【python高级用法】迭代器、生成器、装饰器、闭包

迭代器

• 可迭代对象：可以使用for循环来遍历的，可以使用isinstance()来测试。

• 迭代器：同时实现了__iter__()方法和__next__()方法，可以使用isinstance()方法来测试是否是迭代器对象

from collections.abc import Iterable, Iterator
li = [11, 22, 33, 44, 55]

print(isinstance(li, Iterable)
iterator_li = iter(li)
print(isinstance(iterator_li, Iterator)

使用类实现迭代器

两个类实现一个迭代器

class MyList(object):
    """自定义的一个可迭代对象"""
    def __init__(self):
        self.items = []

    def add(self, val):
        self.items.append(val)

    def __iter__(self):
? ? ? ? #python中万物皆对象，将该类对象的引用self作为实参传入到MyIterator类中
        myiterator = MyIterator(self)
        return myiterator


class MyIterator(object):
    """自定义的供上面可迭代对象使用的一个迭代器"""
? ? #这里的mylist就MyList对象
    def __init__(self, mylist):
        self.mylist = mylist
        # current用来记录当前访问到的位置
? ? ? ? #每一次调用for循环时，索引位置都从零开始
        self.current = 0

    def __next__(self):
        if self.current < len(self.mylist.items):
            item = self.mylist.items[self.current]
            self.current += 1
            return item
        else:
            raise StopIteration

    def __iter__(self):
        return self

一个类实现迭代器

class MyList(object):
    """自定义的一个可迭代对象"""
    def __init__(self):
        self.items = []
        self.current = 0

    def add(self, val):
        self.items.append(val)

    def __iter__(self):
? ? ? ? #返回自身引用，自己本身就是一个迭代器对象
        return self

    def __next__(self):
        if self.current < len(self.items):
            item = self.items[self.current]
            self.current += 1
            return item
        else:
? ? ? ? ? ? #使用for循环第二次遍历时，self.current可以从0开始
            self.current = 0
            raise StopIteration

• 可迭代对象与迭代器的总结

1. 一个具备了__iter__方法的对象，就是一个可迭代对象

1. 当对一个可迭代对象调用iter()函数时，它会自动调用这个可迭代对象的__iter__方法，这个方法返回的对象当作迭代器

1. 当对一个迭代器对象调用next()函数时，他会自动调用这个迭代器对象的__next__方法，这个方法返回想要的数据

1. 迭代器一定是可迭代对象，可迭代对象不一定是迭代器

1. 数据类型list、dict、str等是Iterable单不是Iterator,不过可以通过iter()函数获得一个Iterator对象

• 迭代器的应用

1. 如果每次返回的数据值不是在一个已有的数据集合中，而是通过程序按照一定的规律计算生成的，那就不用再依赖一个已有的数据集合，也就是说不用再将所有要迭代的数据都一次性缓存下来，这样可以节省大量的存储（内存）空间。

class FeiboIterator(object):
    """斐波那契数列迭代器"""
 
    def __init__(self, n):
        # 斐波那数列值的个数
        self.n = n
        # 记录当前遍历的下标
        self.index = 0
        # 斐波那数列前面的两个值
        self.num1 = 0
        self.num2 = 1
 
    def __next__(self):
        """被next()函数调用来获取下一个数"""
        if self.index < self.n:
            num = self.num1
            self.num1, self.num2 = self.num2, self.num1 + self.num2
            self.index += 1
            return num
        else:
            raise StopIteration
 
    def __iter__(self):
        """迭代器的__iter__返回自身即可"""
        return self
 
 
if __name__ == '__main__':
    fb = FeiboIterator(20)
    for num in fb:
        print(num, end=' ')

生成器

生成器的定义

1. 使用了yield关键字的函数不再是函数，而是生成器。

1. yield关键字有两点作用：

• 保存当前运行状态（断点），然后暂停执行，即将生成器（函数）挂起

• 将yield关键字后面表达式的值作为返回值返回，此时可以理解为起到了return作用

1. 可以使用next()函数让生成器从断点处继续执行，唤醒生成器(函数)

1. python3中的生成器可以使用return返回最终运行的返回值

1. 生成器是这样一个函数，他记住上一次返回在函数体中的位置。对生成器函数的第二次(或第n次)调用跳转至函数中间，而上次调用的所有的局部变量都保持不变。生成器不仅记住了他的数据状态，生成器还记住了它在流程控制构造(在命令式编程中，这种构造不只是数据值）中的位置。

1. 生成器的特点：

• 存储的是生成数据的方式(即算法）,而不是存储生成的数据，因此节约内存。

生成器的使用

def create_points():
    k = 2
    b = 1
    x = 0
    while True:
        y = k * x + b
        #当使用send方法时，会将send方法中的参数赋给temp,send()方法与next()方法类似，都可以取生成器中的下一个元素。
        temp = yield (x,y)
        if temp:
            k, b = temp
        x = y

if __name__ == '__main__':
? ? #不再是一个普通函数的调用，因为函数体内包含yield关键字，此时是生成一个生成器对象
    g = create_points()
    # print(next(g))
    # print(next(g))
    # print(g.send((3, 4)))
    # print(next(g))
    # print(next(g))
    count = 0
    for i in g:
        if count > 3:
            break
        print(i)
        count += 1

参考链接：

python生成器的原理和业务场景下的使用_for line in tqdm(f, desc='read sentence_cuts'):如果不-CSDN博客

装饰器

装饰器的定义

装饰器可以在不改变某函数结构和调用方式基础之上，为其增加新的功能，并且最大化复用新的功能。

装饰器的应用场景

为函数增加日志记录、登录校验、权限校验等，我们可以将这些功能写成一个装饰器，然后直接应用到相应需要改功能的函数中即可，可以保证对原代码和函数零侵入。

装饰器的本质是一个闭包函数

• 装饰器函数

def timing_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        execution_time = end_time - start_time
        print(f"{func.__name__} cost time: {execution_time:.4f} s")
        return result
    return wrapper

• 构造执行函数

@timing_decorator
def demo():
    time.sleep(5)
    

执行demo函数时，会打印该函数执行时间为5s

参考文献：

python装饰器全解--包含实现原理及应用场景_装饰器实现原理-CSDN博客

闭包

什么是闭包

概念：一个函数可以引用作用域外的变量，同时也可以在函数内部进行使用的函数，称之为闭包函数。而这个作用域外的变量，称之为自由变量。这个自由变量不同于C++的static修饰的静态变量，也不同于全局变量，它是和闭包函数进行绑定的。

1. 闭包函数是函数的嵌套，函数内还有函数，即外层函数嵌套一个内层函数

1. 在外层函数定义局部变量，在内层函数通过nonlocal引用，并实现指定功能，比如计数

1. 最后外层函数return内层函数

1. 主要作用：可以变相实现私有变量的功能，即用内层函数访问外层函数内的变量，并让外层函数内的变量常驻内存

为什么要使用闭包

1. 封装变量： 闭包允许你创建一个包含函数和其所在环境中变量的封闭空间。这样，你可以隐藏一些变量，使其不易被外部访问，起到一定的封装作用。

2. 保持状态： 闭包函数可以保持其创建时的状态。这意味着你可以在函数外部改变闭包内部的变量，并且在多次调用闭包时保持这些变量的状态。

3. 函数工厂： 闭包函数可以用作函数工厂，动态生成函数。这对于根据不同情况生成不同行为的场景很有用。

4. 实现装饰器： 闭包函数常用于实现装饰器模式，通过在函数外层包装其他函数来增强其功能，而无需修改原始函数的代码。

5. 实现私有变量和方法： 通过闭包，你可以模拟出类似于面向对象编程中的私有变量和方法，限制对内部实现的访问。

闭包的应用场景是什么

创建一个计数器，但又不想让外部直接访问计数变量

def create_counter():
    count = 0  # 这个变量在闭包内

    def counter():
        nonlocal count  # 使用 nonlocal 关键字声明 count 不是局部变量
        count += 1
        return count

    return counter

# 创建一个计数器
my_counter = create_counter()

# 使用计数器
print(my_counter())  # 输出 1
print(my_counter())  # 输出 2
print(my_counter())  # 输出 3

在这个例子中，create_counter 函数返回了一个内部定义的 counter 函数。count 变量被封装在 counter 函数的闭包中，因此外部无法直接访问。每次调用 my_counter() 时，计数器会递增并返回当前计数值。

这样做的好处是，我们可以创建多个独立的计数器，它们各自维护自己的状态，而不会互相干扰。闭包在这里提供了一种轻量级的状态封装和隔离的机制。