# 我们以前学习的while按照如下执行，会一直执行下去；

# 但是，while只是一个开关作用，while在这里并没有体现出迭代的精髓"每一次迭代得到的结果会作为下一次迭代的初始值"

while True:

    print('Hello World!')

# 下面我们遍历列表，其中每一次的n都是基于上一次的n，依次遍历

# 这里就体现了迭代的精髓“每一次的迭代的结果编程下一次迭代的初始值”

l = ['a', 'b', 'c']

n = 0

while n < len(l):

    print(l(n))

    n += 1

# 以下都是可迭代对象(字符串，列表，元组，字典，集合，文件)

str = 'hello'

list1 = [1, 2, 3]

tup1 = (4,5,6)

dic = {'x': 1}

s1 = {'a', 'b', 'c'}

f = open('a.txt', 'w', encoding='utf-8')

# 需要注意文件由于本身过大的特性，必须被定义为可迭代对象，不然很容易内存溢出

# 集合

s1 = {'a', 'b', 'c'}

# 可迭代对象s1集合，执行内置的._iter_()方法，获得迭代器对象，然后就可以逐一取出来

iter_s1 = s1._iter_()

print(iter_s1._next_())

print(iter_s1._next_())

print(iter_s1._next_())

# 字典

dic1 = {'x':1, 'y':2, 'z':3}

# 可迭代对象dic1字典，执行内置的._iter_()方法，获得迭代器对象，然后就可以逐一取出来

iter_dic1 = dic1._iter_()

print(iter_dic1._next_())

print(iter_dic1._next_())

print(iter_dic1._next_())

# 列表

L1 = [2,3,4,]

# 可迭代对象L1列表，执行内置的._iter_()方法，获得迭代器对象，然后可以逐一取出来

iter_L1 = L1._iter_()

print(iter_L1._next_())

print(iter_L1._next_())

print(iter_L1._next_())

# 字符串

str1 = 'hello'

#  可迭代对象str1字符串，执行内置的._iter_()方法，获得迭代器对象，然后逐一取出

iter_str1 = iter_str1._iter_()

print(iter_str1._next_())

print(iter_str1._next_())

print(iter_str1._next_())

print(iter_str1._next_())

print(iter_str1._next_())

# 我们在遍历字符串的时候，发现会报错，那就引入抛出异常机制

# 文件

f1 = open('a.txt', 'r', encoding = 'utf-8')

# 可迭代对象f1文件，执行内置的._iter_()方法，获取迭代器对象，然后逐一取出

iter_f1 = f1._iter_()

while True:

    try:

        print(iter_f1._next_())

    except StopIteration:

        break

# 迭代文件的时候，你会发现打印出来，有空行，因为在文件中换行是由‘\n’代表的

#基于for循环，我们可以完全不再依赖索引去取值了

dic={'a':1,'b':2,'c':3}

for k in dic:

    print(dic[k])

# for循环的工作原理

#1：执行in后对象的dic.__iter__()方法，得到一个迭代器对象iter_dic

#2: 执行next(iter_dic),将得到的值赋值给k,然后执行循环体代码

#3: 重复过程2，直到捕捉到异常StopIteration,结束循环

# 下图中，iter_l的内存信息，你会看到内存中标记的是ist_iterator对象

# 补充说明， 文件有时候本身较大，一次全部加载到内存，费事费力，所以要被定义为一个迭代器对象，每次取一点，节省内存，提升效率

# 注意下图中，内存的标记为生成器generator

# 生成器的本质就是迭代器，下面res._iter_() 就是 res本身

def  start():

    print('Starting.......')

    while True:

        x = yield       #此处是yield的表达式形式

        print(x)

f = start()

next(f)         #next(g) == g.send(None)

'''

send的效果：

1. 将携带的值传给yield，不是x，然后yield在复制给x

2. send()方法具有和next()方法一样的功能，能在传值的基础上继续执行，直到再次碰到

    yield结束

'''

g.send(2)     

def  start():

    print('Starting.......')

    while True:

        x = yield       #此处是yield的表达式形式

        print(x)

start()

start() # 到这里就不会运行print('Starting.......')，因为再次调用函数，解释器在检测语法

              的时候，检测到有yield，那么在执行该函数的时候就不会运行

# 结合上面，下面实例是可变长度参数的应用实例

def foo(func):

    def foo1(*args, **kwargs):

        g = func(*args, **kwargs)

        next(g)

        return g

    return foo1

@foo

def eater(name):

    print('%s starts to ear' % name)

    foo_list = []

    while True:

        food = yield food_list

        food_list.append(food)

        print('%s starts to eat %s' % (name, food))

        print(food_list)

m = eater('Alex')

m.send('Bread')
        

#  结合上面理论，理解以下yield表达式的范例