1.1==，is的使用
·is是比較兩個引用是否指向了同一個對象（引用比較）。
·==是比較兩個對象是否相等。
1.2深拷貝、淺拷貝
1.2.1淺拷貝
淺拷貝是對于一個對象的頂層拷貝
通俗的理解是：拷貝了引用，并沒有拷貝內容
1.2.2深拷貝
copy.deepcopy
1.2.3拷貝的其他方式
淺拷貝對不可變類型和可變類型的copy不同
In [88]: a = [11,22,33]
In [89]: b = copy.copy(a)
In [90]: id(a)
Out[90]:59275144
In [91]: id(b)
Out[91]:59525600
In [92]: a.append(44)
In [93]: a
Out[93]: [11,22,33,44]
In [94]: b
Out[94]: [11,22,33]
In [95]:
In [95]:
In [95]: a = (11,22,33)
In [96]: b = copy.copy(a)
In [97]: id(a)
Out[97]:58890680
In [98]: id(b)
Out[98]:58890680
·分片表達式可以賦值一個序列
a ="abc"
b = a[:]
·字典的copy方法可以拷貝一個字典
d = dict(name="zhangsan", age=27)
co = d.copy()
·有些內置函數可以生成拷貝(list)
a = list(range(10))
b = list(a)
·copy模塊中的copy函數
importcopy
a = (1,2,3)
b = copy.copy(a)
1.3屬性property
面試題：
1、你對面向對象的理解
2、面向對象的特征是什么
3、對封裝的理解？
封裝，類本身就是一個封裝，封裝了屬性和方法。方法也是封裝，對一些業務邏輯的封裝。私有也是封裝，將一些方法和屬性私有化，對外提供可訪問的接口。
4、對繼承的理解
將共性的內容放在父類中，子類只需要關注自己特有的內容，共性的繼承過來就行了。
這樣簡化開發，符合邏輯習慣，利于擴展。
5、多態的理解
多態，一個對象在不同的情況下顯示不同的形態。在python中因為是弱類型語言，對類型沒有限定，所有python中不完全支持多態，但是多態的思想呢，python也是能體現的。
1.3.1私有屬性添加getter和setter方法
classMoney(object):
def__init__(self):
self.__money =0
defgetMoney(self):
returnself.__money
defsetMoney(self, value):
ifisinstance(value, int):
self.__money = value
else:
print("error:不是整型數字")
1.3.2使用property升級getter和setter方法
classMoney(object):
def__init__(self):
self.__money =0
defgetMoney(self):
returnself.__money
defsetMoney(self, value):
ifisinstance(value, int):
self.__money = value
else:
print("error:不是整型數字")
money = property(getMoney, setMoney)
運行結果:
In [1]:fromget_setimportMoney
In [2]:
In [2]: a = Money()
In [3]:
In [3]: a.money
Out[3]:0
In [4]: a.money =100
In [5]: a.money
Out[5]:100
In [6]: a.getMoney()
Out[6]:100
1.3.3使用property取代getter和setter方法
@property成為屬性函數，可以對屬性賦值時做必要的檢查，并保證代碼的清晰短小，主要有2個作用
·將方法轉換為只讀
·重新實現一個屬性的設置和讀取方法,可做邊界判定
classMoney(object):
def__init__(self):
self.__money =0
@property
defmoney(self):
returnself.__money
@money.setter
defmoney(self, value):
ifisinstance(value, int):
self.__money = value
else:
print("error:不是整型數字")
運行結果
In [3]: a = Money()
In [4]:
In [4]:
In [4]: a.money
Out[4]:0
In [5]: a.money =100
In [6]: a.money
Out[6]:100
1.4生成器
1.4.1什么是生成器
通過列表生成式，我們可以直接創建一個列表。但是，受到內存限制，列表容量肯定是有限的。而且，創建一個包含100萬個元素的列表，不僅占用很大的存儲空間，如果我們僅僅需要訪問前面幾個元素，那后面絕大多數元素占用的空間都白白浪費了。所以，如果列表元素可以按照某種算法推算出來，那我們是否可以在循環的過程中不斷推算出后續的元素呢？這樣就不必創建完整的list，從而節省大量的空間。在Python中，這種一邊循環一邊計算的機制，稱為生成器：generator。
1.4.2創建生成器方法1
要創建一個生成器，有很多種方法。第一種方法很簡單，只要把一個列表生成式的[ ]改成( )
In [15]: L = [ x*2forxinrange(5)]
In [16]: L
Out[16]: [0,2,4,6,8]
In [17]: G = ( x*2forxinrange(5))
In [18]: G
Out[18]: at0x7f626c132db0>
In [19]:
創建L和G的區別僅在于最外層的[ ]和( )，L是一個列表，而G是一個生成器。我們可以直接打印出L的每一個元素，但我們怎么打印出G的每一個元素呢？如果要一個一個打印出來，可以通過next()函數獲得生成器的下一個返回值：
In [19]: next(G)
Out[19]: 0
In [20]: next(G)
Out[20]: 2
In [21]: next(G)
Out[21]: 4
In [22]: next(G)
Out[22]: 6
In [23]: next(G)
Out[23]: 8
In [24]: next(G)
---------------------------------------------------------------------------
StopIteration ????????????????????????????Traceback (most recent call last)
in ()
----> 1 next(G)
StopIteration:
In [25]:
In [26]: G = ( x*2forxinrange(5))
In [27]:forxinG:
....: ????print(x)
....:
0
2
4
6
8
In [28]:
生成器保存的是算法，每次調用next(G)，就計算出G的下一個元素的值，直到計算到最后一個元素，沒有更多的元素時，拋出StopIteration的異常。當然，這種不斷調用next()實在是太變態了，正確的方法是使用for循環，因為生成器也是可迭代對象。所以，我們創建了一個生成器后，基本上永遠不會調用next()，而是通過for循環來迭代它，并且不需要關心StopIteration異常。
1.4.3創建生成器方法2
generator非常強大。如果推算的算法比較復雜，用類似列表生成式的for循環無法實現的時候，還可以用函數來實現。
比如，著名的斐波拉契數列（Fibonacci），除第一個和第二個數外，任意一個數都可由前兩個數相加得到：
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
斐波拉契數列用列表生成式寫不出來，但是，用函數把它打印出來卻很容易：
In [28]:deffib(times):
....: ????n =0
....: ????a,b =0,1
....:whilen
....: ????????print(b)
....: ????????a,b = b,a+b
....: ????????n+=1
....:return'done'
....:
In [29]: fib(5)
1
1
2
3
5
Out[29]:'done'
仔細觀察，可以看出，fib函數實際上是定義了斐波拉契數列的推算規則，可以從第一個元素開始，推算出后續任意的元素，這種邏輯其實非常類似generator。
也就是說，上面的函數和generator僅一步之遙。要把fib函數變成generator，只需要把print(b)改為yield b就可以了：
In [30]: def fib(times):
....: ????n = 0
....: ????a,b = 0,1
....: ????while n
....: ????????yield b
....: ????????a,b = b,a+b
....: ????????n+=1
....: ????return 'done'
....:
In [31]: F = fib(5)
In [32]: next(F)
Out[32]: 1
In [33]: next(F)
Out[33]: 1
In [34]: next(F)
Out[34]: 2
In [35]: next(F)
Out[35]: 3
In [36]: next(F)
Out[36]: 5
In [37]: next(F)
---------------------------------------------------------------------------
StopIteration ????????????????????????????Traceback (most recent call last)
in ()
----> 1 next(F)
StopIteration: done
在上面fib的例子，我們在循環過程中不斷調用yield，就會不斷中斷。當然要給循環設置一個條件來退出循環，不然就會產生一個無限數列出來。同樣的，把函數改成generator后，我們基本上從來不會用next()來獲取下一個返回值，而是直接使用for循環來迭代：
In [38]:forninfib(5):
....: ????print(n)
....:
1
1
2
3
5
In [39]:
但是用for循環調用generator時，發現拿不到generator的return語句的返回值。如果想要拿到返回值，必須捕獲StopIteration錯誤，返回值包含在StopIteration的value中：
In [39]: g = fib(5)
In [40]:whileTrue:
....:try:
....: ????????x = next(g)
....: ????????print("value:%d"%x)
....:exceptStopIterationase:
....: ????????print("生成器返回值:%s"%e.value)
....:break
....:
value:1
value:1
value:2
value:3
value:5
生成器返回值:done
In [41]:
1.4.4send
例子：執行到yield時，gen函數作用暫時保存，返回i的值;temp接收下次c.send("python")，send發送過來的值，c.next()等價c.send(None)
In [10]:defgen():
....: ????i =0
....:whilei<5:
....: ????????temp =yieldi
....: ????????print(temp)
....: ????????i+=1
....:
使用next函數
In [11]: f = gen()
In [12]: next(f)
Out[12]: 0
In [13]: next(f)
None
Out[13]: 1
In [14]: next(f)
None
Out[14]: 2
In [15]: next(f)
None
Out[15]: 3
In [16]: next(f)
None
Out[16]: 4
In [17]: next(f)
None
---------------------------------------------------------------------------
StopIteration ????????????????????????????Traceback (most recent call last)
in ()
----> 1 next(f)
StopIteration:
使用__next__()方法
In [18]: f = gen()
In [19]: f.__next__()
Out[19]: 0
In [20]: f.__next__()
None
Out[20]: 1
In [21]: f.__next__()
None
Out[21]: 2
In [22]: f.__next__()
None
Out[22]: 3
In [23]: f.__next__()
None
Out[23]: 4
In [24]: f.__next__()
None
---------------------------------------------------------------------------
StopIteration ????????????????????????????Traceback (most recent call last)
in ()
----> 1 f.__next__()
StopIteration:
使用send
In [43]: f = gen()
In [44]: f.__next__()
Out[44]:0
In [45]: f.send('haha')
haha
Out[45]:1
In [46]: f.__next__()
None
Out[46]:2
In [47]: f.send('haha')
haha
Out[47]:3
In [48]:
1.4.5實現多任務
模擬多任務實現方式之一：協程
def test1():
while True:
print("--1--")
yield None
def test2():
while True:
print("--2--")
yield None
t1 = test1()
t2 = test2()
while True:
t1.__next__()
t2.__next__()
總結
生成器是這樣一個函數，它記住上一次返回時在函數體中的位置。對生成器函數的第二次（或第n次）調用跳轉至該函數中間，而上次調用的所有局部變量都保持不變。
生成器不僅“記住”了它數據狀態；生成器還“記住”了它在流控制構造（在命令式編程中，這種構造不只是數據值）中的位置。
生成器的特點：
1.節約內存
2.迭代到下一次的調用時，所使用的參數都是第一次所保留下的，即是說，在整個所有函數調用的參數都是第一次所調用時保留的，而不是新創建的
1.5迭代器
迭代是訪問集合元素的一種方式。迭代器是一個可以記住遍歷的位置的對象。迭代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結束。迭代器只能往前不會后退。
1.5.1可迭代對象
以直接作用于for循環的數據類型有以下幾種：
一類是集合數據類型，如list、tuple、dict、set、str等；
一類是generator，包括生成器和帶yield的generator function。
這些可以直接作用于for循環的對象統稱為可迭代對象：Iterable。
1.5.2判斷是否可以迭代
可以使用isinstance()判斷一個對象是否是Iterable對象：
In [50]:fromcollectionsimportIterable
In [51]: isinstance([], Iterable)
Out[51]:True
In [52]: isinstance({}, Iterable)
Out[52]:True
In [53]: isinstance('abc', Iterable)
Out[53]:True
In [54]: isinstance((xforxinrange(10)), Iterable)
Out[54]:True
In [55]: isinstance(100, Iterable)
Out[55]:False
而生成器不但可以作用于for循環，還可以被next()函數不斷調用并返回下一個值，直到最后拋出StopIteration錯誤表示無法繼續返回下一個值了。
1.5.3迭代器
可以被next()函數調用并不斷返回下一個值的對象稱為迭代器：Iterator。
可以使用isinstance()判斷一個對象是否是Iterator對象：
In [56]:fromcollectionsimportIterator
In [57]: isinstance((xforxinrange(10)), Iterator)
Out[57]:True
In [58]: isinstance([], Iterator)
Out[58]:False
In [59]: isinstance({}, Iterator)
Out[59]:False
In [60]: isinstance('abc', Iterator)
Out[60]:False
In [61]: isinstance(100, Iterator)
Out[61]:False
1.5.4iter()函數
生成器都是Iterator對象，但list、dict、str雖然是Iterable，卻不是Iterator。
把list、dict、str等Iterable變成Iterator可以使用iter()函數：
In [62]: isinstance(iter([]), Iterator)
Out[62]:True
In [63]: isinstance(iter('abc'), Iterator)
Out[63]:True
總結
·凡是可作用于for循環的對象都是Iterable類型；
·凡是可作用于next()函數的對象都是Iterator類型
·集合數據類型如list、dict、str等是Iterable但不是Iterator，不過可以通過iter()函數獲得一個Iterator對象。
·目的是在使用集合的時候，減少占用的內存。
1.6閉包
1.61.1.1什么是閉包.1函數引用
deftest1():
print("--- in test1 func----")
#調用函數
test1()
#引用函數
ret = test1
print(id(ret))
print(id(test1))
#通過引用調用函數
ret()
運行結果:
---intest1 func----
140212571149040
140212571149040
---intest1 func----
1.6.2 什么是閉包
定義一個函數
deftest(number):
#在函數內部再定義一個函數，并且這個函數用到了外邊函數的變量，那么將這個函數以及用到的一些變量稱之為閉包
deftest_in(number_in):
print("in test_in函數, number_in is %d"%number_in)
returnnumber+number_in
#其實這里返回的就是閉包的結果
returntest_in
#給test函數賦值，這個20就是給參數number
ret = test(20)
#注意這里的100其實給參數number_in
print(ret(100))
#注意這里的200其實給參數number_in
print(ret(200))
運行結果：
intest_in函數, number_inis100
120
intest_in函數, number_inis200
220
1.6.3看一個閉包的實際例子：
defline_conf(a, b):
defline(x):
returna*x + b
returnline
line1 = line_conf(1,1)
line2 = line_conf(4,5)
print(line1(5))
print(line2(5))
這個例子中，函數line與變量a,b構成閉包。在創建閉包的時候，我們通過line_conf的參數a,b說明了這兩個變量的取值，這樣，我們就確定了函數的最終形式(y = x + 1和y = 4x + 5)。我們只需要變換參數a,b，就可以獲得不同的直線表達函數。由此，我們可以看到，閉包也具有提高代碼可復用性的作用。
如果沒有閉包，我們需要每次創建直線函數的時候同時說明a,b,x。這樣，我們就需要更多的參數傳遞，也減少了代碼的可移植性。
閉包思考：
1.閉包似優化了變量，原來需要類對象完成的工作，閉包也可以完成
2.由于閉包引用了外部函數的局部變量，則外部函數的局部變量沒有及時釋放，消耗內存
1.7.裝飾器
裝飾器是程序開發中經常會用到的一個功能，用好了裝飾器，開發效率如虎添翼，所以這也是Python面試中必問的問題，但對于好多初次接觸這個知識的人來講，這個功能有點繞，自學時直接繞過去了，然后面試問到了就掛了，因為裝飾器是程序開發的基礎知識，這個都不會，別跟人家說你會Python,看了下面的文章，保證你學會裝飾器。
1.7.1裝飾器的理解
1、先明白這段代碼
####第一波####
deffoo():
print('foo')
foo#表示是函數
foo()#表示執行foo函數
####第二波####
deffoo():
print('foo')
foo =lambdax: x +1
foo()#執行下面的lambda表達式，而不再是原來的foo函數，因為foo這個名字被重新指向了另外一個匿名函數
2、需求來了
初創公司有N個業務部門，1個基礎平臺部門，基礎平臺負責提供底層的功能，如：數據庫操作、redis調用、監控API等功能。業務部門使用基礎功能時，只需調用基礎平臺提供的功能即可。如下：
###############基礎平臺提供的功能如下###############
deff1():
print('f1')
deff2():
print('f2')
deff3():
print('f3')
deff4():
print('f4')
###############業務部門A調用基礎平臺提供的功能###############
f1()
f2()
f3()
f4()
###############業務部門B調用基礎平臺提供的功能###############
f1()
f2()
f3()
f4()
目前公司有條不紊的進行著，但是，以前基礎平臺的開發人員在寫代碼時候沒有關注驗證相關的問題，即：基礎平臺的提供的功能可以被任何人使用。現在需要對基礎平臺的所有功能進行重構，為平臺提供的所有功能添加驗證機制，即：執行功能前，先進行驗證。
老大把工作交給Low B，他是這么做的：
跟每個業務部門交涉，每個業務部門自己寫代碼，調用基礎平臺的功能之前先驗證。誒，這樣一來基礎平臺就不需要做任何修改了。太棒了，有充足的時間泡妹子...
當天Low B被開除了…
老大把工作交給Low BB，他是這么做的：
###############基礎平臺提供的功能如下###############
deff1():
#驗證1
#驗證2
#驗證3
print('f1')
deff2():
#驗證1
#驗證2
#驗證3
print('f2')
deff3():
#驗證1
#驗證2
#驗證3
print('f3')
deff4():
#驗證1
#驗證2
#驗證3
print('f4')
###############業務部門不變###############
###業務部門A調用基礎平臺提供的功能###
f1()
f2()
f3()
f4()
###業務部門B調用基礎平臺提供的功能###
f1()
f2()
f3()
f4()
過了一周Low BB被開除了…
老大把工作交給Low BBB，他是這么做的：
只對基礎平臺的代碼進行重構，其他業務部門無需做任何修改
###############基礎平臺提供的功能如下###############
defcheck_login():
#驗證1
#驗證2
#驗證3
pass
deff1():
check_login()
print('f1')
deff2():
check_login()
print('f2')
deff3():
check_login()
print('f3')
deff4():
check_login()
print('f4')
老大看了下Low BBB的實現，嘴角漏出了一絲的欣慰的笑，語重心長的跟Low BBB聊了個天：
老大說：
寫代碼要遵循開放封閉原則，雖然在這個原則是用的面向對象開發，但是也適用于函數式編程，簡單來說，它規定已經實現的功能代碼不允許被修改，但可以被擴展，即：
·封閉：已實現的功能代碼塊
·開放：對擴展開發
如果將開放封閉原則應用在上述需求中，那么就不允許在函數f1、f2、f3、f4的內部進行修改代碼，老板就給了Low BBB一個實現方案：
defw1(func):
definner():
#驗證1
#驗證2
#驗證3
func()
returninner
@w1
deff1():
print('f1')
@w1
deff2():
print('f2')
@w1
deff3():
print('f3')
@w1
deff4():
print('f4')
對于上述代碼，也是僅僅對基礎平臺的代碼進行修改，就可以實現在其他人調用函數f1 f2 f3 f4之前都進行【驗證】操作，并且其他業務部門無需做任何操作。
Low BBB心驚膽戰的問了下，這段代碼的內部執行原理是什么呢？
老大正要生氣，突然Low BBB的手機掉到地上，恰巧屏保就是Low BBB的女友照片，老大一看一緊一抖，喜笑顏開，決定和Low BBB交個好朋友。
詳細的開始講解了：
單獨以f1為例：
defw1(func):
definner():
#驗證1
#驗證2
#驗證3
func()
returninner
@w1
deff1():
print('f1')
python解釋器就會從上到下解釋代碼，步驟如下：
1.def w1(func): ==>將w1函數加載到內存
2.@w1
沒錯，從表面上看解釋器僅僅會解釋這兩句代碼，因為函數在沒有被調用之前其內部代碼不會被執行。
從表面上看解釋器著實會執行這兩句，但是@w1這一句代碼里卻有大文章，@函數名 是python的一種語法糖。
上例@w1內部會執行一下操作：
執行w1函數
執行w1函數 ，并將@w1下面的函數作為w1函數的參數，即：@w1等價于w1(f1)所以，內部就會去執行：
definner():
#驗證1
#驗證2
#驗證3
f1()# func是參數，此時func等于f1
returninner#返回的inner，inner代表的是函數，非執行函數,其實就是將原來的f1函數塞進另外一個函數中
w1的返回值
將執行完的w1函數返回值 賦值 給@w1下面的函數的函數名f1即將w1的返回值再重新賦值給f1，即：
新f1 =definner():
#驗證1
#驗證2
#驗證3
原來f1()
returninner
所以，以后業務部門想要執行f1函數時，就會執行 新f1函數，在新f1函數內部先執行驗證，再執行原來的f1函數，然后將原來f1函數的返回值返回給了業務調用者。
如此一來，即執行了驗證的功能，又執行了原來f1函數的內容，并將原f1函數返回值 返回給業務調用著
Low BBB你明白了嗎？要是沒明白的話，我晚上去你家幫你解決吧！！！
1.1.2多個裝飾器
#定義函數：完成包裹數據
defmakeBold(fn):
defwrapped():
return""+ fn() +""
returnwrapped
#定義函數：完成包裹數據
defmakeItalic(fn):
defwrapped():
return""+ fn() +""
returnwrapped
@makeBold
deftest1():
return"hello world-1"
@makeItalic
deftest2():
return"hello world-2"
@makeBold
@makeItalic
deftest3():
return"hello world-3"
print(test1()))
print(test2()))
print(test3()))
運行結果:
hello world-1
hello world-2
hello world-3
1.7.3裝飾器(decorator)功能
1.引入日志
2.函數執行時間統計
3.執行函數前預備處理
4.執行函數后清理功能
5.權限校驗等場景
6.緩存
1.7.4裝飾器示例
1.7.4.1例1:無參數的函數
fromtimeimportctime, sleep
deftimefun(func):
defwrappedfunc():
print("%s called at %s"%(func.__name__, ctime()))
func()
returnwrappedfunc
@timefun
deffoo():
print("I am foo")
foo()
sleep(2)
foo()
上面代碼理解裝飾器執行行為可理解成
foo = timefun(foo)
#foo先作為參數賦值給func后,foo接收指向timefun返回的wrappedfunc
foo()
#調用foo(),即等價調用wrappedfunc()
#內部函數wrappedfunc被引用，所以外部函數的func變量(自由變量)并沒有釋放
#func里保存的是原foo函數對象
1.7.2例2:被裝飾的函數有參數
fromtimeimportctime, sleep
deftimefun(func):
defwrappedfunc(a, b):
print("%s called at %s"%(func.__name__, ctime()))
print(a, b)
func(a, b)
returnwrappedfunc
@timefun
deffoo(a, b):
print(a+b)
foo(3,5)
sleep(2)
foo(2,4)
1.7.3例3:被裝飾的函數有不定長參數
fromtimeimportctime, sleep
deftimefun(func):
defwrappedfunc(*args, **kwargs):
print("%s called at %s"%(func.__name__, ctime()))
func(*args, **kwargs)
returnwrappedfunc
@timefun
deffoo(a, b, c):
print(a+b+c)
foo(3,5,7)
sleep(2)
foo(2,4,9)
1.7.4例4:裝飾器中的return
fromtimeimportctime, sleep
deftimefun(func):
defwrappedfunc():
print("%s called at %s"%(func.__name__, ctime()))
func()
returnwrappedfunc
@timefun
deffoo():
print("I am foo")
@timefun
defgetInfo():
return'----hahah---'
foo()
sleep(2)
foo()
print(getInfo())
執行結果:
foo called at Fri Nov421:55:352016
I am foo
foo called at Fri Nov421:55:372016
I am foo
getInfo called at Fri Nov421:55:372016
None
如果修改裝飾器為return func()，則運行結果：
foo called at Fri Nov421:55:572016
I am foo
foo called at Fri Nov421:55:592016
I am foo
getInfo called at Fri Nov421:55:592016
----hahah---
總結：
·一般情況下為了讓裝飾器更通用，可以有return
1.7.5例5:裝飾器帶參數,在原有裝飾器的基礎上，設置外部變量
#decorator2.py
fromtimeimportctime, sleep
deftimefun_arg(pre="hello"):
deftimefun(func):
defwrappedfunc():
print("%s called at %s %s"%(func.__name__, ctime(), pre))
returnfunc()
returnwrappedfunc
returntimefun
@timefun_arg("wangcai")
deffoo():
print("I am foo")
@timefun_arg("python")
deftoo():
print("I am too")
foo()
sleep(2)
foo()
too()
sleep(2)
too()
可以理解為
foo()==timefun_arg("wangcai")(foo)()
1.2python是動態語言
1.2.1動態語言的定義
動態編程語言是高級程序設計語言的一個類別，在計算機科學領域已被廣泛應用。它是一類在運行時可以改變其結構的語言：例如新的函數、對象、甚至代碼可以被引進，已有的函數可以被刪除或是其他結構上的變化。動態語言目前非常具有活力。例如JavaScript便是一個動態語言，除此之外如PHP、Ruby、Python等也都屬于動態語言，而C、C++等語言則不屬于動態語言。----來自 維基百科
1.2.2運行的過程中給對象綁定(添加)屬性
>>>classPerson(object):
def__init__(self, name = None, age = None):
self.name = name
self.age = age
>>>P = Person("小明","24")
>>>
在這里，我們定義了1個類Person，在這個類里，定義了兩個初始屬性name和age，但是人還有性別啊！如果這個類不是你寫的是不是你會嘗試訪問性別這個屬性呢？
>>>P.sex ="male"
>>>P.sex
'male'
>>>
這時候就發現問題了，我們定義的類里面沒有sex這個屬性啊！怎么回事呢？ 這就是動態語言的魅力和坑！ 這里 實際上就是 動態給實例綁定屬性！
1.2.3運行的過程中給類綁定(添加)屬性
>>>P1 = Person("小麗","25")
>>>P1.sex
Traceback (most recent call last):
File"", line1,in
P1.sex
AttributeError: Person instance has no attribute'sex'
>>>
我們嘗試打印P1.sex，發現報錯，P1沒有sex這個屬性！----給P這個實例綁定屬性對P1這個實例不起作用！ 那我們要給所有的Person的實例加上sex屬性怎么辦呢？ 答案就是直接給Person綁定屬性！
>>>> Person.sex =None#給類Person添加一個屬性
>>>P1 = Person("小麗","25")
>>>print(P1.sex)#如果P1這個實例對象中沒有sex屬性的話，那么就會訪問它的類屬性
None#可以看到沒有出現異常
>>>
1.2.4運行的過程中給類綁定(添加)方法
我們直接給Person綁定sex這個屬性，重新實例化P1后，P1就有sex這個屬性了！ 那么function呢？怎么綁定？
>>>classPerson(object):
def__init__(self, name = None, age = None):
self.name = name
self.age = age
defeat(self):
print("eat food")
>>>defrun(self, speed):
print("%s在移動,速度是%d km/h"%(self.name, speed))
>>>P = Person("老王",24)
>>>P.eat()
eat food
>>>
>>>P.run()
Traceback (most recent call last):
File"", line1,in
P.run()
AttributeError: Person instance has no attribute'run'
>>>
>>>
>>>importtypes
>>>P.run = types.MethodType(run, P)
>>>P.run(180)
老王在移動,速度是180km/h
既然給類添加方法，是使用類名.方法名= xxxx，那么給對象添加一個方法也是類似的對象.方法名= xxxx
完整的代碼如下：
importtypes
#定義了一個類
classPerson(object):
num =0
def__init__(self, name = None, age = None):
self.name = name
self.age = age
defeat(self):
print("eat food")
#定義一個實例方法
defrun(self, speed):
print("%s在移動,速度是%d km/h"%(self.name, speed))
#定義一個類方法
@classmethod
deftestClass(cls):
cls.num =100
#定義一個靜態方法
@staticmethod
deftestStatic():
print("---static method----")
#創建一個實例對象
P = Person("老王",24)
#調用在class中的方法
P.eat()
#給這個對象添加實例方法
P.run = types.MethodType(run, P)
#調用實例方法
P.run(180)
#給Person類綁定類方法
Person.testClass = testClass
#調用類方法
print(Person.num)
Person.testClass()
print(Person.num)
#給Person類綁定靜態方法
Person.testStatic = testStatic
#調用靜態方法
Person.testStatic()
1.2.5運行的過程中刪除屬性、方法
刪除的方法:
1.del對象.屬性名
2.delattr(對象, "屬性名")
通過以上例子可以得出一個結論：相對于動態語言，靜態語言具有嚴謹性！所以，玩動態語言的時候，小心動態的坑！
那么怎么避免這種情況呢？請使用__slots__，
1.2.6__slots__
現在我們終于明白了，動態語言與靜態語言的不同
動態語言：可以在運行的過程中，修改代碼
靜態語言：編譯時已經確定好代碼，運行過程中不能修改
如果我們想要限制實例的屬性怎么辦？比如，只允許對Person實例添加name和age屬性。
為了達到限制的目的，Python允許在定義class的時候，定義一個特殊的__slots__變量，來限制該class實例能添加的屬性：
>>>classPerson(object):
__slots__ = ("name","age")
>>>P = Person()
>>>P.name ="老王"
>>>P.age =20
>>>P.score =100
Traceback (most recent call last):
File"", line1,in
AttributeError: Person instance has no attribute'score'
>>>
1.2.6.1注意:
·使用__slots__要注意，__slots__定義的屬性僅對當前類實例起作用，對繼承的子類是不起作用的
In [67]:classTest(Person):
...:pass
...:
In [68]: t = Test()
In [69]: t.score =100
?
