【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 myiteratorclass MyIterator(object):"""自定义的供上面可迭代对象使用的一个迭代器"""#这里的mylist就MyList对象def __init__(self, mylist):self.mylist = mylist# current用来记录当前访问到的位置#每一次调用for循环时，索引位置都从零开始self.current = 0def __next__(self):if self.current < len(self.mylist.items):item = self.mylist.items[self.current]self.current += 1return itemelse:raise StopIterationdef __iter__(self):return self

一个类实现迭代器


class MyList(object):"""自定义的一个可迭代对象"""def __init__(self):self.items = []self.current = 0def add(self, val):self.items.append(val)def __iter__(self):#返回自身引用，自己本身就是一个迭代器对象return selfdef __next__(self):if self.current < len(self.items):item = self.items[self.current]self.current += 1return itemelse:#使用for循环第二次遍历时，self.current可以从0开始self.current = 0raise StopIteration

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

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

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

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

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

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

迭代器的应用

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


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

生成器

生成器的定义

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

yield关键字有两点作用：

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

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

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

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

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

生成器的特点：

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

生成器的使用


def create_points():k = 2b = 1x = 0while True:y = k * x + b#当使用send方法时，会将send方法中的参数赋给temp,send()方法与next()方法类似，都可以取生成器中的下一个元素。temp = yield (x,y)if temp:k, b = tempx = yif __name__ == '__main__':#不再是一个普通函数的调用，因为函数体内包含yield关键字，此时是生成一个生成器对象g = create_points()# print(next(g))# print(next(g))# print(g.send((3, 4)))# print(next(g))# print(next(g))count = 0for i in g:if count > 3:breakprint(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_timeprint(f"{func.__name__} cost time: {execution_time:.4f} s")return resultreturn wrapper

构造执行函数

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

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

参考文献：

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

闭包

什么是闭包

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

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

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

最后外层函数return内层函数

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

为什么要使用闭包

封装变量： 闭包允许你创建一个包含函数和其所在环境中变量的封闭空间。这样，你可以隐藏一些变量，使其不易被外部访问，起到一定的封装作用。
保持状态： 闭包函数可以保持其创建时的状态。这意味着你可以在函数外部改变闭包内部的变量，并且在多次调用闭包时保持这些变量的状态。
函数工厂： 闭包函数可以用作函数工厂，动态生成函数。这对于根据不同情况生成不同行为的场景很有用。
实现装饰器： 闭包函数常用于实现装饰器模式，通过在函数外层包装其他函数来增强其功能，而无需修改原始函数的代码。
实现私有变量和方法： 通过闭包，你可以模拟出类似于面向对象编程中的私有变量和方法，限制对内部实现的访问。

闭包的应用场景是什么

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

def create_counter():count = 0  # 这个变量在闭包内def counter():nonlocal count  # 使用 nonlocal 关键字声明 count 不是局部变量count += 1return countreturn counter# 创建一个计数器
my_counter = create_counter()# 使用计数器
print(my_counter())  # 输出 1
print(my_counter())  # 输出 2
print(my_counter())  # 输出 3

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

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