一、生成器 通過列表生成式,我們可以直接創建一個列表。但是,受到記憶體限制,列表容量肯定是有限的。而且,創建一個包含100萬個元素的列表,不僅占用很大的存儲空間,如果我們僅僅需要訪問前面幾個元素,那後面絕大多數元素占用的空間都白白浪費了。所以,如果列表元素可以按照某種演算法推算出來,那我們是否可以在迴圈 ...
一、生成器
通過列表生成式,我們可以直接創建一個列表。但是,受到記憶體限制,列表容量肯定是有限的。而且,創建一個包含100萬個元素的列表,不僅占用很大的存儲空間,如果我們僅僅需要訪問前面幾個元素,那後面絕大多數元素占用的空間都白白浪費了。所以,如果列表元素可以按照某種演算法推算出來,那我們是否可以在迴圈的過程中不斷推算出後續的元素呢?這樣就不必創建完整的list,從而節省大量的空間。在Python中,這種一邊迴圈一邊計算的機制,稱為生成器:generator。
要創建一個generator,有很多種方法。第一種方法很簡單,只要把一個列表生成式的[]
改成()
,就創建了一個generator:
>>> L = [ x*2 for x in range(5)]
>>> L
[0, 2, 4, 6, 8]
>>> g = ( x*2 for x in range(5) )
>>> g
<generator object <genexpr> at 0x000000000321EF68>
創建L
和g
的區別僅在於最外層的[]
和()
,L
是一個list,而g
是一個generator。我們可以直接列印出list的每一個元素,但我們怎麼列印出generator的每一個元素呢?如果要一個一個列印出來,可以通過next()
函數獲得generator的下一個返回值:
>>> next(g)
0
>>> next(g)
2
>>> next(g)
4
>>> next(g)
6
>>> next(g)
8
>>> next(g)
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
next(g)
StopIteration
>>> g
<generator object <genexpr> at 0x000000000321EF68>
>>> g = ( x*2 for x in range(5) )
>>> for n in g:
print(n)
0
2
4
6
8
generator保存的是演算法,每次調用next(g)
,就計算出g
的下一個元素的值,直到計算到最後一個元素,沒有更多的元素時,拋出StopIteration
的錯誤。當然,這種不斷調用next(g)
實在是太變態了,正確的方法是使用for
迴圈,因為generator也是可迭代對象。所以,我們創建了一個generator後,基本上永遠不會調用next()
,而是通過for
迴圈來迭代它,並且不需要關心StopIteration
的錯誤。
generator非常強大。如果推算的演算法比較複雜,用類似列表生成式的for
迴圈無法實現的時候,還可以用函數來實現。
比如,著名的斐波拉契數列(Fibonacci),除第一個和第二個數外,任意一個數都可由前兩個數相加得到:
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
斐波拉契數列用列表生成式寫不出來,但是,用函數把它列印出來卻很容易:
>>> def fib(max):
n,a,b = 0,0,1
while n<max:
print(b)
a,b =b,a+b
n=n+1
return 'done'
>>> fib(10)
1
1
2
3
5
8
13
21
34
55
'done'
'''仔細觀察,可以看出,fib函數實際上是定義了斐波拉契數列的推算規則,可以從第一個元素開始,推算出後續任意的元素,這種邏輯其實非常類似generator。
也就是說,上面的函數和generator僅一步之遙。要把fib函數變成generator,只需要把print(b)改為yield b就可以了:
'''
>>> def fib(max):
n,a,b = 0,0,1
while n<max:
yield b
a,b =b,a+b
n=n+1
return 'done'
>>> f=fib(5)
>>> f
<generator object fib at 0x000000000321EF68>
>>> print(next(f))
1
>>> print(next(f))
1
>>> print(next(f))
2
>>> print(next(f))
3
>>> print(next(f))
5
>>> print(next(f))
Traceback (most recent call last):
File "<pyshell#49>", line 1, in <module>
print(next(f))
StopIteration: done
在上面fib
的例子,我們在迴圈過程中不斷調用yield
,就會不斷中斷。當然要給迴圈設置一個條件來退出迴圈,不然就會產生一個無限數列出來。同樣的,把函數改成generator後,我們基本上從來不會用next()
來獲取下一個返回值,而是直接使用for
迴圈來迭代:
>>> for n in fib(5):
... print(n)
...
1
1
2
3
5
'''
但是用for迴圈調用generator時,發現拿不到generator的return語句的返回值。如果想要拿到返回值,必須捕獲StopIteration錯誤,返回值包含在StopIteration的value中:
'''
>>> g=fib(5)
>>> while True:
try:
x=next(g)
print('g:',x)
except StopIteration as e:
print('Generator return value:', e.value)
break
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done
通過yield實現在單線程的情況下實現併發運算的效果:(暫時保留)
二、迭代器
迭代是Python最強大的功能之一,是訪問集合元素的一種方式。迭代器是一個可以記住遍歷的位置的對象。迭代器對象從集合的第一個元素開始訪問,直到所有的元素被訪問完結束。迭代器只能往前不會後退。
以直接作用於for
迴圈的數據類型有以下幾種:
一類是集合數據類型,如list
、tuple
、dict
、set
、str
等;
一類是generator
,包括生成器和帶yield
的generator function。
這些可以直接作用於for
迴圈的對象統稱為可迭代對象:Iterable
。
可以使用isinstance()
判斷一個對象是否是Iterable
對象:
>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False
而生成器不但可以作用於for
迴圈,還可以被next()
函數不斷調用並返回下一個值,直到最後拋出StopIteration
錯誤表示無法繼續返回下一個值了。
*可以被next()
函數調用並不斷返回下一個值的對象稱為迭代器:Iterator
。
可以使用isinstance()
判斷一個對象是否是Iterator
對象:
>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False
生成器都是Iterator
對象,但list
、dict
、str
雖然是Iterable
,卻不是Iterator
。
把list
、dict
、str
等Iterable
變成Iterator
可以使用iter()
函數:
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True
你可能會問,為什麼list
、dict
、str
等數據類型不是Iterator
?
這是因為Python的Iterator
對象表示的是一個數據流,Iterator對象可以被next()
函數調用並不斷返回下一個數據,直到沒有數據時拋出StopIteration
錯誤。可以把這個數據流看做是一個有序序列,但我們卻不能提前知道序列的長度,只能不斷通過next()
函數實現按需計算下一個數據,所以Iterator
的計算是惰性的,只有在需要返回下一個數據時它才會計算。
Iterator
甚至可以表示一個無限大的數據流,例如全體自然數。而使用list是永遠不可能存儲全體自然數的。
小結
凡是可作用於for
迴圈的對象都是Iterable
類型;
凡是可作用於next()
函數的對象都是Iterator
類型,它們表示一個惰性計算的序列;
集合數據類型如list
、dict
、str
等是Iterable
但不是Iterator
,不過可以通過iter()
函數獲得一個Iterator
對象。
Python的for
迴圈本質上就是通過不斷調用next()
函數實現的,例如:
for x in [1, 2, 3, 4, 5]:
pass
#實際上完全等價於:
# 首先獲得Iterator對象:
it = iter([1, 2, 3, 4, 5])
# 迴圈:
while True:
try:
# 獲得下一個值:
x = next(it)
except StopIteration:
# 遇到StopIteration就退出迴圈
break
三、裝飾器
理解了好幾天,開始寫裝飾器,先說定義:裝飾器本質上是一個Python函數,它可以讓其他函數在不需要做任何代碼變動的前提下增加額外功能,裝飾器的返回值也是一個函數對象。假設我們要增強一個函數的功能,比如,在函數調用前後自動列印時間,但又不希望修改函數的定義,這種在代碼運行期間動態增加功能的方式,稱之為“裝飾器”(Decorator)。
def use_logging(func):
print("%s is running" % func.__name__) #_name_獲取函數的名字,也就是bar
func()
def bar():
print('i am bar')
use_logging(bar)
'''執行結果:
bar is running
i am bar
'''
邏輯上不難理解, 但是這樣的話,我們每次都要將一個函數作為參數傳遞給use_logging函數。而且這種方式已經破壞了原有的代碼邏輯結構,之前執行業務邏輯時,執行運行bar(),但是現在不得不改成use_logging(bar)。那麼有沒有更好的方式的呢?當然有,答案就是裝飾器。
1.無參裝飾器
import time
def timer(func):
def deco():
start_time = time.time()
func()
stop_time = time.time()
print("The func run time is %s" %(stop_time-start_time))
return deco
@timer #相當於time1=timer(time1)
def time1():
time.sleep(1)
print("In the time")
time1()
'''
In the time
The func run time is 1.0000569820404053
'''
2.有參裝飾器
import time
def timer(timeout=0):
def decorator(func):
def wrapper(*args,**kwargs):
start=time.time()
func(*args,**kwargs)
stop=time.time()
print 'run time is %s ' %(stop-start)
print timeout
return wrapper
return decorator
@timer(2)
def test(list_test):
for i in list_test:
time.sleep(0.1)
print '-'*20,i
#timer(timeout=10)(test)(range(10))
test(range(10))
四、Json & pickle 數據序列化
用於序列化的兩個模塊
- json,用於字元串 和 python數據類型間進行轉換
- pickle,用於python特有的類型 和 python的數據類型間進行轉換
Json模塊提供了四個功能:dumps、dump、loads、load
pickle模塊提供了四個功能:dumps、dump、loads、load
我們把變數從記憶體中變成可存儲或傳輸的過程稱之為序列化,在Python中叫pickling。序列化之後,就可以把序列化後的內容寫入磁碟,或者通過網路傳輸到別的機器上。反過來,把變數內容從序列化的對象重新讀到記憶體里稱之為反序列化,即unpickling。Python提供了pickle
模塊來實現序列化。
>>> import pickle
>>> d = dict(name='Bob', age=20, score=88)
>>> pickle.dumps(d)
b'\x80\x03}q\x00(X\x03\x00\x00\x00ageq\x01K\x14X\x05\x00\x00\x00scoreq\x02KXX\x04\x00\x00\x00nameq\x03X\x03\x00\x00\x00Bobq\x04u.'
#pickle.dumps()方法把任意對象序列化成一個bytes,然後,就可以把這個bytes寫入文件。
>>> f = open('dump.txt', 'wb')
>>> pickle.dump(d, f)
>>> f.close()
#當我們要把對象從磁碟讀到記憶體時,可以先把內容讀到一個bytes,然後用pickle.loads()方法反序列化出對象。
>>> f = open('dump.txt', 'rb')
>>> d = pickle.load(f)
>>> f.close()
>>> d
{'age': 20, 'score': 88, 'name': 'Bob'}
Pickle的問題和所有其他編程語言特有的序列化問題一樣,就是它只能用於Python,並且可能不同版本的Python彼此都不相容,因此,只能用Pickle保存那些不重要的數據,不能成功地反序列化也沒關係。
如果我們要在不同的編程語言之間傳遞對象,就必須把對象序列化為標準格式,比如XML,但更好的方法是序列化為JSON,因為JSON表示出來就是一個字元串,可以被所有語言讀取,也可以方便地存儲到磁碟或者通過網路傳輸。JSON不僅是標準格式,並且比XML更快,而且可以直接在Web頁面中讀取,非常方便。
>>> import json
>>> d = dict(name='Bob', age=20, score=88)
>>> json.dumps(d)
'{"age": 20, "score": 88, "name": "Bob"}'
dumps()
方法返回一個str
,內容就是標準的JSON。
要把JSON反序列化為Python對象,用loads()
或者對應的load()
方法,前者把JSON的字元串反序列化。
>>> json_str = '{"age": 20, "score": 88, "name": "Bob"}'
>>> json.loads(json_str)
{'age': 20, 'score': 88, 'name': 'Bob'}