關鍵字is 和 == 的區別

a = 'hello world'
b = 'hello world'
a == b  #回傳True 
a is b  #回傳False 
注意：is 判斷是否是一個ID， == 判斷內容是否一致，

深拷貝和淺拷貝

import copy
a = [1,2,3,4,5]
b = a   #淺拷貝，a,b同時指向一個id,當其中一個修改時，另外一個也會被修改，
c = copy.deepcopy(a) #深拷貝，c單獨開辟一個id,用來存盤和a一樣的內容，
d =a[:] #這樣也是深拷貝，
e = copy.copy(a) #當拷貝內容是可變型別時，那么就會進行深拷貝，如果是不可變型別時，那么就會進行淺拷貝，

注意：深拷貝指的是復制內容，單獨開辟一個記憶體，淺拷貝指的是兩個變數同時指向一個記憶體ID，

私有化和Property

class Test(object):
	def __init__(self):
		self.__num = 100
	@getNum.setter #等同步于 porperty(setNum,getNum)
	def setNum(self,num): #將self.__num的屬性封裝，
		self.__num = num
	@porperty #等于getNum = porperty(getNum) 默認的是getter方法，
	def getNum(self) #獲取__num的值，
		return self.__num
	num = porperty(getNum,setNum) #使用關鍵字porperty將getNum和setNum方法打包使用，并將參考賦予屬性num，
t = Test()
print(t.__num) #將會出錯，表示輸出私有屬性，外部無法使用，
t.__num = 200  #這里將會理解為添加屬性 __num = 200,而不是重新賦值私有屬性，
print(t.__num) #這里輸出的200是定義的屬性__num，而不是self.__num， 
t.setNum(200) #通過set方法將私有屬性重新賦值，
t.getNum() #通過get方法獲取__num的值，
print(_Test__num) #私有屬性其實是系統再私有屬性前加上了一個_Test，就是一個下劃線加類名，
 
t.num = 300 #呼叫類屬性num,并重新賦值，porperty會自動檢測set方法和get方法，并將參考賦值給set方法，
print(t.num) #輸出類屬性，并會自己檢測使用get方法進行輸出，

注意： num 前后沒有下劃線的是公有方法，_num 前邊有一個下劃線的為私有方法或屬性，子類無法繼承， 前邊有兩個下劃線的 一般是為了避免于子類屬性或者方法名沖突，無法在外部直接訪問，前后都有雙下劃線的為系統方法或屬性，后邊單個下劃線的可以避免與系統關鍵詞沖突，

串列生成式

range(1,100,5) #第一個引數表示開始位，第二個引數表示結束位（不含），第三個引數表示步長，就是每5個數回傳一次，
a = [i for i in range(1,10)] #串列生成式表示回傳i的值，并且回傳9次，每次回傳的是i的值，
a = [2 for i in range(1,10)] #這里表示回傳2，并且回傳9次，但是每次的值都是2，
a = [i for i in range10 if i%2==0] #表示在生成式內部加入if判斷，當i除以2的余數等于0的時候將數值回傳，
a = [(i,j) for i in range(5) for j in range(5)] #表示將i和j的值以元組為元素的形式回傳，當i回圈一次的時候j回圈5次，以此類推，
生成器
a = (i for i in range(1,10)) #將串列生成試外部的中括號改為小括號，就能將生成式轉化為生成器，
next(a),a.__next__() #生成器的取值方式只能使用next的方法，
def num():
	a,b = 0,1
	for i in range(10):
		yield b  #生成關鍵字yield，有yield的關鍵字的代碼塊就是yield的生成器，當運行到yield時代碼就會停止，并回傳運行結果，當在次運行時依舊是到yield停止，并回傳結果， 切記：生成器只能使用next方法，
		a,b = b,a+b
		temp = yield b  #這里并不是變數的定義，當運行到yield時就會停止，所以當運行到等號右邊的時候就會停止運行，當在次使用next的時候，將會把一個None賦值給temp，因為b的值已經在上輪回圈中輸出，這里可以使用num().send()方法將一個新的值賦值給temp，
a = num()  #將生成器賦值給變數a，
for n in a:  #生成器可以使用for回圈使用，并且不會出錯，
	print(n) 

注意：生成器占用記憶體小，在使用的時候取值，降低CPU和記憶體空間，提高效率，并且一般都使用for回圈進行取值，

迭代器

for i in '',[],(),{},{:}
#可以for回圈的物件是可迭代物件，
a = (x for i in range(100))
#串列生成式，把中括號改為小括號就可以變為一個串列生成器，是可迭代物件，
from collections import Iterable #如果想驗證是否是可迭代物件，可以使用isinstance()判斷是否是可迭代物件，
isinstance('abc',Ierable) #判斷語法
a = [1,2,3,4,5]
b = iter(a)  #使用iter()方法可以將可迭代物件轉換為可迭代物件，

注意：生成器是可迭代物件，迭代器不一定是生成器，并且迭代器無法回取，只能向前取值，

注意：一個物件具有 iter 方法的才能稱為可迭代物件，使用yield生成的迭代器函式，也有iter方法，凡是沒有iter方法的物件不是可迭代物件，凡是沒有__next__()方法的不是是生成器，（這里的方法都是魔法方法，是內置方法，可以使用dir（）查看）

閉包

def num(num): #定義函式
	def num_in(nim_in): #定義函式
		return num + num_in #回傳兩個引數的和，
	return num_in #回傳內部函式的參考，（變數名）
 
a = num(100) #將引數為100的函式num接收，并賦值給a，只不過這個回傳值是一個函式的參考，等于 a = num_in，注意這里接收的不光是函式本身，還有已經傳遞的引數，
b = a(100) #呼叫函式a,即num_in，并傳遞一個引數100，回傳值給b，

注意：當一個函式定義在另一個函式內，且使用到了外部函式的引數，整個代碼塊稱為閉包，當外部引數確定時，內部函式引數可以反復呼叫，

裝飾器

裝飾沒有引數的函式

def function(func): #定義了一個閉包
	def func_in(): #閉包內的函式
		print('這里是需要裝飾的內容，就是需要添加的內容')
		func() #呼叫實參函式，
	return func_in
	
def test(): 	#需要被裝飾修改的函式，
	print('無參函式的測驗')
	
test = function(test) 	#裝飾器的原理就是將原有的函式名重新定義為以原函式為引數的閉包，
test() 這里再次掉用test()的時候，其實是將會呼叫閉包內的函式func_in()，所以將會起到裝飾修改的作用，最后會再次呼叫原函式test()，

@function 	#裝飾器的python寫法，等價于test = function(test)，并且無需呼叫當代碼運行道這里，Python會自動運行，
def test():
	print('無參函式的測驗')
test() 	#這里再次呼叫函式時，將會產生修改后的效果，

裝飾帶有引數的函式

def function(func): #定義了一個閉包
	def func_in(*args,**kwargs): 	#閉包內的函式，因為裝飾器運行的實則是閉包內的函式，所以這里將需要有形參用來接收原函式的引數，
		print('這里是需要裝飾的內容，就是需要添加的內容')
		func(*args,**kwargs) 	#呼叫實參函式，并傳入一致的實參，
	return func_in
	
@function	 #裝飾器的python寫法，等價于test = function(test) .
def test():
	print('無參函式的測驗')
	
test(5，6) 	#這里再次掉用test()的時候，其實是將會呼叫閉包內的函式func_in()，所以將會起到裝飾修改的作用，最后會再次呼叫原函式test()，

裝飾帶有回傳值的函式

def function(func): #定義了一個閉包
	def func_in(*args,**kwargs): #閉包內的函式，因為裝飾器運行的實則是閉包內的函式，所以這里將需要有形參用來接收原函式的引數，
		print('這里是需要裝飾的內容，就是需要添加的內容')
		num = func(*args,**kwargs) #呼叫實參函式，并傳入一致的實參，并且用變數來接收原函式的回傳值，
		return num #將接受到的回傳值再次回傳到新的test()函式中，
	return func_in
@function
def test(a,b): #定義一個函式
	return a+b #回傳實參的和

通用裝飾器

def function(func): #定義了一個閉包
	def func_in(*args,**kwargs): 	#閉包內的函式，因為裝飾器運行的實則是閉包內的函式，所以這里將需要有形參用來接收原函式的引數，
		print('這里是需要裝飾的內容，就是需要添加的內容')
		num = func(*args,**kwargs) 	#呼叫實參函式，并傳入一致的實參，并且用變數來接收原函式的回傳值，
		return num 	#將接受到的回傳值再次回傳到新的test()函式中，
	return func_in

帶有引數的裝飾器

def func(*args,**kwags):
	def function(func): #定義了一個閉包
		def func_in(*args,**kwargs): #閉包內的函式，因為裝飾器運行的實則是閉包內的函式，所以這里將需要有形參用來接收原函式的引數，
			print('這里是需要裝飾的內容，就是需要添加的內容')
			num = func(*args,**kwargs) #呼叫實參函式，并傳入一致的實參，并且用變數來接收原函式的回傳值，
			return num #將接受到的回傳值再次回傳到新的test()函式中，
		return func_in
	return function
 
@func(50)  #這里會先運行函式func，并切傳入引數，之后會再次運行閉包函式進行裝飾, @func(50)>>@function，然后將由@function繼續進行裝飾修改，
def test(a,b):
	print('這是一個函式')
	return a+b

class Test(object): #定義一個類
   def __init__(self，func):
   	self.__func = func
   def __call__(self):  #定義call方法，當直接呼叫類的時候，運行這里，
   	print('這里是裝飾的功能')
   	self.__func()	
t = Test() #實體化物件
t() #呼叫類，將會呼叫call方法，

@Test  #類裝飾器等于test = Test(test),將函式test當作引數傳入類中的init方法，并將函式名賦值給私有屬性__func，當函式test被呼叫的時候，其實是運行Test類中的call方法.
def test():
   print('被裝飾的函式')
test() #這里呼叫的不在是函式test，而是實體物件test的call方法，會先進行裝飾，然后再呼叫私有屬性__func(),__func 其實就是被裝飾的函式test，

動態語言添加屬性和方法

class Person(): #創建一個類
	def __init__(self,name): #定義初始化資訊，
		self.name = name 
li = Person('李')  #實體化Person('李'),給變數li
li.age = 20  #再程式沒有停止下，將實體屬性age傳入，動態語言的特點，
Person.age = None  #這里使用類名來創建一個屬性age給類，默認值是None，Python支持的動態屬性添加，
def eat(self): #定義一個方法，不過這個方法再類之外，
	print('%s正在吃東西，，'%self.name) 
import types  #動態添加方法需要使用tpyes模塊，
li.eat = types.MethodType(eat,li) #使用types.MethodType，將函式名和實體物件傳入，進行方法系結，并且將結果回傳給li.eat變數，實則是使用一個和li.eat方法一樣的變數名用來呼叫，
li.eat() #呼叫外部方法eat()方法，
 
@staticmethod  #定義靜態方法，
def test():  #定義靜態方法，靜態方法可以不用self引數，
	print('這是一個靜態方法，')
Person.test = test  #使用類名.方法名 = test的形式來方便記憶和使用，Person.test其實只是一個變數名，沒有特殊的含義，
Person.test()  #呼叫test方法，
 
@classmethod  #類方法
def test(cls): 
	print('這是一個類方法，')
Person.test = test #定義一個類屬性等于方法名，
Person.test() #呼叫方法，
 
class test(object): #定義一個類，
	__slots__ = ('name','age') #使用slots來將屬性固定，不能進行動態添加修改，

元類

創建帶有類屬性的類

Test = type('Test',(object,),{'num':0}  #元類是只使用type創建的類，使用type會有3個引數，第一個是類名，第二個小括號內是父類名，需要使用元組，第三個字典中是類屬性，使用type能夠快速的動態創建一個類，
class Test(object):  #創建一個類，等價于上邊
	num = 0

創建帶有方法的類

def eat(self):  #定義一個函式，self作為第一個引數，
	print ('%s正在吃飯，，'%self.name)
Person = type('Person',(object,), {'eat':eat,'name':None}  #使用type創建一個類，但是有兩個屬性，一個是eat,一個是name,但是eat的值是函式eat的參考，
p = Person()  #實體化
p.name = 'Tom'  #類屬性賦值
p.eat()  #呼叫eat()方法，

內建屬性

__init__ #構造初始化函式,__new__之后運行
__new__ #創建實體所需的屬性
__class__ #實體所在的類，實體.__class__
__str__ #實體的字串表示，可讀性高
__repr__ #實體的字串表示，準確性高
__del__ #洗掉實體參考
__dict__ #實力自定義屬性，vars(實體.__dict__)
__doc__ #類檔案，help(類或者實體)
__bases__ #當前類的所有父類
__getattribute__ #屬性訪問攔截器，

內建方法

range(start,stop,[,step]) #生成器
map(function, iterable, ...) # map() 會根據提供的函式對指定序列做映射，
filter(function, iterable) #filter() 函式用于過濾序列，過濾掉不符合條件的元素，回傳由符合條件元素組成的新串列，
reduce(function, iterable[, initializer]) #reduce() 函式會對引數序列中元素進行累積，
sorted(iterable[, cmp[, key[, reverse]]]) #sorted() 函式對所有可迭代的物件進行排序操作，sort 與 sorted 區別：
sort 是應用在 list 上的方法，sorted 可以對所有可迭代的物件進行排序操作，
list 的 sort 方法回傳的是對已經存在的串列進行操作，而內建函式 sorted 方法回傳的是一個新的 list，而不是在原來的基礎上進行的操作，

PDB除錯

1.python -m pdb xxx.py  #在命令列輸入以上命令，進入pdb除錯模式，XXX.py表示需要打開的檔案，
2.import pdb
pdb.run('func(*args)') #第二種方式，當程式在運行中除錯，
3.pdb.set_trace() #第三種方法，當程式運行到這行代碼時，就會自動運行，
l(list) # 顯示全部代碼
n(next) # 向下執行一行代碼
c(contiune) # 執行余下的代碼
b(break) 10 # 設定斷點，b 10表示將斷點設定到第10行，clear 1,洗掉第一個斷點
p(print) a,b #列印變數的值
a(args) #列印全部的形參資料
s(step) #進入到一個函式
r(return) #快速執行到函式的最后一行