9.24 总结

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')

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}')

转载于:https://www.cnblogs.com/lidandanaa/p/11580769.html