進階語法
with ... as 上下文管理協議
with 語句適用于對資源進行訪問的場合，確保不管使用過程中是否發生異常都會執行必要的“清理”操作，釋放資源，比如文件使用后自動關閉、線程中鎖的自動獲取和釋放等。
已經加入對上下文管理協議支持的還有模塊 threading、decimal 等。
# 操作文件
with open('file.txt') as f:
for line in f:
print(line)
匿名函數lambda
在python中使用lambda來創建匿名函數,在需要傳遞函數作為參數的地方使用lambda更方便。
一個lambda的例子
list(map(lambda x: x*x, [1,2,3,4,5])) #[1, 4, 9, 16, 25]
# lambdx x: x*x 等于下面的f函數 可以直接f = lambda x: x*x 賦值后調用
def f(x):
return x*x
list(map(f,[1,2,3,4,5]))
對象模擬函數 可調用接口
對象通過__call__(self [, *args [, **kwargs]])方法模擬函數行為。如果一個對象x提供了該方法，就可以像函數一樣調用它。
class DistanceFrom(object):
def __init__(self,origin):
self.origin = origin
def __call__(self,x):
return abs(x-self.origin)
nums = [1,37,42,101,13,9,-20]
newnums = sorted(nums,key=DistanceFrom(10)) #按照與10的距離排序
以上效果等同于
newnums = sorted(nums,lambda x:abs(x-10))
當然也可以直接把DistanceFrom定義成函數
使用閉包
將組成函數的語句和這些語句的執行環境打包在一起時，得到的對象稱為閉包
# 計數器測試閉包效率，和使用類的時候對比
import timeit
def count(x):
def next():
nonlocal x
n = x
x -= 1
return n
return next
class count2:
def __init__(self,x):
self.x = x
def next(self):
n = self.x
self.x -= 1
return n
def test():
next = count(1000000)
while 1:
v = next()
if not v:break
def test2():
c = count2(1000000)
while 1:
v = c.next()
if not v:break
t2 = timeit.timeit(test2,number=10)
print(t2)
t = timeit.timeit(test,number=10)
print(t)
# 輸出結果，閉包效率大概是正常方法的2倍
# 4.5261534636385345
# 2.468003824508422
裝飾器
裝飾器本質上是一個Python函數，它可以讓其他函數在不需要做任何代碼變動的前提下增加額外功能，裝飾器的返回值也是一個函數對象。它經常用于有切面需求的場景，比如：插入日志、性能測試、事務處理、緩存、權限校驗等場景。
@wraps(func)裝飾裝飾函數，能把原函數的元信息拷貝到裝飾器函數中。
上面閉包性能測試改成使用裝飾器測試性能
import timeit
def timeit_test(number):
def decorated(func):
print(timeit.timeit(func,number=number))
return func
return decorated
'''略'''
'''略'''
@timeit_test(number=10)
def test():
next = count(1000000)
while 1:
v = next()
if not v:break
@timeit_test(number=10)
def test2():
c = count2(1000000)
while 1:
v = c.next()
if not v:break
# 裝飾器中已運行測試方法，不需要再主動運行
yield和生成器
盡量使用生成器
range(num) ----> xrange(nums) #僅限python2，python3中range就等于之前的xrange
for k,v in dict.items() ----> for k,v in dict.iteritems()
for k in dict.keys() ----> for k in iterkeys()
yied生成斐波那契數列
def fab(max):
n ,a, b = 0, 0 ,1
while n < max:
print('before fab %d' %n)
yield a
print('after fab %d' %n)
a, b = b, a + b
n += 1
for n in fab(5):
print(n)
# 迭代就是重復運行__next__()
print('//////////////////////////////////////////')
c = fab(5)
print(c.__next__())
print(c.__next__())
print(c.__next__())
print(c.__next__())
print(c.__next__())
for循環迭代fab(5)等同于
c = fab(5)
print(c.__next__()) #運行5次
注意運行結果，每循環一次其實代碼只執行到yield那一行,下一次循環直接從yield后面的代碼開始執行到下一次調用yield
yield和協程
def fab():
a, b, n = 0, 1 ,0
fablist = []
while True:
number = yield fablist # 返回值不是必須的，如果number = yield，則返回的是None
while n < number:
n += 1
fablist.append(a)
a, b = b ,a + b
c = fab()
c.__next__()
for i in range(3,7):
print(c.send(i*10))
對next()的初始調用是必須的，yield語句那里協程會掛起，等待相關生成器對象c的send()方法給它發送一個值。
可以定義一個coroutine裝飾器改寫上述語句，這看起來和tornado以及asyncio很相似了。
def coroutine(func):
def start(*args, **kwargs):
c = func(*args, **kwargs)
c.__next__()
return c
return start
@coroutine
def fab():
a, b, n = 0, 1 ,0
fablist = []
while True:
number = yield fablist
while n < number:
n += 1
fablist.append(a)
a, b = b ,a + b
c = fab()
#c.__next__() #加上自定義的coroutine裝飾器之后，不需要這個初始調用了
for i in range(3,7):
print(c.send(i*10))
