1.迭代器：
不是函数，只是一个称呼，Python中一切皆对象，可迭代对象：含有.__iter__方法的数据类型叫做可迭代对象
x=10 #不是可迭代对象
s='abc'
s.__iter__()
lt=[1,2,3]
lt.__iter__()
tup=(1,)
tup.__iter__()
dic={'a':1}
dic.__iter__()
fa=open('test.txt','a+',encoding='utf8')
fa.seek(0,0)
fa.__iter__()
除了数字类型，所有数据类型都是可迭代对象
s='abc'
s_iter=s.__iter__()
print(s_iter.__next__()) #s[0]
print(s_iter.__next__()) #s[1]
print(s_iter.__next__()) #s[2]
dic = {'a': 1, 'b': 2, 'c': 3}
dic_iter=dic.__iter__()
print(dic_iter.__next__()) # 迭代取值 --》 基于上一个值
print(dic_iter.__next__())
print(dic_iter.__next__()) #c
2.迭代器对象：
含有.__iter__和.__next__方法的对象，可迭代对象使用.__iter__变成迭代器，迭代器使用.__iter__依然是迭代器
为什么要有迭代器对象，提供了不依赖索引取值的手段
迭代取值是基于上一个值取值。
for循环称为迭代器循环，in后必须是可迭代的对象，for循环是一个可控的while循环
dic={'a':1,'b':2,'c':3}
dic_iter=dic.__iter__()
while True:
try:
print(dic_iter.__next__())
except StopIteration:
break
#下面的等同于上面的代码
for i in dic: # for循环 --> 迭代循环
print(i)
**迭代器特点： **
a.内置.__next__方法，执行该方法会拿到迭代器对象里的一个值
b.内置有.__iter__方法会拿到迭代器本身
c.文件本身就是迭代器对象
3.三元表达式
比较x,y大小：
x=10
y=20
print(x) if x>y else print(y) #20
4.列表推导式
lt=[i**2 for i in range(10)]
print(lt) #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
5.字典推导式
dic={i:i**2 for i in range(10)}
print(dic) #{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
zip()方法：
keys=['name','age','gender']
values=['nick',19,'male']
res=zip(keys,values)
print(f'res:{res})
info_dict={k:v for k,v in res}
print(f'info_dict:{info_dict}')
运行结果：
res:<zip object at 0x0000000005B11088>
info_dict:{'name': 'nick', 'age': 19, 'gender': 'male'}
通过解压缩函数生成一个字典：
info_dict = {'name': 'nick', 'age': 19, 'gender': 'male'}
print(f'info_dict.keys():{info_dict.keys()}')
print(f'info_dict.values():{info_dict.values()}')
res=zip(info_dict.keys(),info_dict.values())
print(f'zip(keys,values),{res}')
info_dict={k:v for k,v in res}
print(f'info_dict:{info_dict}')
运行结果：
zip(keys,values),<zip object at 0x0000000005B11088>
info_dict:{'name': 'nick', 'age': 19, 'gender': 'male'}
lt1=[1,2,3]
lt2=[4,2,3,4]
s='nahsibsnnc'
# zip()
res = zip(lt1,lt2,s) # res是一个迭代器,__next__返回元组
print(res.__next__()) # type:tuple
print(res.__next__()) # type:tuple
print(res.__next__()) # type:tuple
运行结果：
(1, 4, 'n')
(2, 2, 'a')
(3, 3, 'h')
字典生成式：
print({i: i**2 for i in range(10)})
运行结果：
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
keys = ['name', 'age', 'gender']
values = ['nick', 19, 'male']
res = zip(keys, values)
print(F"zip(keys,values): {zip(keys,values)}")
info_dict = {k: v for k, v in res}
print(f"info_dict: {info_dict}")
运行结果：
zip(keys,values): <zip object at 0x11074c088>
info_dict: {'name': 'nick', 'age': 19, 'sex': 'male'}
通过解压缩函数生成一个字典：
info_dict = {'name': 'nick', 'age': 19, 'gender': 'male'}
print(f"info_dict.keys(): {info_dict.keys()}")
print(f"info_dict.values(): {info_dict.values()}")
res = zip(info_dict.keys(), info_dict.values())
print(F"zip(keys,values): {zip(info_dict.keys(),info_dict.values())}")
info_dict = {k: v for k, v in res}
print(f"info_dict: {info_dict}")
运行结果：
info_dict.keys(): dict_keys(['name', 'age', 'gender'])
info_dict.values(): dict_values(['nick', 19, 'male'])
zip(keys,values): <zip object at 0x1105cefc8>
info_dict: {'name': 'nick', 'age': 19, 'gender': 'male'}
6.生成器
含有yield 关键字的函数就叫生成器
生成器的本质是迭代器，是一个自定义的迭代器
def ge():
yield 3 #一个yield 相当于一个next，有暂停函数的作用
print('llll')
yield 4
g=ge()
print(g.__next__())
print(g.__next__())
#用for循环代替
for i in g:
print(i)
运行结果：
3
llll
4
return的特性：
终止函数，通过调用函数拿到值
def f1():
yield 1
yield 2
yield from range(3)
for i in f1():
print(i)
运行结果：
1
2
0
1
2
生成器表达式：把列表的[]换成() 优点：省内存，一次只产生一个值在内存中
t=(i for i in range(10))
print(t)
print(f'next(t):{next(t)}')
运行结果：
<generator object <genexpr> at 0x0000000005AC8150>
next(t):0
7.函数递归：
函数内部直接调用函数本身，每次递归不会自己结束函数，以防死循环需要一个退出循环的条件，递归也要有规律
def age(x):
if x==0:
return 18
x-=1
return age(x)+2
res=age(6)
print(res) #30
解压缩格式：
name_list = ['nick', 'egon', 'jason', ]
x, y, z = name_list
print(f'x:{x}, y:{y}, z:{z}')
