python中的迭代器，生成器，闭包，装饰器，@property

古城微笑少年丶 2022-12-13 01:28 208阅读 0赞

## 一.迭代器 ##

迭代器在Python中无处不在。它们在for循环，理解，生成器等中优雅地实现，但却隐藏在眼皮底下。

Python中的Iterator只是一个可以迭代的对象。一个将返回数据的对象，一次返回一个元素。

从技术上讲，Python 迭代器对象必须实现两个特殊方法，**iter**()和\_\_next\_\_()统称为迭代器协议。

如果我们可以从对象获得迭代器，则该对象称为可迭代。Python中的大多数内置容器（例如：list，tuple，string等）都是可迭代的。

iter()函数（也就是\_\_iter\_\_()方法）从它们返回一个迭代器。

**1示例**

my_list = [4, 7, 0, 3]
    
    # 使用iter()获得迭代器
    my_iter = iter(my_list)
    #输出 4
    print(next(my_iter))
    #输出 7
    print(next(my_iter))
    ## next（obj）与obj .__ next __()相同
    #输出 0
    print(my_iter.__next__())

![20201009090756470.png][]

**2for循环**  
在正常编码中，我们常常使用for循环来迭代

for element in iterable:
        # 对元素做点什么

其真实 for 循环 内部代码为

# 创建一个迭代器对象iterable
    iter_obj = iter(iterable)
    
    # 无限循环
    while True:
        try:
            # 获取下一项
            element = next(iter_obj)
            # 对元素做点什么
        except StopIteration:
            # 如果引发StopIteration，则从循环中断
            break

![20201009091355249.png][]

因此，在内部，for循环通过在iterable上调用iter（）创建一个迭代器对象iter\_obj。

具有讽刺意味的是，这个for循环实际上是一个无限的while循环。

在循环内部，它调用next()来获取下一个元素，并使用这个值执行for循环的主体。当所有的项都用完后，StopIteration被抛出，它在内部被捕获，循环结束。注意，任何其他类型的异常都会通过。

**3构建自己的迭代器**  
在Python中从头开始构建迭代器很容易。我们只需要实现这些方法\_\_iter\_\_()和\_\_next\_\_()。

**iter**()方法返回迭代器对象本身。如果需要，可以执行一些初始化。

**next**()方法必须返回序列中的下一项。在到达终点时，以及在随后的调用中，它必须引发StopIteration。

这里，我们展示了一个示例，它将在每次迭代中为我们提供2的次幂。幂指数从0到用户设置的数字。

class PowTwo:
        """实现迭代器的类 二的幂"""
    
        def __init__(self, max = 0):
            self.max = max
    
        def __iter__(self):
            self.n = 0
            return self
    
        def __next__(self):
            if self.n <= self.max:
                result = 2 ** self.n
                self.n += 1
                return result
            else:
                raise StopIteration
    
    
    a = PowTwo(4)
    print(a.__iter__())
    print(a.__next__())
    print(a.__next__())
    print(a.__next__())
    print(a.__next__())
    print(a.__next__())
    print(a.__next__())

![20201009091956731.png][]

## 二.生成器 ##

**1什么是生成器**  
用Python构建迭代器有很多开销; 我们必须使用\_\_iter\_\_()和\_\_next\_\_()方法实现一个类，跟踪内部状态，在没有要返回的值时触发StopIteration等等。

这既冗长又违反直觉。生成器在这种情况下可以派上用场。

Python生成器是创建迭代器的简单方法。我们上面提到的所有开销都由Python的生成器自动处理。

简而言之，生成器是一个函数，它返回一个对象（迭代器），我们可以对其进行迭代（一次一个值）。

**2如何创建生成器**  
在Python中创建生成器非常简单。 就像使用yield语句而不是return语句定义普通函数一样容易。

如果一个函数包含至少一个yield语句(它可能包含其他yield或return语句)，那么它就成为一个生成器函数。yield和return都将从函数返回一些值。

不同之处在于，当return语句完全终止一个函数时，yield语句会暂停该函数保存其所有状态，然后在后续调用时继续执行。

**3生成器函数和普通函数区别**  
生成器函数包含一个或多个yield语句。  
调用时，它返回一个对象（迭代器），但不会立即开始执行。  
像\_\_iter\_\_()和\_\_next\_\_()这样的方法会自动实现。因此，我们可以使用next()来遍历项目。  
一旦函数产生了结果，函数就会暂停，控制就会转移给调用者。  
局部变量及其状态在连续调用之间被记住。  
最后，当函数终止时，在进一步调用时会自动引发StopIteration。

**4代码**

# 一个简单的生成器函数
    def my_gen():
        n = 1
        print('这是第一次打印')
        # 生成器函数包含yield语句
        yield n
    
        n += 1
        print('这是第二次打印')
        yield n
    
        n += 1
        print('这是最后一次打印')
        yield n
    
    a=my_gen()
    print(a.__next__())
    print(a.__next__())
    print(next(a))
    print(next(a))

![20201009094047202.png][]

**5生成器表达式**  
使用生成器表达式可以轻松地动态创建简单的生成器。它使建造生成器变得容易。  
与lambda函数创建匿名函数相同，生成器表达式创建匿名生成器函数。  
生成器表达式的语法类似于Python中的列表理解语法。但是将方括号替换为圆括号。  
列表理解与生成器表达式之间的主要区别在于，虽然列表理解生成整个列表，但生成器表达式一次生成一个项目。  
他们有点懒，只在需要时才生成项目。由于这个原因，生成器表达式比等价的列表理解的内存效率要高得多。

# 初始化列表
    my_list = [1, 3, 6, 10]
    
    # 使用列表理解对每个项目进行平方
    # 输出: [1, 9, 36, 100]
    print('[x**2 for x in my_list]:',[x**2 for x in my_list])
    
    # 同样的事情可以使用生成器表达式来完成
    # 输出: <generator object <genexpr> at 0x0000000002EBDAF8>
    a=(x**2 for x in my_list)
    print('a:',a)
    print('next(a):',next(a))

![20201009094454592.png][]

## 三.闭包 ##

**1嵌套函数中的非局部变量**  
在了解闭包是什么之前，我们必须首先了解什么是嵌套函数和非局部变量。  
在另一个函数内部定义的函数称为嵌套函数。嵌套函数可以访问封闭范围的变量。  
在Python中，默认情况下，这些非本地变量是只读的，并且我们必须将它们明确声明为非本地变量（使用nonlocal关键字）才能进行修改。  
以下是访问非局部变量的嵌套函数的示例。

def print_msg(msg):
    # 这是外部封闭函数
    
        def printer():
    # 这是嵌套函数
            print(msg)
    
        printer()
    
    # 我们执行这个函数
    # 输出: Hello
    print_msg("Hello")

![20201009095345815.png][]

**2定义闭包函数**

在上面的示例中，如果函数print\_msg()的最后一行返回了printer()函数而不是调用它，将会发生什么？ 这意味着功能定义如下。

def print_msg(msg):
    # 这是外部封闭函数
    
        def printer():
    # 这是嵌套函数
            print(msg)
    
        return printer  # 这变了
    
    # 现在，让我们尝试调用此函数。
    # 输出: Hello
    another = print_msg("Hello")
    another()

![20201009095625219.png][]

这很不寻常。  
print\_msg()函数用字符串调用，"Hello"返回的函数绑定到另一个名称。在调用时another()，尽管我们已经完成了print\_msg()函数的执行，但仍然记得该消息。  
这种将一些数据（“Hello”）附加到代码上的技术在Python中称为闭包。  
即使变量超出范围或函数本身已从当前命名空间中删除，也会记住封闭范围中的这个值。

**3闭包的条件**  
从上面的实例可以看出，在Python中，当嵌套的函数在其封闭的范围内引用一个值时，我们有一个闭包。  
以下几点总结了在Python中创建闭包必须满足的条件。

1.  我们必须有一个嵌套函数（函数在函数内部）。
2.  嵌套函数必须引用在封闭函数中定义的值。
3.  封闭函数必须返回嵌套函数。

**4何时使用闭包**  
那么，闭包有什么用呢？  
闭包可以避免使用全局值，并提供某种形式的数据隐藏。它还可以为该问题提供面向对象的解决方案。  
当在一个类中实现的方法很少（大多数情况下是一个方法）时，闭包可以提供另一种更优雅的解决方案。但是，当属性和方法的数量变大时，最好实现一个类。  
这是一个简单的示例，其中闭包可能比定义类和创建对象更可取。

def make_multiplier_of(n):
        def multiplier(x):
            return x * n
        return multiplier
    
    # 3的乘数
    times3 = make_multiplier_of(3)
    
    # 5的乘数
    times5 = make_multiplier_of(5)
    
    # 输出: 27
    print(times3(9))#此时x=9
    
    # 输出: 15
    print(times5(3))#此时x=3
    
    # 输出: 30
    print(times5(times3(2)))#times3(2)=6，x=times3(2)

![20201009100510301.png][]

## 四.装饰器 ##

**1.什么是装饰器**  
装饰器接受一个函数，添加一些功能并返回它。  
Python有一个有趣的功能，称为装饰器，可将功能添加到现有代码中。  
这也称为元编程，因为程序的一部分试图在编译时修改程序的另一部分。

**2学习装饰器的先决条件**  
为了了解装饰器，我们必须首先了解Python的一些基本知识。  
我们必须接受这样一个事实，即Python中的所有内容都是对象。我们定义的名称只是绑定到这些对象的标识符。函数也不例外，它们也是对象（带有属性）。可以将各种不同的名称绑定到同一功能对象。  
这是一个实例。

def first(msg):
        print(msg)    
    
    first("Hello")
    
    second = first
    second("Hello")

当您运行代码时，这两个函数first和second给出相同的输出。在此，名称first和second指代相同的功能对象。  
现在情况是不是感觉变复杂了点，可以将函数作为参数传递给另一个函数。  
如果您在Python中使用过map，filter和reduce之类的函数，那么您已经知道这一点。  
这种以其他函数为参数的函数也称为高阶函数。这是这种函数的一个实例。

def inc(x):
        return x + 1
    
    def dec(x):
        return x - 1
    
    def operate(func, x):
        result = func(x)
        return result
    operate(inc,3)#4
    operate(dec,3)#2

此外，一个函数可以返回另一个函数。 即闭包

def is_called():
        def is_returned():
            print("Hello")
        return is_returned
    
    new = is_called()
    
    #输出 "Hello"
    new()

**3回到装饰器**  
函数和方法被称为可调用的，因为它们可以被调用。  
实际上，任何实现特殊方法\_\_call \_\_()的对象都称为可调用的。 因此，从最基本的意义上讲，装饰器是可调用的，可返回可调用的。  
基本上，装饰器接受一个函数，添加一些功能并返回它。

def make_pretty(func):
        def inner():
            print("我被装饰了")
            func()
        return inner
    
    def ordinary():
        print("我是普通的函数")
    
    ordinary()
    print('.....')
    pretty = make_pretty(ordinary)
    pretty()

![20201009102357501.png][]

在上面显示的示例中，make\_pretty()是一个装饰器。在分配步骤中。

> pretty = make\_pretty(ordinary)

函数ordinary()被修饰，返回的函数被命名为pretty。  
我们可以看到decorator函数在原来的函数中添加了一些新功能。这类似于包装礼物。装饰器充当包装器。被装饰的物品(里面的礼物)的性质不会改变。但是现在，它看起来很漂亮(自从装饰之后)。  
通常，我们装饰一个函数并将其重新分配为

> ordinary = make\_pretty(ordinary).

这是一个常见的构造，因此，Python具有简化此语法的语法。  
我们可以将@符号与装饰器函数的名称一起使用，并将其放置在要装饰的函数的定义上方。例如，

def make_pretty(func):
        def inner():
            print("我被装饰了")
            func()
        return inner
    
    @make_pretty
    def ordinary():
        print("我是普通的函数")
    ordinary()

![20201009102917464.png][]

相当于

def ordinary():
        print("我是普通的函数")
    ordinary = make_pretty(ordinary)

**4.带参数的装饰器**  
装饰器里有很多闭包知识

def smart_divide(func):
       def inner(a,b):
          print("我要做除法",a,"和",b)
          if b == 0:
             print("哎呀!不能除")
             return
    
          return func(a,b)
       return inner
    
    @smart_divide
    def divide(a,b):
        return a/b
    
    print(divide(2,5))

![20201009103337694.png][]

通过这种方式，我们可以装饰带有参数的函数。  
敏锐的观察者会注意到，inner()装饰器内部的嵌套函数的参数与其装饰的函数的参数相同。考虑到这一点，现在我们可以使通用装饰器可以使用任意数量的参数。  
在Python中，此魔术是通过完成的function(\*args, \*\*kwargs)。这样，args是位置参数的元组，kwargs而是关键字参数的字典。这样的装饰器的一个实例是。

def works_for_all(func):
        def inner(*args, **kwargs):
            print("我可以装饰任何函数")
            return func(*args, **kwargs)
        return inner

**5.链接装饰器**  
可以在Python中链接多个装饰器。  
这就是说，一个函数可以用不同（或相同）的装饰器多次装饰。我们只需将装饰器放置在所需函数之上。

def star(func):
        def inner(*args, **kwargs):
            print("*" * 30)
            func(*args, **kwargs)
            print("*" * 30)
        return inner
    
    def percent(func):
        def inner(*args, **kwargs):
            print("%" * 30)
            func(*args, **kwargs)
            print("%" * 30)
        return inner
    
    @star
    @percent
    def printer(msg):
        print(msg)
    printer("Hello")

![20201009103903886.png][]

## 五.@property ##

在定义和详细了解@property是什么之前，让我们了解为什么首先需要使用它。、  
一个实例开始  
假设您决定创建一个以摄氏度为单位存储温度的类。它还将实现一种将温度转换为华氏温度的方法。其中一种方法如下。

class Celsius:
        def __init__(self, temperature = 0):
            self.temperature = temperature
    
        def to_fahrenheit(self):
            return (self.temperature * 1.8) + 32
    # 创建新对象
    man = Celsius()
    # 设定温度
    man.temperature = 37
    # 获得华氏度
    print(man.to_fahrenheit())

![20201009105452706.png][]

如上所示，每当我们分配或检索任何对象属性（如temperature）时，Python都会在对象的\_\_dict\_\_字典中进行搜索。

> man.**dict**  
> \{‘temperature’: 37\}

现在，让我们进一步假设我们的课程在客户中很受欢迎，并且他们开始在程序中使用它。 他们对对象进行了各种分配。

有一天，一个值得信赖的客户来找我们，建议温度不能低于-273摄氏度(热力学专业的学生可能会说实际上是-273.15摄氏度)，也被称为绝对零度。他进一步要求我们实现这个值约束。作为一家追求客户满意度的公司，我们很高兴地听取了这个建议，并发布了1.01版本(对现有类的升级)。

**1 使用getter和setter**  
解决上述约束的一个明显方法是隐藏属性temperature（将其设为私有），并定义新的getter和setter接口以对其进行操作。这可以如下进行。

class Celsius:
        def __init__(self, temperature = 0):
            self.set_temperature(temperature)
    
        def to_fahrenheit(self):
            return (self.get_temperature() * 1.8) + 32
    
        # new update
        def get_temperature(self):
            return self._temperature
    
        def set_temperature(self, value):
            if value < -273:
                raise ValueError("-273度是不可能的")
            self._temperature = value

我们在上面可以看到get\_temperature()，set\_temperature()已经定义了新方法，此外，用\_temperature替换了temperature。下划线(\_)开头表示Python中的私有变量。

> c = Celsius(-277)  
> Traceback (most recent call last):

ValueError: Temperature below -273 is not possible

> c = Celsius(37)  
> c.get\_temperature()  
> 37  
> c.set\_temperature(10)  
> c.set\_temperature(-300)  
> Traceback (most recent call last):  
> ValueError: Temperature below -273 is not possible

但这不是一个大问题。上述更新的最大问题在于，所有在程序中实现了上一类的客户端都必须将其代码从obj.temperature修改为obj.get\_temperature()，并将所有分配（例如obj.temperature = val修改为obj.set\_temperature（ val）)。

这种重构会给客户带来数十万行代码的麻烦。

总而言之，我们的新更新不向后兼容。这是@property发挥作用的地方。

**2@property的力量**  
python处理上述问题的方法是使用property。我们可以这样来实现它。

class Celsius:
        def __init__(self, temperature = 0):
            self.temperature = temperature
    
        def to_fahrenheit(self):
            return (self.temperature * 1.8) + 32
    
        def get_temperature(self):
            print("获得的值")
            return self._temperature
    
        def set_temperature(self, value):
            if value < -273:
                raise ValueError("零下273度是不可能的")
            print("设定值")
            self._temperature = value
    
        temperature = property(get_temperature,set_temperature)
    c = Celsius()

同样，任何访问如c.temperature都会自动调用get\_temperature()。 这就是属性的作用。 这里还有一些实例。

同样，任何设定.temperature都会自动调用set\_temperature()。 这就是属性的作用。  
![20201009111335444.png][]

任何检索温度值的代码都将自动调用get\_temperature()而不是字典(**dict**)查找。 同样，任何为温度分配值的代码都会自动调用set\_temperature()。 这是Python中的一项很酷的功能。  
我们可以在上面看到即使创建对象时也会调用set\_temperature()。

**3深入了解property**  
在Python中，property()是一个内置函数，用于创建并返回属性对象。该函数的签名是

> property(fget=None, fset=None, fdel=None, doc=None)

其中，fget为获取属性值的函数，fset为设置属性值的函数，fdel为删除属性的函数，doc为字符串(如注释)。从实现中可以看出，这些函数参数是可选的。因此，可以简单地按照以下方式创建属性对象。

属性对象有三个方法，getter()、setter()和deleter()，用于稍后指定fget、fset和fdel。这意味着

> temperature = property(get\_temperature,set\_temperature)

也可以分解为

> 创建空属性  
> temperature = property()  
> 设置 fget  
> temperature = temperature.getter(get\_temperature)  
> \#设置 fset  
> temperature = temperature.setter(set\_temperature)

熟悉Python中装饰器的程序员可以认识到上述构造可以实现为装饰器。

我们可以更进一步，不定义名称get\_temperature，set\_temperature，因为它们是不必要的，并且会影响类命名空间。为此，我们在定义getter和setter函数时重用了名称temperature。这是可以做到的。

class Celsius:
        def __init__(self, temperature = 0):
            self._temperature = temperature
    
        def to_fahrenheit(self):
            return (self.temperature * 1.8) + 32
    
        @property
        def temperature(self):
            print("获得值")
            return self._temperature
    
        @temperature.setter
        def temperature(self, value):
            if value < -273:
                raise ValueError("零下273度是不可能的")
            print("设定值")
            self._temperature = value

![在这里插入图片描述][20201009112318164.jpg_pic_center]  
电气工程的计算机萌新：余登武。  
写博文不容易，如果你觉得本文对你有用，请点个赞支持下，谢谢。  
![在这里插入图片描述][20201009112415242.gif_pic_center]

[20201009090756470.png]: /images/20221123/ba22a96986f240aca1c8267cc8ee7259.png
[20201009091355249.png]: /images/20221123/b2fc34cb87c4499691d20a9ad401cde5.png
[20201009091956731.png]: /images/20221123/8bdbec82e15b4f389487ec76f50fabdc.png
[20201009094047202.png]: /images/20221123/803be4ac212b4c89b72b4ca245a46ab6.png
[20201009094454592.png]: /images/20221123/2c5990679ffb4ae489168b4092212cb0.png
[20201009095345815.png]: /images/20221123/a8cf4596b58347fd8cdeebd6b9d2f897.png
[20201009095625219.png]: /images/20221123/2418f1f07eb8452d9b115f58fc0088c2.png
[20201009100510301.png]: /images/20221123/a3bdb3be477a419493ce8e27487dddcb.png
[20201009102357501.png]: /images/20221123/bac6d9b87a3d4e00a982a2a70cc41b8c.png
[20201009102917464.png]: /images/20221123/53023c97fd6549da804859f285613c70.png
[20201009103337694.png]: /images/20221123/2d3c211649cd4a098bb7dbb11d591e2f.png
[20201009103903886.png]: /images/20221123/daf9afbe446645c5861d51f4f7dd8db3.png
[20201009105452706.png]: /images/20221123/06076f60cab84a699667c9a4dc784d5f.png
[20201009111335444.png]: /images/20221123/4bb7ea127773487f9d69275eab332f6c.png
[20201009112318164.jpg_pic_center]: /images/20221123/6d140088b49b43788a88d251dc09d469.png
[20201009112415242.gif_pic_center]: /images/20221123/cf8bed3eadd94cc9bd5d24cbb6110aa2.png