day13: 迭代器和生成器

1，思考所有可以被for循环的：list,tuple,set,dict,range,enumerate,f,str,差不多了，为何这些数据类型可以被for循环呢？

2，一个标准的装饰器函数

from functools import wraps
def wrapper(f):
    @wraps(f)
    def inner(*args,**kwargs):
        # 被装饰函数调用之前添加的功能
        ret = f(*args,**kwargs)
        # 被装饰函数调用之后添加的功能
        return ret
    return inner

@wrapper
def func():
     print("i am func")
     
func()

3，查看一个变量或者是数据类型的所有方法dir

print(dir([])) # 告诉我字典拥有的所有方法
[].__add__()  # 这些方法都可以通过点来调用

4，双下方法，一般双下方法我们不会自己去调用，通常是执行其他操作的时候，自动调用的，也叫做魔法方法

# 运行加操作的时候，会自动调用双下add方法
print([1]+[2])
print([1].__add__([2]))

5，结论，只要是可以被for循环的就有__iter__方法

# 我想查看一下这些数据有哪些共同的方法
# ret = set(dir([]))&set(dir({}))&set(dir(''))&set(dir(range(10))) # 求交集
# print(ret)

# 发现了一个和可迭代的Iterable很像的双下函数__iter__

# 那我们来查看一下intl类型是否有这个函数
print("__iter__" in dir(int))  #结果为false
print("__iter__" in dir(bool))
# 看看其他的类型有没有这个函数
print("__iter__" in dir(str))
print("__iter__" in dir(dict))
print("__iter__" in dir(set))
print("__iter__" in dir(list))
print("__iter__" in dir(tuple))
print("__iter__" in dir(enumerate))
print("__iter__" in dir(range))

运行结果：
False
False
True
True
True
True
True
True
True

6，那我们看一下者个__iter__是个什么鬼？结论：他们都是iterator,所有这些数据，执行了__iter__之后返回的都是一个iterator,就是迭代器

print([])
print([].__iter__())
print(list.__iter__([]))
print({}.__iter__())
print({1:2}.__iter__())
print(range(3).__iter__())
print(''.__iter__())
print(enumerate([]).__iter__())
print((1,).__iter__())

运行结果：
[]
<list_iterator object at 0x10b127630>
<list_iterator object at 0x10b127630>
<dict_keyiterator object at 0x10b0d8e08>
<dict_keyiterator object at 0x10b0d8e08>
<range_iterator object at 0x10b16c4e0>
<str_iterator object at 0x10b0f77b8>
<enumerate object at 0x10b200990>
<tuple_iterator object at 0x10b127630>

7,看看迭代器独有的函数有哪些？ 他们有一个共同的函数就是__next__

# 那我们看看迭代器比原来的数据多了哪些函数？求差集
print(set(dir([].__iter__()))-set(dir([])))
print(set(dir({}.__iter__()))-set(dir({})))
print(set(dir(''.__iter__()))-set(dir('')))
print(set(dir(range(10).__iter__()))-set(dir(range(10))))
# lengh_hint 元素个数
运行结果：
{'__length_hint__', '__next__', '__setstate__'}
{'__length_hint__', '__next__'}
{'__length_hint__', '__next__', '__setstate__'}
{'__length_hint__', '__next__', '__setstate__'}

8,结论，可迭代的，只要含有__iter__方法的就是可迭代的，可迭代协议里面规定的，协议就是约定好了的

迭代器都是可迭代的，可迭代的不一定是迭代器，只要是可以for循环的就都是可迭代的,就有__iter__方法，只有可迭代的才可以用for

写成可迭代对象，就是为了用for，不确定是否可以for，判断一下是否是可迭代的。

9，迭代器，迭代器协议，从容器中一个一个取值，可以取到所有的值，节省内存空间，含有__next__方法和__iter__两个方法

迭代器并不会在内存中在占用一大块内存，而是随着循环，每次生成一个，每次next在给我一个，要一个给一个，内存中永远只有一个

而且执行速度不会慢，就算真的一次全部要过来，操作系统，找地存这些数据也是很浪费时间的，所以迭代器还是很有好处的

my_list =[1,2,3,4]
my_list_iter =my_list.__iter__()


ret = '__iter__' in dir(my_list_iter)
print(ret)
ret = '__next__' in dir(my_list_iter)
print(ret)

ret = '__iter__' in dir(my_list)
print(ret)
ret = '__next__' in dir(my_list)
print(ret)

运行结果：
True
True
True
False

10，range ,文件句柄都是可迭代的，range可以切片的

print(range(1000)) # 这是一个可迭代对象，我给是给他要了1000个数，系统答应了，但是没有给，文件句柄也是，你打开文件时，并没有真正打文件加载到内存而是后面read的时候才去加载
print(list(range(1000))) # 这样取的话，会占用大量内存，会取出所有的数放到内存里面


# range是可以切片的

print(range(1000)[1:100])
print(list(range(1000)[1:100]))# 同样占用内存

11，迭代器循环结束会报错，因为取不到下一个值了，这个错误其实可以自己去处理的

my_list =[1,2,3,4]
my_list_iter =my_list.__iter__()  # 一个列表执行了__iter__方法返回值就是一个迭代器
while True:
    print(my_list_iter.__next__())

运行结果：
1
Traceback (most recent call last):
2
  File "/Users/guolixiao/PycharmProjects/lisa's_practise/boys/13.3.py", line 22, in <module>
3
    print(my_list_iter.__next__())
4
StopIteration

12，如果我想写一个函数，一个一个的给我数据，而不是一次全给我，怎么办？生成器，自己写一个迭代器，其实就是生成器

我不能一直用next去调用，强制转换，会全部加载到内存，不想生产数据了，我想生产字符串，生成器函数

13，不想把所有数据一次性加载到内存，还要处处使用它，所以才有了生成器函数，因为普通的迭代器已经不能满足我们要求了，我们要自己来写

生成器有两种形式：生成器函数，本质就是我们自己写的函数，另外一个是生成器表达式

def func():
    for i in range(2000000):
        i = 'lisa%s'%i
        return i  # 这样并不能解决我的问题，因为return只可以return一次
#写到函数里面是因为我要多次使用这个函数

14，其实__iter__和__next__的字眼，我们在实际编程的时候是不会出现的，但是我们要知道原理，知道我们调用for循环的时候，内部就是这么走的，而且前面这么多也是为了后面生成器做铺垫

15，既然return不可以，那怎么？yield，生成器本质还是迭代器，就是自己写的迭代器，把普通函数的return改成yeild 就变成了生成器函数

两者共同点就是都只能在函数内部用，而且不能共用

def generator():
    print(1)
    yield 'a'
    
ret = generator()  # 返回值就是一个生成器
print(ret)

运行结果：
<generator object generator at 0x103845480>

16，我们会发现返回的生成器里面是有__iter__和__next__方法的，他就是一个迭代器

17，我们调用生成器的时候，并不会执行里面的代码，知道我们要用生成器里面的数据的时候才会去运行里面的代码

def generator(): # 第一步定义一个函数
    print(1)  #第五步执行生成器里面的代码
    yield 'a' # 第六步

ret = generator()  # 第二步调用函数返回给ret
print(ret)  #第三步打印
print(ret.__next__()) # 第四步调用生成器里面的数值

18，多个yield，调用一次next走到一个yield，知道没有了，会抛出错误，内部函数执行会受到外部的控制

def generator():
    print(1)
    yield 'a'
    print(2)
    yield 'b'

ret = generator()
print(ret)
print(ret.__next__()) 

运行结果：
<generator object generator at 0x105895480>
1
a

19，如何才能不抛出错误，不能用next调用，需要用for 来调用

def generator():
    yield 'a'
    yield 'b'
    yield 'c'
    yield 'd'

ret = generator()
print(ret)
for i in ret:
    print(i)

运行结果：
<generator object generator at 0x105fb2480>
a
b
c
d

20，200万个Lisa字符串

def generator():  #定义生成器函数
    for i in range(200000):
        yield "lisa%s"%i

gene_lisa = generator()

for i in gene_lisa:
    print(i)

# 运行速度非常快，因为是要一个，给一个的，不占用内存

21，而且我们可以再取出字符串以后自己在做一些操作，比方说只要前50个，或者每个串前面加三个星号，等等

22，两个生成器是单独的，不要混了

def generator():  #定义生成器函数
    for i in range(200000):
        yield "lisa%s"%i

gene_lisa1 = generator()
gene_lisa2 = generator()

print(gene_lisa1.__next__())
print(gene_lisa2.__next__())

运行结果：
lisa0
lisa0

23，每次for循环都是一个新的迭代器

li = [1,2,3,4]
# 列表不是一个迭代器，只是一个可迭代的，所以每次执行for循环的时候，会转化为一个迭代器，每次
# 转化出来的都是新的

for i in li:
    print(i )
    if i == 2:
        break

for i in li:
    print(i)

24，实现一个监听用户输入的功能,代码和老师一模一样，但是不监听，为啥呢？

def tail(filename):
    f1 = open(filename,encoding="utf-8")
        # 下面我不可以用for循环，read或者readlines ，因为这些运行完了都会自动结束
        # 怎么办，我们用while True，这个会一直执行，不会结束，只不过后面打印的都是空而已
    while True:
        line = f1.readline()
        if line.strip():  #非空再打印，这样后面就不会覆盖掉了
            yield line.strip()  # 我想要处理一下这个数据了，那么我必须把这个数据返回回去，但是return只能返回一个，所以必须要yield

g = tail("file.txt")

for i in g:
    print(i)

25，验证可迭代协议，和迭代器协议

from collections import Iterator   # 迭代器，import就是别人写好了的
from collections import Iterable   # 可迭代的

print(isinstance([],Iterable))
print(isinstance([],Iterator))

print(isinstance([].__iter__(),Iterable))
print(isinstance([].__iter__(),Iterator))

运行结果：
True
False
True
True

26，只有next啥也不是

# 自己定义一个数据类型
class A:
    def __iter__(self):pass
    def __next__(self):pass

# 实例化一个对象
a = A()
print(isinstance(a,Iterable))
print(isinstance(a,Iterator))

运行结果：
True
True

27，

li = [1,2,3,4]

for i in li:
    print(i)

for i in li.__iter__():
    print(i)

for i in li.__iter__().__iter__(): # 这个其实就没有意义了，前面已经是可迭代的了
    print(li)

运行结果：
1
2
3
4
1
2
3
4
[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4]

28，可迭代的.__iter__方法就可以得到一个迭代器，猜测是一个可迭代的，类似range这种，告诉你有10个数，实际上没给你，就可以用for来拿

直接告诉你是一个可迭代器，直接告诉你内存地址的