Python三大活器

1.迭代器

可迭代的：可以被for循環都是可迭代的，諸如：列表、元組、集合、字典、字符串等

from collections import Iterable

l = [1, 2, 3, 4]
t = (1, 2, 3, 4)
d = {1: 2, 3: 4}
s = {1, 2, 3, 4}

print(isinstance(l, Iterable))
print(isinstance(t, Iterable))
print(isinstance(d, Iterable))
print(isinstance(s, Iterable))

// 輸出結果：
True
True
True
True

可迭代協議：內部實現了__iter__方法

print("__iter__" in dir(l))
print("__iter__" in dir(t))
print("__iter__" in dir(d))
print("__iter__" in dir(s))

// 輸出結果：
True
True
True
True

迭代器：是訪問集合的一種方法，擁有_inter_和_next_方法

a = iter(l) # iter()方法生成迭代器，參數必須是可迭代對象；iter()方法等同"__iter__()"
print(a)
while true:
try:
    print(next(a)) # next()方法對迭代器取值，等同於"__next__()"
except StopInteration:
    break
// 輸出結果：
<list_iterator object at 0x000001C01351E9E8> # 列表迭代器內存地址
1
2
3
4

特色：

1.訪問者不須要關心迭代器內部結構，僅須要經過next()方法不斷去取下一個內容
2.不可以隨機訪問集合中的某個值，只可以從頭至尾依次訪問且不能回退
3.便於循環比較大的數據集合，節省內存

總結：可以被for循環確定是可迭代對象，但不必定是迭代器
備註：關於for循環是基於迭代器協議的一種遍歷方法，先調用可迭代對象的iter()方法將其轉化成迭代器，而後使用迭代器協議去實現循環訪問

2.生成器

本質：迭代器
定義：一個函數調用時返回一個迭代器，那這個函數就是生成器；若是該函數中包含yield語法，則這個函數會成爲生成器函數
生成器函數：一個包含yield語法的函數，yield能夠從函數中返回值，不一樣return（程序結束），調用生成器函數會獲得可迭代的對象，每一次獲取這個可迭代對象的值，就能推進函數的執行，獲取新的返回值，直到函數結束（關於send()方法相同並傳遞給上一個yield）
列表推導式：list1=['學生%s' %i for i in range(10)]
生成器表達式：list1=('學生%s' %i for i in range(10)])

1.把列表解析的[]換成()獲得的就是生成器表達式
2.列表解析與生成器表達式都是一種便利的編程方式，只不過生成器表達式更節省內存

3.裝飾器

本質：一個閉包函數
功能：在不改變原函數的調用狀況下對原函數功能進行擴展
閉包：在一個外函數中定義一個內函數，內函數引用外函數的臨時變量，而且外函數的返回值是內函數
閉包函數：內部函數對外部做用域而非全局做用域的引用，該內部函數稱之爲閉包函數
閉包好處：能夠讀取函數內部的變量，這些變量的值始終保持在內存中，不會由於外函數調用後回收

裝飾器格式：

from functools import wraps
def decorator(func):
    @wraps(func)    # 幫助查看函數信息的方法
    def inner(*args,**kargs):
        print("before...")
        res = func(*args,**kargs)
        print("after...")
        return res 
    returen inner
def sum(a,b):
    return a+b
# 使用語法糖：
@decorator ==> sum = decorator(sum) = inner
res_sum = sum(1,2) ==> res_sum = inner(1,2)

多個裝飾器：

def wrapper1(func):
    def inner():
        print('wrapper1 ,before func')
        func()
        print('wrapper1 ,after func')
    return inner

def wrapper2(func):
    def inner():
        print('wrapper2 ,before func')
        func()
        print('wrapper2 ,after func')
    return inner

@wrapper2
@wrapper1
def f():
    print('in f')
f()

// 輸出結果：按語法糖順序優先執行before內容，再去執行after內容
wrapper2 ,before func
wrapper1 ,before func
in f
wrapper1 ,after func
wrapper2 ,after fun