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