python迭代器-16

2.迭代器

可迭代对象：

• list，str，tuple etc. ---->for…in…遍历---->遍历(迭代)

迭代器协议：

• 对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么引起StopIteration异常，以终止迭代（只能往下走，不可以回退）

实现了迭代器协议对象就是和迭代对象。

实现：

• 通过在对象内部定义一个__iter__方法

li=[1,2,3]
li_iter=li.__iter__()
print(li_iter.__next__())
print(next(li_iter))
print(li.__iter__().__next__())
print(next(iter(li)))
#1 2 1 1

#**可迭代对象测试**
from collections.abc import Iterable
#使用instance()来判断对象是否可迭代
print(isinstance([],Iterable))
#True

类的迭代

在迭代一个可迭代的对象时，实际上是获取该对象的一个迭代器。然后通过该迭代器依次获取对象的每一个数据。

from collections.abc import Iterable
class People:
    def __init__(self):
        self.names=[]
    def add(self,name):
        self.names.append(name)
    def __iter__(self):
        return self.names.__iter__()
peo=People()
peo.add('sheep')
peo.add('Tom')
peo.add('jack')
print(isinstance(peo,Iterable))
for tem in peo:
    print(tem,end=' ')
#True
#sheep Tom jack 

if no 7,8行：
	print(isinstance(peo,Iterable))
is False

通过迭代器迭代

tem=iter(peo)
print(next(tem))
#sheep

结论：for …in…循环的本质就是通过iter（）函数获取可迭代对象的Iterable迭代器，然后对获取到的迭代器不断调用next（）方法来获取下一个值并将其赋值，当遇到StopIteration异常后，退出。

应用场景

迭代器的 核心就是通过next（）函数调用返回下一个数据值。如果每次返回的数据值不是在一个已有的数据聚合中读取的，而是通过程序按照一定规律计算生产。那么也就意味着可以不用依赖一个已有的数据集，namely，无需将所有的迭代对象数据一次性缓存下来供后续使用。这样可以节省大量的存储空间。

demo：

斐波那契数列

class FibIt(object):
    '''斐波那契数列迭代器'''
    def __init__(self,n):
        #记录生成的斐波那契数列
        self.n=n
        #记录当前记录的索引
        self.current_index=0
        #记录两个初始值
        self.num1 = 0
        self.num2 = 1

    def __next__(self):
        '''调用next（）函数来获取下一个数'''
        if self.current_index<self.n:
            num = self.num1
            self.num1,self.num2=self.num2,self.num1+self.num2
            self.current_index+=1
            return num
        else:
            raise StopIteration
    def __iter__(self):
        return self

fi=FibIt(10)
for num in fi:
    print(num,end=' ')

生成器

利用迭代器，我们可以在每次迭代获取数据（通过next()方法）时按照特定的规律进行生成。但是我们在实现一个迭代器时，关于当前迭代到的状态需要我们自己记录，进而才能根据当前状态生成下一个数据。为了达到记录当前状态，并配合next()函数进行迭代使用，我们可以采用更简便的语法，即生成器(generator)。生成器是一类特殊的迭代器

要创建一个生成器，有很多种方法。

第一种方法很简单，只要把一个列表生成式的 [ ] 改成 ( )

G = ( x*2 for x in range(5))
print(next(G))
print(next(G))
print(next(G))

生成器函数

在函数中如果出现了yield关键字，那么该函数就不再是一个普通函数而是一个生成器函数。

def foo():
    yield  1
    yield  2
f=foo()
print(next(f))
print(next(f))

next 和yield 进行匹配

构造一个产生无穷奇数的生成器

def odd():
    n=1
    while True:
        yield n
        n+=2
a=odd()
while True:
    print(next(a),end=' ')
    
#类定义    
class odd(object):
    def __init__(self):
        self.n=1
    def __iter__(self):
        return self
    def __next__(self):
        self.n+=2
        return self.n
a=odd
for i in a:
    print(i)

生成器支持的方法

• close()
  • 手动关闭生成器函数，后面调用会直接引起异常
• send()
  • temp=yield i 赋值
  • 使用send()函数的一个好处是可以在唤醒的同时向断点处传入一个附加数据。
  • 如果生成器未启动，则必须在使用send前启动生成器，使用方法可以是a.next(),也可以是a.send(None)执行到第一个yield处
  • 如果是已启动，则send（para）的作用就是给x赋值

def bow():
    value=0
    while True:
        re=yield value
        if re=='e':
            break
        value='got : %s'%re
#send()的作用就是使re赋值为其所传送的值，然后让生成器执行到下一个yield
b=bow()
print(b.send(None))
print(b.send('a'))
print(b.send('b'))
#0
#got : a
#got : b
b.__next__()
print(b.send('a'))
print(b.send('b'))
#got : a
#got : b

• throw()
  • 手动抛出异常

闭包

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

闭包：

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

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()