#什么是迭代协议
#迭代器是什么？ 迭代器是访问集合内元素的一种方式， 一般用来遍历数据
#迭代器和以下标的访问方式不一样， 迭代器是不能返回的, 迭代器提供了一种惰性方式数据的方式
#[] list , __iter__from collections.abc import Iterable, Iterator
a = [1,2]
iter_rator = iter(a)
print (isinstance(a, Iterable))
print (isinstance(a, Iterator))
print (isinstance(iter_rator, Iterator))---
True
False
True

from collections.abc import Iterator
class Company(object):def __init__(self, employee_list):self.employee = employee_listdef __iter__(self):                    # 可迭代对象，实现了__iter__return MyIterator(self.employee)   # iter(可迭代对象) 方法 会调用反回迭代器# def __getitem__(self, item):        # 当没有定义__iter__协议for循环就会将定义的getitem变成迭代器#     return self.employee[item]      # 退化为迭代器# 可迭代对象不要去实现__next__class MyIterator(Iterator):             # 迭代器 实现了__next__def __init__(self, employee_list):self.iter_list = employee_listself.index = 0def __next__(self):#真正返回迭代值的逻辑               #实现原理try:word = self.iter_list[self.index]except IndexError:raise StopIterationself.index += 1return wordif __name__ == "__main__":company = Company(["tom", "bob", "jane"])my_itor = iter(company)for item in company:print (item)# ---
tom
bob
jane

#生成器函数，函数里只要有yield关键字
def gen_func():yield 1yield 2yield 3def func():return 1if __name__ == "__main__":#生成器对象， python编译字节码的时候就产生了，gen = gen_func()  # <generator object gen_func at 0x000001CD083334F8>print(gen)for value in gen:print (value)# ---
<generator object gen_func at 0x000001CD08333570>
1
2
3
# ---

# 斐波拉契 0 1 1 2 3 5 8
# 惰性求值， 延迟求值提供了可能def fib(index):     # 第几个数if index <= 2:return 1else:return fib(index-1) + fib(index-2)def fib2(index):    # 打印前几个数re_list = []n,a,b = 0,0,1while n<index:re_list.append(b)a,b = b, a+bn += 1return re_list
print(fib(10))
print(fib2(10))
# ---
55
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
# ---def gen_fib(index):n,a,b = 0,0,1while n<index:yield ba,b = b, a+bn += 1for data in gen_fib(10):print (data)# ---
1
1
2
3
5
8
13
21
34
55

#1.python中函数的工作原理def foo():bar()
def bar():pass#python.exe会用一个叫做 PyEval_EvalFramEx(c函数)去执行foo函数， 首先会创建一个栈帧(stack frame)
"""
python一切皆对象，栈帧对象， 字节码对象
当foo调用子函数 bar， 又会创建一个栈帧
所有的栈帧都是分配在堆内存上，这就决定了栈帧可以独立于调用者存在
"""
import dis
print(dis.dis(foo))
#---5           0 LOAD_GLOBAL              0 (bar)2 CALL_FUNCTION            04 POP_TOP6 LOAD_CONST               0 (None)8 RETURN_VALUE
None
#--- import inspect
frame = None
def foo():bar()
def bar():global frameframe = inspect.currentframe()foo()
print(frame.f_code.co_name)   #栈针
caller_frame = frame.f_back   # 调用他的栈针
print(caller_frame.f_code.co_name)# ---
bar
foo

def gen_func():yield 1name = "lewen"yield 2age = 30return "imooc"import dis
gen = gen_func()
print (dis.dis(gen))# ---2           0 LOAD_CONST               1 (1)2 YIELD_VALUE4 POP_TOP3           6 LOAD_CONST               2 ('lewen')8 STORE_FAST               0 (name)4          10 LOAD_CONST               3 (2)12 YIELD_VALUE14 POP_TOP5          16 LOAD_CONST               4 (30)18 STORE_FAST               1 (age)6          20 LOAD_CONST               5 ('imooc')22 RETURN_VALUE
None
# ---print(gen.gi_frame.f_lasti)
print(gen.gi_frame.f_locals)
next(gen)
print(gen.gi_frame.f_lasti)
print(gen.gi_frame.f_locals)
next(gen)
print(gen.gi_frame.f_lasti)
print(gen.gi_frame.f_locals)# ---
-1
{}
2
{}
12
{'name': 'lewen'}

# 500G, 特殊 全部在 一行，由特殊分割符分割

# 一次性读取太大，按分隔符读取
def myreadlines(f, newline):buf = ""  # 缓存while True:while newline in buf:pos = buf.index(newline)yield buf[:pos]                 # 将第一个分隔符之前的数据yield 出去buf = buf[pos + len(newline):]  # 丢弃掉yield的数据，如果buf中还有分隔符就继续处理，chunk = f.read(4096)                 # 没有就继续读新的4096个字节if not chunk:# 说明已经读到了文件结尾yield bufbreakbuf += chunkwith open("input.txt") as f:for line in myreadlines(f, "{|}"):print(line)