基础4
1.裝飾器??=??高階函數(shù)+嵌套函數(shù)
本質(zhì)是函數(shù)，它裝飾其他函數(shù)，給其他函數(shù)添加附加功能
原則：1.不能修改被裝飾的函數(shù)
2.不能修改被裝飾函數(shù)的調(diào)用方式
?? 3.裝飾器不會修改代碼的任何東西
裝飾器需要的知識：
?? 1.函數(shù)即變量
?? 2.高階函數(shù)
?? 3.嵌套函數(shù)
?
?
2.迭代器
列表生成式
[i*2 for i in range(10)]
3.生成器：只在調(diào)用的時候才會生成相應的數(shù)據(jù)，而且只記錄當前位置，不能再調(diào)用上一個數(shù)據(jù)
c=(i*2 for i in range(10))
這時，c是一個函數(shù)對象，并沒有創(chuàng)建一個包含10個元素的集合
???? <generator object <genexpr> at 0x0000000002E6D5A0>
for i in c:
print(i)
通過這種方法，當用到某個元素的時候，調(diào)用c將元素取出來，這種方法可以大量節(jié)省內(nèi)存
【技巧：c.__next__()得到下一個元素，沒有方法得到上一個元素】
他山之石
##############################################################??????????
生成器（顯著標志是yield）
通過列表生成式，我們可以直接創(chuàng)建一個列表。但是，受到內(nèi)存限制，列表容量肯定是有限的。而且，創(chuàng)建一個包含100萬個元素的列表，不僅占用很大的存儲空間，如果我們僅僅需要訪問前面幾個元素，那后面絕大多數(shù)元素占用的空間都白白浪費了。
所以，如果列表元素可以按照某種算法推算出來，那我們是否可以在循環(huán)的過程中不斷推算出后續(xù)的元素呢？這樣就不必創(chuàng)建完整的list，從而節(jié)省大量的空間。在Python中，這種一邊循環(huán)一邊計算的機制，稱為生成器：generator。
要創(chuàng)建一個generator，有很多種方法。第一種方法很簡單，只要把一個列表生成式的[]改成()，就創(chuàng)建了一個generator：
?| 1 2 3 4 5 6 | >>> L = [x * x for x in range(10)] >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> g = (x * x for x in range(10)) >>> g <generator object <genexpr> at 0x1022ef630> |
創(chuàng)建L和g的區(qū)別僅在于最外層的[]和()，L是一個list，而g是一個generator。
我們可以直接打印出list的每一個元素，但我們怎么打印出generator的每一個元素呢？
如果要一個一個打印出來，可以通過next()函數(shù)獲得generator的下一個返回值：
?| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | >>> next(g) 0 >>> next(g) 1 >>> next(g) 4 >>> next(g) 9 >>> next(g) 16 >>> next(g) 25 >>> next(g) 36 >>> next(g) 49 >>> next(g) 64 >>> next(g) 81 >>> next(g) Traceback (most recent call last): ??File "<stdin>", line 1, in <module> StopIteration |
我們講過，generator保存的是算法，每次調(diào)用next(g)，就計算出g的下一個元素的值，直到計算到最后一個元素，沒有更多的元素時，拋出StopIteration的錯誤。
當然，上面這種不斷調(diào)用next(g)實在是太變態(tài)了，正確的方法是使用for循環(huán)，因為generator也是可迭代對象：
?| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | >>> g = (x * x for x in range(10)) >>> for n in g: ...???? print(n) ... 0 1 4 9 16 25 36 49 64 81 |
?
所以，我們創(chuàng)建了一個generator后，基本上永遠不會調(diào)用next()，而是通過for循環(huán)來迭代它，并且不需要關心StopIteration的錯誤。
generator非常強大。如果推算的算法比較復雜，用類似列表生成式的for循環(huán)無法實現(xiàn)的時候，還可以用函數(shù)來實現(xiàn)。
比如，著名的斐波拉契數(shù)列（Fibonacci），除第一個和第二個數(shù)外，任意一個數(shù)都可由前兩個數(shù)相加得到：
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
斐波拉契數(shù)列用列表生成式寫不出來，但是，用函數(shù)把它打印出來卻很容易：
?| 1 2 3 4 5 6 7 | def fib(max): ????n, a, b = 0, 0, 1 ????while n < max: ????????print(b) ????????a, b = b, a + b ????????n = n + 1 ????return 'done' |
注意，賦值語句：
?| 1 | a, b = b, a + b |
相當于：
?| 1 2 3 | t = (b, a + b) # t是一個tuple a = t[0] b = t[1] |
但不必顯式寫出臨時變量t就可以賦值。
上面的函數(shù)可以輸出斐波那契數(shù)列的前N個數(shù)：
?| 1 2 3 4 5 6 7 8 9 10 11 12 | >>> fib(10) 1 1 2 3 5 8 13 21 34 55 done |
仔細觀察，可以看出，fib函數(shù)實際上是定義了斐波拉契數(shù)列的推算規(guī)則，可以從第一個元素開始，推算出后續(xù)任意的元素，這種邏輯其實非常類似generator。
也就是說，上面的函數(shù)和generator僅一步之遙。要把fib函數(shù)變成generator，只需要把print(b)改為yield b就可以了：
def fib(max):n,a,b = 0,0,1while n < max:#print(b) yield b a,b = b,a+b n += 1 return 'done'這就是定義generator的另一種方法。如果一個函數(shù)定義中包含yield關鍵字，那么這個函數(shù)就不再是一個普通函數(shù)，而是一個generator：
>>> f = fib(6) >>> f <generator object fib at 0x104feaaa0>這里，最難理解的就是generator和函數(shù)的執(zhí)行流程不一樣。函數(shù)是順序執(zhí)行，遇到return語句或者最后一行函數(shù)語句就返回。而變成generator的函數(shù)，在每次調(diào)用next()的時候執(zhí)行，遇到y(tǒng)ield語句返回，再次執(zhí)行時從上次返回的yield語句處繼續(xù)執(zhí)行。
data = fib(10) print(data)print(data.__next__()) print(data.__next__()) print("干點別的事") print(data.__next__()) print(data.__next__()) print(data.__next__()) print(data.__next__()) print(data.__next__()) #輸出 <generator object fib at 0x101be02b0> 1 1 干點別的事 2 3 5 8 13?
?
#################################################################################################
3.生成器的send函數(shù)
看過limodou的文章《2.5版yield之學習心得》，并自己反復體驗后，對yield有了一個全新的理解。
1. 包含yield的函數(shù)
假如你看到某個函數(shù)包含了yield，這意味著這個函數(shù)已經(jīng)是一個Generator，它的執(zhí)行會和其他普通的函數(shù)有很多不同。比如下面的簡單的函數(shù)：
def?h(): ????print?'To?be?brave' ????yield?5h()
可以看到，調(diào)用h()之后，print 語句并沒有執(zhí)行！這就是yield，那么，如何讓print 語句執(zhí)行呢？這就是后面要討論的問題，通過后面的討論和學習，就會明白yield的工作原理了。
2. yield是一個表達式
Python2.5以前，yield是一個語句，但現(xiàn)在2.5中，yield是一個表達式(Expression)，比如：
m?=?yield?5表達式(yield 5)的返回值將賦值給m，所以，認為 m = 5 是錯誤的。那么如何獲取(yield 5)的返回值呢？需要用到后面要介紹的send(msg)方法。
3. 透過next()語句看原理
現(xiàn)在，我們來揭曉yield的工作原理。我們知道，我們上面的h()被調(diào)用后并沒有執(zhí)行，因為它有yield表達式，因此，我們通過next()語句讓它執(zhí)行。next()語句將恢復Generator執(zhí)行，并直到下一個yield表達式處。比如：
def?h(): ????print?'Wen?Chuan' ????yield?5 ????print?'Fighting!'c?=?h() c.next()
c.next()調(diào)用后，h()開始執(zhí)行，直到遇到y(tǒng)ield 5，因此輸出結(jié)果：
Wen Chuan
當我們再次調(diào)用c.next()時，會繼續(xù)執(zhí)行，直到找到下一個yield表達式。由于后面沒有yield了，因此會拋出異常：
4. send(msg) 與 next()
了解了next()如何讓包含yield的函數(shù)執(zhí)行后，我們再來看另外一個非常重要的函數(shù)send(msg)。其實next()和send()在一定意義上作用是相似的，區(qū)別是send()可以傳遞yield表達式的值進去，而next()不能傳遞特定的值，只能傳遞None進去。因此，我們可以看做
c.next() 和 c.send(None) 作用是一樣的。
來看這個例子：
c?=?h() c.next()??#相當于c.send(None) c.send('Fighting!')??#(yield?5)表達式被賦予了'Fighting!'
輸出的結(jié)果為：
Wen Chuan Fighting!
需要提醒的是，第一次調(diào)用時，請使用next()語句或是send(None)，不能使用send發(fā)送一個非None的值，否則會出錯的，因為沒有yield語句來接收這個值。
5. send(msg) 與 next()的返回值
send(msg) 和 next()是有返回值的，它們的返回值很特殊，返回的是下一個yield表達式的參數(shù)。比如yield 5，則返回 5 。到這里，是不是明白了一些什么東西？本文第一個例子中，通過for i in alist 遍歷 Generator，其實是每次都調(diào)用了alist.Next()，而每次alist.Next()的返回值正是yield的參數(shù)，即我們開始認為被壓進去的東東。我們再延續(xù)上面的例子：
def?h(): ????print?'Wen?Chuan', ????m?=?yield?5??#?Fighting! ????print?m ????d?=?yield?12 ????print?'We?are?together!'c?=?h() m?=?c.next()??#m?獲取了yield?5?的參數(shù)值?5 d?=?c.send('Fighting!')??#d?獲取了yield?12?的參數(shù)值12 print?'We?will?never?forget?the?date',?m,?'.',?d
輸出結(jié)果：
Wen Chuan Fighting!
We will never forget the date 5 . 12
6. throw() 與 close()中斷 Generator
中斷Generator是一個非常靈活的技巧，可以通過throw拋出一個GeneratorExit異常來終止Generator。Close()方法作用是一樣的，其實內(nèi)部它是調(diào)用了throw(GeneratorExit)的。我們看：
def?close(self): ????try: ????????self.throw(GeneratorExit) ????except?(GeneratorExit,?StopIteration): ????????pass ????else: ????????raise?RuntimeError("generator?ignored?GeneratorExit") #?Other?exceptions?are?not?caught因此，當我們調(diào)用了close()方法后，再調(diào)用next()或是send(msg)的話會拋出一個異常：
Traceback?(most?recent?call?last): ??File?"/home/evergreen/Codes/yidld.py",?line?14,?in?<module> ????d?=?c.send('Fighting!')??#d?獲取了yield?12?的參數(shù)值12 StopIteration
注：以上觀點屬于本人的個人理解，如有偏差請批評指正。謝謝！
3.迭代器：可以被next()函數(shù)調(diào)用并不斷返回下一個值的對象稱為迭代器：Iterator。
可以直接作用于for循環(huán)的對象統(tǒng)稱為可迭代對象：Iterable iter(a)??可將可迭代對象a轉(zhuǎn)換為迭代器 4.Json用來不同語言之間信息的轉(zhuǎn)換傳輸，JSON編碼識別python的如下類型：(string,?unicode,?int,float,?list,?tuple, and?dict) Json序列化與Json反序列化 Json序列化，（由于不能直接將字典存到文件里，所以需要Json將字典序列化，這時字典變成字符串，可以寫入文件） Json反序列化,（將文件中的字典讀出，并還原為字典）這樣字典就可以用了 1 d = {"id": 1234, "password": 1, "default": 15000, "yue": 15000} 2 3 import json 4 #將字典寫成json文件 5 with open("1234.json", "w") as f: 6 f.write(json.dumps(d) ) 7 #從json文件讀取數(shù)據(jù)，并將數(shù)據(jù)還原成字典 8 with open("1234.json","r+") as f: 9 for i in f: 10 print(i,type(i)) 11 c = json.loads(i) 12 print(c,type(c)) 13 14 輸出： 15 {"default": 15000, "yue": 15000, "password": 1, "id": 1234} <class 'str'> 16 {'default': 15000, 'password': 1, 'yue': 15000, 'id': 1234} <class 'dict'>?
5.pickle模塊用于將內(nèi)存中的python對象序列化成字節(jié)流，并可以寫入任何類似文件對象中；它也可以根據(jù)序列化的字節(jié)流進行反序列化，將字節(jié)流還原為內(nèi)存中的對象。 pickle使用dump方法將內(nèi)存對象序列化： import pickle d = {'1':1,'2':2} dbfile = open('pickle_list.txt', 'wb') ? ?#必須以2進制打開文件，否則pickle無法將對象序列化只文件 pickle.dump(d, dbfile) dbfile.close() 輸出：生成'pickle_list.txt'文件，但里面是人類讀不懂的一串字符串 以上代碼即將字典對象d序列化至文件“pickle_list.txt"中，下次再次運行時，可以通過pickle的load方法恢復字典對象： import pickle dbfile = open('pickle_list.txt', 'rb') d?= pickle.load(dbfile) dbfile.close() print(d) 輸出：? {'1':1,'2':2}，類型是字典?
轉(zhuǎn)載于:https://www.cnblogs.com/wt11/p/5768724.html
總結(jié)
- 上一篇： Lexer的设计--中(4)
- 下一篇： 通用扩展函数--类型转换