day 13 - 1 迭代器

迭代器

首先我们查看下列类型拥有的所有方法（会显示很多）

print(dir([])) 
print(dir({})) 
print(dir('')) 
print(dir(range(10)))

#求下上面列表中方法的交集
ret = set(dir([]))&set(dir({}))&set(dir(''))&set(dir(range(10))) #set 转化为列表
print(ret)

#可以注意到都有这两个双下方法
# __init__  __iter__

#我们来举一个双下方法的例子
#举例：列表的相加

print([1].__add__([2]))
print([1]+[2]) #实际执行的是 print([1].__add__([2]))

#接着我来看一下 int 类型
for i in 123:
    print(i)

#不可被循环的会提示该报错：TypeError: 'int' object is not iterable（iterable：可迭代的）
#原因是 int 类型没有该方法 __iter__

判断数据类型中是否有 __iter__ 方法

print('__iter__' in dir(int)) 　　#False
print('__iter__' in dir(bool))　　#False
print('__iter__' in dir(list))
print('__iter__' in dir(dict))
print('__iter__' in dir(set))
print('__iter__' in dir(tuple))
print('__iter__' in dir(enumerate([])))
print('__iter__' in dir(range(1)))

#方法之间也可以相减 去重（主要是查看 并没有什么用）
print(set(dir([].__iter__())) - set(dir([])))  

 

只要是能被 for 循环的数据类型 就一定拥有 __iter__ 方法，一个列表执行了 __iter__() 之后的返回值就是一个迭代器

print([].__iter__())
<list_iterator object at 0x0000000000A8F2E8> #iterator 迭代器，返回的是一个内存地址

#使用 __next__ 一个一个的取值
l = [1,2,3]
iterator = l.__iter__()
print(iterator)       　　　#列表是可以迭代的，当可迭代的后面加上 .__iter__() 方法，就可以得到一个迭代器，返回是一个内存地址
print(iterator.__next__())
print(iterator.__next__())
print(iterator.__next__())  #当无值可取时会抛出 StopIteration 的异常
print(iterator.__next__())  #for 循环就是一个迭代器 当无值可取时也会出现该异常，但是 for 已经帮我们处理了

#__length_hint__ 计算元素个数
print([1,'a','bbb'].__iter__().__length_hint__())

 

Iterable 可迭代的    ——>  __iter__ 　只要含有 __iter__ 方法的都是可迭代的 —— 可迭代协议
[].__iter__() 迭代器 ——>  __next__   通过 next 就可以从迭代器中一个一个的取值

 

简单的证明一下上面的结论

from collections import Iterable
from collections import Iterator

class A:
    def __iter__(self):pass #在这两处添加注释 然后查看下面的输出结果
    def __next__(self):pass #两次查看做下对比

a = A()
print(isinstance(a,Iterator))
print(isinstance(a,Iterable))

 

迭代器的概念

迭代器协议 —— 内部含有 __next__ 和 __iter__ 方法的就是迭代器

迭代器协议和可迭代协议

要含有 __iter__ 方法的都是可迭代的 —— 可迭代协议 
部含有 __next__ 和 __iter__ 方法的就是迭代器 —— 迭代器协议
可以被for循环的都是可迭代的
可迭代的内部都有 __iter__ 方法
只要是迭代器，一定是可迭代的
可迭代的 .__iter__() 方法就可以得到一个迭代器
迭代器中的 __next__() 方法可以一个一个的获取值

for 循环

for 循环其实就是在使用迭代器  

只有 是可迭代对象的时候 才能用 for
当我们遇到一个新的变量，不确定能不能 for 循环的时候，就判断它是否可迭代（判断它内部有没有 __iter__ ）

for 循环的运行逻辑

for i in l:
    pass
iterator = l.__iter__()
iterator.__next__()

 

迭代器的好处

从容器类型中一个一个的取值，会把所有的值都取到。
节省内存空间(因为它不是一下子发内容存到内存当中的，而是一条一条的读取)
迭代器并不会在内存中再占用一大块内存，
而是随着循环 每次生成一个
每次 next 每次给我一个

 

装饰器复习

装饰器
装饰器的作用：在不改变原来函数的调用方式的情况下，在这个函数的前后添加新的功能
完美的符合了一个开发原则：开放封闭原则
　　对扩展的是开放的
　　对修改是封闭的

基础的装饰器

from functools import wraps
def wrapper(func):
    @wraps(func)
    def inner(*args,**kwargs):
        '''在函数被调用之前添加的代码'''
        ret = func(*args,**kwargs)   # func是被装饰的函数 在这里被调用
        '''在函数被调用之后添加的代码'''
        return ret
    return inner
#使用 —— @wrapper
@wrapper
def func():   #inner
    pass

 

带参数的装饰器

@wrapper -- > @warapper(argument)
#三层嵌套函数
def outer(形参):
    def wrapper(func):
        def inner(*args,**kwargs):
            '''在函数被调用之前添加的代码'''
            ret = func(*args,**kwargs)   # func是被装饰的函数 在这里被调用
            '''在函数被调用之后添加的代码'''
            return ret
        return inner
    return wrapper

@outer(True)
def func():
    pass

 

多个装饰器装饰一个函数

from functools import wraps
def wrapper1(func):
    @wraps(func)
    def inner(*args,**kwargs):
        print('before 1')
        print('******')
        ret = func(*args,**kwargs)   # func是被装饰的函数 在这里被调用
        '''在函数被调用之后添加的代码'''
        return ret
    return inner
        
def wrapper2(func):
    @wraps(func)
    def inner(*args,**kwargs):
        print('before 2')
        ret = func(*args,**kwargs)   # func是被装饰的函数 在这里被调用
        '''在函数被调用之后添加的代码'''
        return ret
    return inner

@wrapper1
@wrapper2
def func():
    print('111')

func()

转载于:https://www.cnblogs.com/ysging/p/10089548.html