迭代器

迭代器即迭代的工具，迭代是一个重复的过程，每次重复即是一次迭代，并且每次迭代的结果都是下一次迭代的初始值

可迭代对象

只要拥有__iter__()方法的对象就是可迭代对象，如下：

print('name'.__iter__())
print(['read', 'run',[1,2,3,4]].__iter__())
print(('name',18,('age',14,'weight')).__iter__())
print({'name': 'nick', 'age': 18}.__iter__())
print({1,2,3,4,5}.__iter__())
print(open('a.txt').__iter__())
print(18.__iter__())      #  提示nvalid syntax
def f1():
    pass
print(f1.__iter())        # 报错提示函数没有iter方法“AttributeError: 'function' object has no attribute '__iter'”

<str_iterator object at 0x0000011DA1C6AF28>
<list_iterator object at 0x0000011DA1C6AF98>
<tuple_iterator object at 0x0000011DA1C0FB00>
<dict_keyiterator object at 0x0000011DA1A706D8>
<set_iterator object at 0x0000011DA1C68630>
<_io.TextIOWrapper name='a.txt' mode='r' encoding='cp936'>

可见：字符串/列表/元组/字典/集合/文件都是可迭代对象

迭代器对象

拥有__iter__()和__next__方法的才是迭代器对象。其中，__next__其实是在遍历可迭代对象的元素,一旦遍历完报错，如

lis_iter = [1,2,3].__iter__()
print(lis_iter.__next__())        # 遍历列表中的第一个元素 1
print(lis_iter.__next__())        # 遍历列表中的第一个元素 2
print(lis_iter.__next__())        # 遍历列表中的第一个元素 3
print(lis_iter.__next__())        # 遍历完后报错

1
2
3

---------------------------------------------------------------------------

StopIteration                             Traceback (most recent call last)

<ipython-input-23-2aa8b474bc11> in <module>
      3 print(lis_iter.__next__())        # 遍历列表中的第一个元素 2
      4 print(lis_iter.__next__())        # 遍历列表中的第一个元素 3
----> 5 print(lis_iter.__next__())

StopIteration:

print([1,2,3].__iter__().__iter__())        # 迭代器对象使用__iter__方法后是迭代器对象本身

<list_iterator object at 0x0000011DA1C6A080>

print(open('a.txt').__next__())
print(open('a.txt').__iter__())
# 文件即是可迭代对象也是迭代器对象

Hello world
<_io.TextIOWrapper name='a.txt' mode='r' encoding='cp936'>

优点：节省内存空间

缺点：取值麻烦，只能一个一个取，并且只能往后去，值取了就没了；无法使用len()方法获取长度

注意：迭代器对象一定是可迭代对象，但是可迭代对象不一定是迭代器对象

for循环原理

只有字符串、列表和元组依赖索引取值色，而其他可迭代对象都是无法依赖索引取值的，有了迭代器，我们就可以不依赖索引迭代取值了

lis = ['run','read']
lis_iter = lis.__iter__()
while True:
    try:
        print(lis_iter.__next__())
    except:
        break

run
read

# 基于for循环，我们可以完全不再依赖索引取值
lis = ['run','read']
for i in lis:
    print(i,end=',')

run,read,

for循环的工作原理

执行in后对象的lis.__iter__()方法，得到一个迭代器对象lis_iter
执行lis_iter.__next__()，将得到的值赋给i，然后执行循环体代码
重复过程2，直到捕捉到异常结束循环

三元表达式(三目表达式)

# 示例：返回x和y的最大值
x = 20
y = 10
if x > y:
    print(x)
else:
    print(y)

    
# 用三元表达式写
x, y = 20, 10
max = x if x > y else y        
print(max)

列表推导式

# 示例：求0-9数的平方
lis = []
for i in range(10):
    lis.append(i*2)
print(lis)


# 用列表推导式写
lis = [i*2 for i in range(10)]
print(lis)

字典生成式

dic = {i:i**2 for i in range(5)}
print(dic)

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

zip()方法

# 拉链函数
res = zip('abcd',[1,2,3,4])
print(res)
dic = dict()
for k,v in res:
    dic[k] = v
print(dic)

<zip object at 0x0000011DA1C6E788>
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组

print({k:v for k,v in zip('abcd',[1,2,3,4])})

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

生成器

只要函数内部包含有yield关键字，那么函数名()得到的结果就是生成器，接收值但是不会执行函数内部的代码

def func():
    yield 
    print('from 1')
    yield 2
    print('from 2')
    yield 'a',[1,2,3]
g = func()
print(g)
print(g.__next__())
print(g.__next__())
print(g.__next__())

<generator object func at 0x0000011DA1C1F6D0>
None
from 1
2
from 2
('a', [1, 2, 3])

生成器本质上就是自定义的迭代器，因此可以通过.__next__()方法接收yield返回的值。

yield可以暂停住函数，并且提供当前的返回值

yield默认返回None；有一个返回值时返回一个值；有多个返回值时，以元组的形式接收返回值。但是yield不会结束函数，然后继续下一行代码,直到return。

生成器表达式

tup = (i for i in range(10))
print(tup)
for i in tup:
    print(i,end=',')

<generator object <genexpr> at 0x0000011DA1C1F728>
0,1,2,3,4,5,6,7,8,9,

递归

函数递归：它是一种特殊的函数嵌套，但是它在调用中又直接或间接地调用了它自身

def f():
    print('from f')
    f()
f()        # 进入了死循环

如果递归函数不断地调用函数自身，那么这个递归函数就会进入一个死循环，所以必须给递归函数一个明确的结束条件

递归的两个阶段

递推：一层一层递归调用下去，进入下一层递归的问题规模都将会减小
回溯：递归必须要有一个明确的结束条件，在满足该条件开始一层一层回溯

递归的精髓在于通过不断地重复逼近一个最终的结果

def guess_age(age,count):
    age -= 2
    count -= 1
    if count == 1:
        print(age)
        return
    guess_age(age,count)

guess_age(38,5)

day13-迭代器、三元表达式、列表推导式、字典生成式、生成器与递归

迭代器