小彩蛋：推导式、生成器&迭代器、装饰器&fixture

原创已于 2025-12-08 01:33:38 修改 · 814 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#python

于 2025-08-23 02:58:37 首次发布

测试Python 专栏收录该内容

15 篇文章

订阅专栏

部署运行你感兴趣的模型镜像

小彩蛋~汪汪糊糊

https://www.runoob.com/python3/python3-tutorial.html

【推导式】

Python 推导式是一种强大且简洁的语法，适用于生成列表、字典、集合和生成器。

Python 支持各种数据结构的推导式：

1.列表(list)推导式

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]
或
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

2.字典(dict)推导式

{ key_expr: value_expr for value in collection }
或
{ key_expr: value_expr for value in collection if condition }

3.集合(set)推导式

{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }

4.元组(tuple)推导式

（注意：返回的是生成器对象，使用 tuple() 函数，可以直接将生成器对象转换成元组）

(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

【生成器&迭代器】

1.生成器（生成器就是一个迭代器）

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。

每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。

调用一个生成器函数，返回的是一个迭代器对象。

def countdown(n):
    while n > 0:
        yield n
        n -= 1
 
# 创建生成器对象
generator = countdown(5)
 
# 通过迭代生成器获取值
print(next(generator))  # 输出: 5
print(next(generator))  # 输出: 4
print(next(generator))  # 输出: 3
 
# 使用 for 循环迭代生成器
for value in generator:
    print(value)  # 输出: 2 1

以上实例中，countdown 函数是一个生成器函数。

2.迭代器

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束，只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器。

迭代器对象可以使用常规for语句进行遍历，也可以使用 next() 函数。

import sys  # 引入 sys 模块

list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象
it2 = iter(list)  # 创建迭代器对象，迭代器只能往前不会后退。

while True:
    try:
        print(next(it2))
    except StopIteration:
        for x in it:
            print(x, end=" ")
        sys.exit()

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

raise语句用于手动引发异常，这是处理错误和控制程序流程的常用方法。

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x)

【闭包&装饰器&fixture】

0.闭包

在定义一个函数的时候，嵌套了另外一个函数，而且内部函数使用了外部函数的变量，并且外部函数返回了内部函数的名字（函数引用）

def x():
	print("A")

x()
y=x #这里不能加括号，加了括号就执行了，给结果；不加就是函数给他了，给函数
y() #等于调用了x()




def xx(z):
	print(f"A{z}")

xx("0")
yy=xx 
yy("1") 




def xxx(n):
	def yyy(m):
		print(f"n+m={n+m}")
	return yyy #只能返回里面函数名字（固定的）

zzz=xxx(666)
zzz(888)

1.装饰器(本质是闭包。装饰器是特殊的闭包（外部函数参数是函数），但闭包不一定是装饰器)

装饰器（decorators）是 Python 中的一种高级功能，它允许你动态地修改函数或类的行为。

装饰器是一种函数，它接受一个函数作为参数，并返回一个新的函数或修改原来的函数。

装饰器的语法使用 @decorator_name 来应用在函数或方法上。

可以不带参数也可以带参数

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("在原函数之前执行")
        func(*args, **kwargs)
        print("在原函数之后执行")
    return wrapper

@my_decorator
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

装饰器本身也可以接受参数，此时需要额外定义一个外层函数

def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()

再补充一点哦看多了个 @functools.wraps(func)这个厉害了……

import functools

def my_decorator(func):
    @functools.wraps(func)  # 关键：把func的元信息复制给wrapper
    def wrapper(*args, **kwargs):
        """这是wrapper函数的文档字符串"""
        print("执行前置操作")
        result = func(*args, **kwargs)
        return result
    return wrapper

@my_decorator
def add(a, b):
    """计算两个数的和（原函数的文档字符串）"""
    return a + b

# 再次打印元信息
print(add.__name__)  # 输出：add（正确保留原函数名）
print(add.__doc__)   # 输出：计算两个数的和（原函数的文档字符串）
help(add)            # 帮助信息显示的是add，符合预期

装饰器好多写法啊啊啊啊……

Python 还提供了一些内置的装饰器，比如 @staticmethod 和 @classmethod，用于定义静态方法和类方法。