python学习日志——迭代器、生成器和装饰器

迭代器

可迭代对象:list,str,tuple etc

迭代器协议：对象必须提供一个next方法，执行方法要么返回迭代中的下一项，要么引起异常

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

迭代器是一个可以记住遍历的位置的对象，它有两个基本的方法：iter() 和 next()。

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

而对迭代对象的遍历方式就很多变了：

li = [1,2,3,4]
it = iter(li)
print(next(it))
print(next(it))
for i in it:
    print(i, end=' ')

输出结果为：

1
2
3 4 

可迭代对象测试：

from collections import Iterable
print(isinstance([],Iterable))
print(isinstance({},Iterable))
print(isinstance('',Iterable))
print(isinstance(set(),Iterable))

结果为:

True
True
True
True

创建一个迭代器

比如这个例子

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        x = self.a
        self.a += 1
        return x


myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

输出结果为：

1
2
3
4
5

这个例子就是把一个类作为一个迭代器，就需要实现以下两个方法：

__iter__()方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。

__next__()方法（Python 2 里是 next()）会返回下一个迭代器对象。

StopIteration

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

在 20 次迭代后停止执行：

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)

结果输出为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

生成器

利用迭代器，可以在每次迭代获取数据时（通过next()方法）按照特定的规律进行生成。

但我们在实现一个迭代器是，关于每次迭代的状态需要我们自己记录，进而才能根据当前的状态生成下一个数据。

为了达到记录状态，并配合next()方法进行迭代使用，可以采用更简洁的语法

以下实例使用 yield 实现斐波那契数列：

import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

执行以上程序，输出结果如下：

0 1 1 2 3 5 8 13 21 34 55

闭包

闭是封闭（函数中的函数），包是包含（该内部函数对外部函数作用域而非全局作用域变量的引用）

闭包：

• 内部函数对外部函数作用域里的变量的引用
• 函数内的属性，都是有生命周期，都是在函数执行期间
• 闭包内的闭包函数私有化了变量，完成了数据封装，类似面向对象

demo：

def s():
    print('s()')
    def st(num):
        print('st()')
        print(num)
    return st
a=s()
a(10)
#s()
#st()
#10

装饰器

装饰器存在的意义

• 不影响原有函数功能
• 可以添加新功能

一般常见的，比如拿到第三方的API接口，第三方不允许修改这个接口。这个时候装饰器就派上了用场。

装饰器本身也是一个函数，作用是为现有存在的函数，在不改变函数的基础上，增加一些功能进行装饰。

它是以闭包的形式去实现的。

在使用装饰器函数时，在被装饰器的函数前一行，使用@装饰器函数名形式来进行装饰

Demo：

现在一个项目中有很多函数，由于我们项目越来越大，功能也越来越多，就会导致程序越来越慢。

其中一个功能函数的功能，是实现一百万次的累加。

import time
def count_time(fun):
    def wapper():
        start=time.time()
        fun()
        end=time.time()
        print(end-start)
    return wapper

@count_time
def my_count():
    s=0
    for i in range(10000):
        s+=i
    print('sum=',s)

my_count()