# python的遞歸最大層數
import sys
print(sys.getrecursionlimit())
sys.setrecursionlimit(1000)
print('可修改：',sys.getrecursionlimit())

1000
可修改： 1000

# 用一行代碼實現數值交換  a = 1  b = 2
a,b = 1,2
a,b = b,a
print(a,b)

2 1

# 列舉布爾值爲False的常見值
b = ['',0,[],(),{},False,None]
ls = [bool(i) for i in b]
print(ls)

[False, False, False, False, False, False, False]

# lambda 表達式及應用場景

# 匿名函數就是沒有函數名，沒有代碼塊的函數，主要和其餘函數搭配使用
lambda x:x
lambda x,y:x+y

# 通常和內置函數搭配使用：map()  reduce()  sort()

<function __main__.<lambda>(x, y)>

# pass的做用
if 1:
    pass
# 表明過、不進行任何操做的意思，當代碼塊結構還沒編寫完時，可用pass來佔位，（def class while if等）

# *args **kwargs

# 表明不定長參數  args 會把傳入的參數變爲一個元祖，kwargs會把傳入的參數變爲一個字典

def func(name,age,*args,**kwargs):
    print(args)
    print(kwargs)
func('子牙',21,1,'a','b',sex='男')
print('---------------')
# 若是你想把參數打包成一個列表，或者字典穿進去就要在前面加* 或者 **  否則會是以一個總體傳進去
func('子牙',21,[1,2,3],{'height':170,'weight':55})
print('---------------')
func('子牙',21,*[1,2,3],**{'height':170,'weight':55})

(1, 'a', 'b')
{'sex': '男'}
---------------
([1, 2, 3], {'height': 170, 'weight': 55})
{}
---------------
(1, 2, 3)
{'height': 170, 'weight': 55}

# is 和 == 的區別

# is 判斷的不只僅是值相等，還判斷他們的內存地址是否相同，同 id()  == 僅僅判斷值相等

a = 1
b = 1

print(a,b)
print(a == b)
print(a is b)
print(id(a),id(b))

t1 = (1,2)
t2 = (1,2)
print(t1 is t2)

# 上面a is b爲True是由於在python的解釋權裏面。簡單的數據解釋器裏就一份。好比None、False、0、一、二、三、True等  
n1 = 1234
n2 = 1234
print(n1 is n2)
print(n1 == n2)

a = True
b = True
print(a is b)
print(a == b)
print(id(a),id(b))

1 1
True
True
1882483744 1882483744
False
False
True
True
True
1881993376 1881993376

# 簡述Python的深淺拷貝以及應用場景

# 拷貝就是源對象數據的複製，佔用不一樣的內存空間
# 對於不可變數據類型。數字和字符串。賦值、深淺拷貝無區別，拷貝先後都是引用同一塊內存地址，因此拷貝具備減小內存空間的特色。
# 對於可變數據類型。列表、字典、元祖等能夠相互嵌套，當構造出一些複雜的數據類型的時候
# 淺拷貝：只拷貝最外層的對象，也就是最外層的值同樣。內存地址卻不同。而內層的值同樣，內存地址也同樣
# 深拷貝，它裏面嵌套多少層，就會拷貝多少層出來，可是最底層的數字和字符串地址不變。

# 應用場景：數據入庫、修改或者清洗的時候，拷貝源數據進行操做。防止對源數據形成修改，
# 拷貝就是在內存中從新開闢一個內存，數據一致，內存之間自己數據不共享，淺拷貝(數據半共享，拷貝出來的獨立)、深拷貝(數據徹底不共享，獨立)

# Python的垃圾回收機制

# python採用的是引用計數機制爲主、標記-清除和分代收集兩種機制爲輔

# 引用計數：跟蹤和回收垃圾
# 標記-清除：解決容器對象可能產生循環引用的問題
# 分代回收：活的越長的對象、越不多是垃圾。以空間換取時間來進一步提升垃圾回收的效率

# python的可變類型和不可變類型

# 可變：列表、字典、集合
# 不可變：字符串、數字、元祖

# 求結果
v = dict.fromkeys(['k1','k2'],[])
print(v)
v['k1'].append(666)
# 由於k1 \k2 的value引用的是同一個列表的內存地址，因此，改變k1的值，k2也會變。
print(v)
v['k1'] = 777
# 對k1進行賦值操做，不會影響k2
print(v)

{'k1': [], 'k2': []}
{'k1': [666], 'k2': [666]}
{'k1': 777, 'k2': [666]}

# 求res的值
def num():
    # a = [lambda x:0,lambda x:x,lambda x:2*x,lambda x:3*x]
    b = [lambda x:i*x for i in range(4)]
    return b

res = []
for i in num():
    res.append(i(2))

print(res)

# 這題有個誤區

[6, 6, 6, 6]

# filter、map、reduce的做用

# 這三個函數一般都是與lambda搭配使用，第一個參數一般爲一個函數，第二個參數爲一個可迭代對象

# map() 會把後面的可迭代對象，依次傳給前面的lambda函數，
res = list(map(lambda name:name.title(),['python','java','linux']))
print(res)

# filter() 和 map()類似，可是若是入參的值爲False ，則跳過，不進行處理
res = filter(lambda x:x,[0,1,2,3,None,'hello'])
print(list(res))

['Python', 'Java', 'Linux']
[1, 2, 3, 'hello']

#### 一行代碼實現9*9的乘法表

print('\n'.join([''.join([('%s * %s = %-3s ')%(i,j,j*i) for j in range(1,i+1)]) for i in range(1,10)]))

# re模塊的match和search的區別

import re

# match()：嘗試從頭開始匹配，若是不是起始位置匹配成功，則返回None 
s = 'jiangwei is a good good good boy'
res = re.match('jiangwei',s)
res1 = re.match('good',s)
print(res)
print(res1)

# search()：嘗試掃描整個字符串，返回第一個匹配成功的
s = 'jiangwei is a good good good boy'
res = re.search('good',s)
print(res)

<_sre.SRE_Match object; span=(0, 8), match='jiangwei'>
None
<_sre.SRE_Match object; span=(14, 18), match='good'>

# 什麼是正則的貪婪匹配

# 嘗試儘量多的匹配字符串：通常使用 * 表明貪婪匹配
# 非貪婪模式：通常在 * 後面加個 ?
# 默認會貪婪匹配

# 求結果

res= [ i % 2 for i in range(10)]
# range(10)獲得一個可迭代對象  裏面的每個元素對2取餘  [0，1,0,1,0,1,0,1,0,1]
print(res,type(res))

res = (i % 2 for i in range(10))
# 和上面同樣，可是不是列表了，是一個生成器
print(res, type(res))

[0, 1, 0, 1, 0, 1, 0, 1, 0, 1] <class 'list'>
<generator object <genexpr> at 0x00000243FC767780> <class 'generator'>

# 求結果
a = 1 or 2
print(a)

b = 1 and 2
print(b)

c = 1 < (2 == 2)
print(c)

d = 1 < 2 == 2
print(d)

1
2
False
False

# def func(a,b=[]) 這種寫法有什麼坑？

# 默認參數b是一個列表，確定有問題，列表是可變的數據類型

def func1(a,b=[]):
    b.append(a)
    print(b)
    
func1(0)
func1(1)
func1(2)

# 第一次調用函數的時候，b實例化了一個列表。
# 第二次調用的時候，列表b裏面已經有一個值了，因此，第二次調用時，雖然不傳參，可是b並非空列表。
# 因此儘可能不要用可變類型做爲參數

[0]
[0, 1]
[0, 1, 2]

# 如何實現 「1,2,3」 變成 [‘1’,’2’,’3’] ?

# 字符串變列表、能夠經過切割來實現
s = '1,2,3'
res = s.split(',')
print(res)

['1', '2', '3']

# 如何實現[‘1’,’2’,’3’]變成[1,2,3] ?

# 自己的數據類型並沒變、而是裏面的元素的數據類型變了，能夠用到列表生成式
ls = ['1','2','3']
res = [int(item) for item in ls]
print(res)

[1, 2, 3]

# 比較： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的區別？

a = [1,2,3]
b = [(1),(2),(3)]
c = [(1,),(2,),(3,)]

# 第一種無區別  先來看看數據類型加括號是怎麼一回事  雖然外面套了一層括號  可是是以括號內的數據類型的最小單位來聲明
num = (1)
print(num)
ls = ([])
print(ls)
tp = (())
print(tp)
dic = ({})
print(dic,type(dic))

# 第二種有區別  括號內的元素加了逗號，實際上是元祖。

print(a)
print(b)

print(c)
# 因此當你定義只有一個元素的元祖時。要加括號

1
[]
()
{} <class 'dict'>
[1, 2, 3]
[1, 2, 3]
[(1,), (2,), (3,)]

# 如何用一行代碼生成[1,4,9,16,25,36,49,64,81,100] ?
print([num**2 for num in range(1,11)])

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 一行代碼實現刪除列表中重複的值 ?
ls = [1,1,2,3,0,0,4,5]

# 若是是簡單的去重的話。用到集合就能夠，有去重的效果，
print(list(set(ls)))

# 若是想保持原來的位置\
print(sorted(list(set(ls)),key=ls.index))

# 還有一個就是sote()函數，可是它是對原列表進行修改，而不是生成新列表
ls3 = list(set(ls))
ls3.sort(key=ls.index)
print(ls3)

[0, 1, 2, 3, 4, 5]
[1, 2, 3, 0, 4, 5]
[1, 2, 3, 0, 4, 5]

# 如何在函數中設置一個全局變量 ?

n = 1
def func():
    global n
    n = 2
print(n)
func()
print(n)

1
2

# logging模塊的做用？以及應用場景？

# python內置的日誌模塊，用來記錄一些用戶的操做日誌，包括服務器運行狀態的信息。

# 請用代碼簡答實現stack 。

# stack是一種容器類數據類型。叫作棧，先進後出，就像咱們往桌子上放一本本書，最後放的先拿出來。
# queen是一種與它類似的一種數據類型，叫作隊列。可是是先進先出

# 實現棧，能夠利用python自帶的list來實現，list是一種線性數據結構。

class Stack(object):
    
    def __init__(self):
        self.stack = []
    
    def pop(self):
        # 出棧
        if self.is_empty():
            raise ValueError('棧空了')
        return self.stack.pop()
    
    def push(self,val):
        # 進棧
        self.stack.append(val)
    
    def top(self):
        # 查看最新元素:棧頂
        return self.stack[-1]
    
    def is_empty(self):
        # 是否爲空
        return len(self.stack) == 0
    
    def __iter__(self):
        return iter(self.stack)
    
    def __len__(self):
        return len(self.stack)
    
    def __str__(self):
        return '%s'%self.stack
    
    
stack = Stack()

stack.push(1)
stack.push(2)
stack.push(3)

print('%s出棧'%stack.pop())
stack.push(4)
print('棧的長度%s'%len(stack))
print(stack)
print('棧是否爲空',stack.is_empty())
print('棧頂%s'%stack.top())
print('%s出棧'%stack.pop())
print('%s出棧'%stack.pop())
print('%s出棧'%stack.pop())

3出棧
棧的長度3
[1, 2, 4]
棧是否爲空 False
棧頂4
4出棧
2出棧
1出棧

# 常見的字符串格式化有哪幾種

# 第一種：佔位符
name = 'Jzy'
age = 22
print('my name is %s,i am %d years old' % (name, age))

# 第二種format
# 經過變量
print('my name is {0},i am {1} years old '.format(name,age))
# 經過位置
data = ['Jzy',22]
print('my name is {0},i am {1} years old '.format(*data))
# 經過關鍵字
data = {'name':'Jzy','age':22}
print('my name is {name},i am {age} years old '.format(**data))

# 新特性
print(f'my name is {name},i am {age} years old')

my name is Jzy,i am 22 years old
my name is Jzy,i am 22 years old 
my name is Jzy,i am 22 years old 
my name is Jzy,i am 22 years old 
my name is Jzy,i am 22 years old

# 減速生成器、迭代器、可迭代對象以及應用場景

迭代器：
生成器：
可迭代對象：

# 用python寫一個二分查找

# 談談你對閉包的理解

# os和sys模塊的做用

# 如何生成一個隨機數

# 如何用python刪除一個文件

# 談談你對面向對象的理解

'''
在任何一門編程語言中，面向對象通常都具備封裝、繼承、多態三大特性。

封裝：
    - 將同類方法和屬性封裝到類中
    - 將屬性封裝到對象中：__init__()
    - 好比：定義一我的類，每個人就是一個個對象。而後每一個人都有跑步、睡覺等行爲，就能夠將這兩個行爲封裝到人類這個類中。每一個人都有姓名、年齡等特徵。就能夠封裝到對象的__init__()方法中。
    - 使用：自定義的分頁、rest_framework源碼中的request進行了封裝 
繼承：
    - 將多個類的同類方法和屬性抽取到基類中，抽取共性。
    - 解決了代碼的冗餘
多態：
    - 一種事物的多態類型
    - 鴨子類型，走起來像鴨子，叫起來像鴨子，那它就是鴨子。
    - 無論對象是什麼類型，只要有那個方法就行。
    - 好比說，定義一個動物類和一我的類。它們都實現了跑步這個方法，就能夠定義一個公共函數，把這兩個類的對象看成參數傳進去，參數.run()方法。對於這個參數來講，它具備多種形態。體現了python的多態性。
    - python自帶的也有體現，好比說len()方法。能夠傳字符串對象。列表對象。元祖對象。就能夠計算出它的長度。

'''

# Python中面向對象中的繼承有什麼特色

# 面向對象深度優先和廣度優先是什麼？

# 面向對象中super的做用

# 是否使用過functools中的函數，其做用是什麼？

# 列舉面向對象中帶雙下劃線的特殊方法

# 如何判斷是函數仍是方法

# 之前我認爲寫在類裏面的就是方法，寫在類外面的就是函數，其實不是
# 應該根據調用者來判斷
from types import FunctionType,MethodType

def func():
    pass

class Foo(object):
    
    def __init__(self):
        pass
    
    def func1(self):
        pass

obj = Foo()
print(isinstance(func,FunctionType),type(func))         # 函數
print(isinstance(obj.func1,MethodType),type(obj.func1)) # 對象調用是方法
print(isinstance(Foo.func1,FunctionType),type(Foo.func1)) # 類調用倒是函數

True <class 'function'>
True <class 'method'>
True <class 'function'>

# 靜態方法和類方法區別

# 靜態方法不管是對象仍是類均可以直接調用：@staticmethod
# 類方法只能類調用，切第一個參數必須爲類

# 列舉面向對象中的特殊成員以及應用場景

# 一、二、三、四、五、能組成多少個互不相同且無重複的三位數

# 什麼是反射？以及應用場景

# 反射是根據字符串去映射對象中的方法或屬性

# django的cbv中，self.dispath根據反射來獲取請求的method從而進行不一樣的處理。

# metaclass的做用？以及應用場景

# 用盡可能多的方法實現單例模式

# python有着純自然的單例模式，導入屢次相同模塊或者包，都只有一個對象

# 使用裝飾器
def singleton(cls):
    _instance = {}

    def inner(*args, **kwargs):
        if cls not in _instance:
            _instance[cls] = cls(*args, **kwargs)
        return _instance[cls]
    return inner


@singleton
class A:
    pass


a1 = A()
a2 = A()
print(id(a1))
print(id(a2))

# 使用__new__()
class A:
    _instance = None

    def __new__(cls):
        if not cls._instance:
            cls._instance = super(A, cls).__new__(cls)
        return cls._instance


a1 = A()
a2 = A()
print(id(a1))
print(id(a2))

# 裝飾器的寫法，以及應用場景

def wraper(func):
    """
    爲被裝飾函數加一個打印參數的值的功能
    """
    def inner(*args,**kwargs):
        print('這是函數的參數',args,kwargs)
        return func(*args,**kwargs)
    return inner

@wraper
def func(*args,**kwargs):
    print('我被裝飾了')
    return 1

res = func(1,2,**{'name':'Jzy','age':22})
print(res)

# 裝飾器自己就是遵循對外開放擴展，對內封閉不修改

這是函數的參數 (1, 2) {'name': 'Jzy', 'age': 22}
我被裝飾了
1

# 異常處理寫法以及如何主動拋出異常

# 什麼是面向對象的mro

# isinstance做用，以及應用場景

# json序列化時，能夠處理的數據類型有哪些，如何定製支持datetime類型

# json序列化時，默認遇到中文會轉換成unicode，若是想要保留中文怎麼辦？

# 什麼是斷言，以及應用場景

# 有用過with statement嗎？它的好處是什麼

# 使用代碼實現列舉目錄下的全部文件

# 簡述yield和yield from關鍵字

001---基礎部分