Python你必须了解的一些点——迭代器、生成器和装饰器

我会带着你远行 2023-02-14 02:21 19阅读 0赞

### Python 的迭代器、生成器和装饰器 ###

*   *  迭代器
     *   *   *  可迭代对象与迭代器
             *  两个例子
     *  生成器
     *   *   *  定义&特点
             *  工作原理
             *  如何创建生成器
     *  装饰器
     *   *   *  初级装饰器入门
             *  稍微高级一点点的
             *  基于类实现的装饰器

## 迭代器 ##

1.  迭代是Python最强大的功能之一，是访问集合元素的一种方式。
2.  迭代器是一个可以记住遍历的位置的对象。
3.  迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
4.  迭代器有两个基本的方法：iter() 和 next()。
5.  字符串，列表或元组对象都可用于创建迭代器：

#### 可迭代对象与迭代器 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMTA4MjM3_size_16_color_FFFFFF_t_70]

首先我们要明确一点：**可迭代对象≠迭代器！！**

1.  可迭代对象包含迭代器。
2.  如果一个对象拥有\_\_iter\_\_方法，其是可迭代对象；如果一个对象拥有next方法，其是迭代器。
3.  定义可迭代对象，必须实现\_\_iter\_\_方法；定义迭代器，必须实现\_\_iter\_\_和next方法。

你也许会问，结论3与结论2是不是有一点矛盾？既然一个对象拥有了**next**方法就是迭代器，那为什么迭代器必须同时实现两方法呢？

因为结论1，迭代器也是可迭代对象，因此迭代器必须也实现`__iter__`方法。

介绍一下涉及到的两个方法：

1）`__iter__()`

该方法返回的是当前对象的迭代器类的实例。因为可迭代对象与迭代器都要实现这个方法，因此有以下两种写法。

写法一：用于可迭代对象类的写法，返回该可迭代对象的迭代器类的实例。

写法二：用于迭代器类的写法，直接返回self（即自己本身），表示自身即是自己的迭代器。

也许有点晕，没关系，下面会给出两写法的例子，我们结合具体例子看。

2）`next()`  
返回迭代的每一步，实现该方法时注意要最后超出边界要抛出StopIteration异常。

#### 两个例子 ####

下面举个可迭代对象与迭代器的例子：

#!/usr/bin/env python  
    # coding=utf-8  
      
      
    class MyList(object):            # 定义可迭代对象类  
      
        def __init__(self, num):  
            self.data = num          # 上边界  
      
        def __iter__(self):  
            return MyListIterator(self.data)  # 返回该可迭代对象的迭代器类的实例  
      
      
    class MyListIterator(object):    # 定义迭代器类，其是MyList可迭代对象的迭代器类  
      
        def __init__(self, data):  
            self.data = data         # 上边界  
            self.now = 0             # 当前迭代值，初始为0  
      
        def __iter__(self):  
            return self              # 返回该对象的迭代器类的实例；因为自己就是迭代器，所以返回self  
      
        def next(self):              # 迭代器类必须实现的方法  
            while self.now < self.data:  
                self.now += 1  
                return self.now - 1  # 返回当前迭代值  
            raise StopIteration      # 超出上边界，抛出异常  
      
    
    my_list = MyList(5)              # 得到一个可迭代对象  
    print type(my_list)              # 返回该对象的类型  
      
    my_list_iter = iter(my_list)     # 得到该对象的迭代器实例，iter函数在下面会详细解释  
    print type(my_list_iter)  
      
      
    for i in my_list:                # 迭代  
        print i

迭代器实现简单的斐波那契：

class Fib():
        def __init__(self, n):
            self.a = 0
            self.b = 1
            self.n = n
            self.count = 0
        def __iter__(self):
            return self
        def next(self):
            res = self.a
            self.a, self.b = self.b, self.a + self.b
            if self.count > self.n:
                raise StopIteration
            self.count += 1
            return res
    print(list(Fib(5)))
    print(list(Fib(10)))

--------------------

## 生成器 ##

#### 定义&特点 ####

在**Python**中，一边循环一边计算的机制，称为生成器：**generator**。

生成器也是一种**迭代器**，但是你只能对其迭代**一次**。这是因为它们并没有把所有的值存在内存中，而是在运行时生成值。

你通过遍历来使用它们，要么用一个for循环，要么将它们传递给任意可以进行迭代的函数和结构。大多数时候生成器是以函数来实现的。然而，它们并不返回一个值，而是`yield`(暂且译作“生出”)一个值。

每次对生成器调用 `next()` 时，它会从上次离开位置恢复执行（它会记住上次执行语句时的所有数据值）。

--------------------

特点：

*  和传统的容器相比，生成器更节省内存。
 *  延迟计算，在我们需要结果时就调用一下生成器的next()方法即可。
 *  可迭代，你可以像遍历list一样，遍历生成器

#### 工作原理 ####

1.  生成器(**generator**)能够迭代的关键是它有一个`next()`方法，工作原理就是通过重复调用next()方法，直到捕获一个异常。
2.  带有 yield 的函数不再是一个普通函数，而是一个生成器**generator**。可用`next()`调用生成器对象来取值。next 两种方式 `t.__next__() | next(t)`。可用for 循环获取返回值（每执行一次，取生成器里面一个值）（基本上不会用`next()`来获取下一个返回值，而是直接使用**for**循环来迭代）。
3.  **yield**相当于 **return** 返回一个值，并且记住这个返回的位置，下次迭代时，代码从**yield**的下一条语句开始执行。
4.  `send()` 和`next()`一样，都能让生成器继续往下走一步（下次遇到**yield**停），但`send()`能传一个值，这个值作为yield表达式整体的结果

——换句话说，就是**send**可以强行修改上一个yield表达式值。比如函数中有一个**yield**赋值，`a = yield 5`，第一次迭代到这里会返回5，a还没有赋值。第二次迭代时，使用`.send(10)`，那么，就是强行修改yield 5表达式的值为10，本来是5的，那么a=10

#### 如何创建生成器 ####

法一：

*  列表推导式，将\[\]改为()即可，例如：

>>> L = [x * x for x in range(10)]
    >>> L
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    >>> g = (x * x for x in range(10))
    >>> g
    
    <generator object <genexpr> at 0x1022ef630>

法二：  
在函数中使用`yield`关键字，那么这个函数就不再是一个普通函数，而是一个generator。调用函数就是创建了一个生成器（generator）对象。例如：

#生成器生成斐波那契
    def fib(max_num):
        a,b = 1,1
        while a < max_num:
            yield b
            a,b=b,a+b
    
    g = fib(10)               #生成一个生成器：[1，2, 3, 5, 8, 13]
    print(g.__next__())       #第一次调用返回：1
    print(list(g))            #把剩下元素变成列表：[2, 3, 5, 8, 13]

--------------------

## 装饰器 ##

概括的讲，装饰器的作用就是为已经存在的函数或对象添加额外的功能。  
想要理解**Python**中的装饰器，不得不先理解闭包（**closure**）这一概念。  
维基百科是这样解释的：

> 在计算机科学中，闭包（英语：**Closure**），又称词法闭包（**Lexical Closure**）或函数闭包（**function closures**），是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。

还是看看可读性更高的代码吧：

# print_msg是外围函数
    def print_msg():
        msg = "I'm closure"
    
        # printer是嵌套函数
        def printer():
            print(msg)
    
        return printer
    
    # 这里获得的就是一个闭包
    closure = print_msg()
    # 输出 I'm closure
    closure()

上面我们就成功的获得了一个闭包。

#### 初级装饰器入门 ####

def debug(func):
        def wrapper(*args, **kwargs):  # 指定宇宙无敌参数
            print "[DEBUG]: enter {}()".format(func.__name__)
            print 'Prepare and say...',
            return func(*args, **kwargs)
        return wrapper  # 返回
    
    @debug
    def say(something):
        print "hello {}!".format(something)

上例多亏了**Python**提供了可变参数`*args`和关键字参数`**kwargs`，有了这两个参数，装饰器就可以用于任意目标函数了。掌握了上例，你也就基本明白了简单装饰器该如何实现。

--------------------

#### 稍微高级一点点的 ####

def logging(level):
        def wrapper(func):
            def inner_wrapper(*args, **kwargs):
                print(f"[{level}]: enter function {func.__name__}()")
                return func(*args, **kwargs)
    
            return inner_wrapper
    
        return wrapper
    
    
    @logging(level='INFO')
    def say(something):
        print("say {}!".format(something))
    
    
    @logging(level='DEBUG')
    def do(something):
        print("do %s..."% something)
    
    
    if __name__ == '__main__':
        say('hello')
        do("my work")

运行结果如下，是不是很简单？  
![在这里插入图片描述][20200531101558455.jpg]  
实际上当带参数的装饰器被打在某个函数上时，比如`@logging(level='DEBUG')`，它其实是一个函数，会马上被执行，只要这个它返回的结果是一个装饰器时，那就没问题。再体会一下吧~

再附上一个使用装饰器计算函数运行时间的小demo：

import functools
    import time
    
    def run_time(fn):
        @functools.wraps(fn)
        def wrapper(*args, **kw):
            start = time.time()
            res = fn(*args, **kw)
            print('%s 运行了 %f 秒' % (fn.__name__, time.time() - start))
            return res
    
        return wrapper
       
    
    #测试
    @run_time
    def test(n):
        time.sleep(n)
        print("运行结束了")
    
    test(3)

--------------------

#### 基于类实现的装饰器 ####

装饰器要求接受一个**callable**对象，并返回一个**callable**对象。我们可以让类的构造函数`__init__()`接受一个函数，然后重载`__call__()`并返回一个函数，也可以达到装饰器函数的效果。下面就是一个使用类创建装饰器的简单例子，一起来看一下吧！

class logging(object):
        def __init__(self, func):
            self.func = func
    
        def __call__(self, *args, **kwargs):
            print "[DEBUG]: enter function {func}()".format(
                func=self.func.__name__)
            return self.func(*args, **kwargs)
    @logging
    def say(something):
        print "say {}!".format(something)

如果需要一个带参数的装饰器，那么在构造函数里接受的就不是一个函数，而是传入的参数。通过类把这些参数保存起来。然后在重载`__call__()`接受并返回一个函数

class logging(object):
        def __init__(self, level='INFO'):
            self.level = level
            
        def __call__(self, func): # 接受函数
            def wrapper(*args, **kwargs):
                print "[{level}]: enter function {func}()".format(
                    level=self.level,
                    func=func.__name__)
                func(*args, **kwargs)
            return wrapper  #返回函数
    
    @logging(level='INFO')
    def say(something):
        print "say {}!".format(something)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMTA4MjM3_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200531093940944.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMTA4MjM3,size_16,color_FFFFFF,t_70
[20200531101558455.jpg]: https://img-blog.csdnimg.cn/20200531101558455.jpg