迭代器
可迭代对象：具有__iter__方法的都可叫做可迭代对象
基本数据类型中，是可迭代对象的有str、list、tuple、dict、set、文件对象f(执行内置的__iter__之后还是本身，没有任何变化)：文件对象本身就是迭代器对象。
n = 1
f = 1.1
s = 'hello'
l = [1,2,45]
t= (1,3,56)
d = {'name':'jaosn'}
s1 = {1,3,4,5}
f1 = open('xxx.txt','w',encoding='utf-8')
res = s.__iter__()
print(s.__len__()) # 5
res1 = l.__iter__()
res2 = f1.__iter__()
print(res1,res1,res2)
print(f1) # 文件本身就是迭代器对象
<list_iterator object at 0x03B87D30> <list_iterator object at 0x03B87D30> <_io.TextIOWrapper name='xxx.txt' mode='w' encoding='utf-8'>
<_io.TextIOWrapper name='xxx.txt' mode='w' encoding='utf-8'>
f1 = open('xxx.txt','r',encoding='utf-8')
iter_f = f1.__iter__()
print(iter_f is f1) # True
什么是迭代器：
迭代：更新换代（重复的过程），每次的迭代都必须基于上一次的结果
迭代器：迭代取值的工具
为什么要用：
迭代器给你提供了一种不依赖于索引取值的方式。
可迭代对象执行内置的__iter__方法得到的就是该对象的迭代器对象。
迭代器对象：
1、内置有__iter__方法和__next__方法的可迭代对象
ps：迭代器对象一定是可迭代对象，可迭代对象不一定是迭代器对象。
迭代器对象取值必须使用__next__方法。
l = [1,2,3,4]
iter_l = l.__iter__()
print(iter_l.__next__())
print(iter_l.__next__())
print(iter_l.__next__())
print(iter_l.__next__())
print(iter_l.__next__()) # 如果取完了，会直接报错
迭代器对象无论执行多少次__iter__方法得到的还是迭代器对象本身。
print(f1 is f1.__iter__().__iter__().__iter__().__iter__()) # True
问题：
__iter__方法就是用来帮我们生成迭代器对象。而文件对象本本身就是迭代器对象，为什么还内置有__iter__方法？？？
因为利用for循环取值的时候，会自动使用__iter__方法将可迭代对象转化为迭代器对象，进而取值。而如果将文件内置的__iter__方法取消了，就不能利用for循环取出列表的每一行内容。
迭代器取值的特点：
1、只能往后依次取，不能后退。取完之后，会直接报错。
# 异常处理
d = {'name':'jsson','password':'123','hobby':'泡面'}
iter_d = d.__iter__()
while True：
try：
print(iter_d.__next__())
except StopIteration:
# print('取完了')
break
for 循环取值的本质
for循环里面的in关键字后面跟的是一个可迭代对象。
for循环内部的本质：
1.将in后面的对象调用__iter__方法转化成迭代器对象
2.调用__iter__迭代取值
3.内部有异常捕获StopIteration,当__next__报这个错，循环自动结束
可迭代对象：内置有__iter__方法的对象
迭代器对象：既内置有__iter__方法也有__next__方法的对象。
迭代取值的优点：
1.不依赖于索引取值，
2.内存中永远只占一份空间，不会导致内存溢出。
缺点：
1.不能够获取指定的元素
2.取完之后会报StopIteration错
生成器
生成器：用户自定义的迭代器，本质就是迭代器，里面含有yield关键字。
函数内如果有yield关键字，那么加括号执行函数的时候并不会触发函数体代码的运行。
def func():
print('first')
yield 666
print('second')
yield 777
print('third')
yield 888
print('forth')
yield
yield
g = func() # 生成器初始化：将函数变成迭代器
print(g) # <generator object func at 0x00857D30>
print(g.__next__()) # 666
print(g.__next__()) # 777
print(g.__next__()) # 888
print(g.__next__()) # None
print(g.__next__()) # None
yield后面跟的值就是调用迭代器__next__方法你能得到的值
yield既可以返回一个值也可以返回多个值，并且多个值也是按照元组的形式返回
for i in range(1,10):
print(i)
# 使用生成器生成range(1,10)
def my_range(start,end,step=1):
while start < end:
yield start
start += step
for i in my_range(1,10,2):
print(i)
yield关键字
yield的英文单词意思是生产，在函数中但凡出现yield关键字，再调用函数，就不会继续执行函数体代码，而是会返回一个值。yield支持外界为其传参
def dog(name):
print(f'{name}准备开吃了')
while True:
food = yield
print(f'{name}吃了{food}')
g = dog('wangcai')
g.__next__() # wangcai准备开吃了 必须先将代码运行至yield，才能为其传值。
g.send('狗不理包子') # wangcai吃了狗不理包子 # 给yield左边的变量传值，自动触发__next方法
g.send('饺子') # wangcai吃了饺子
当函数内有yield关键字的时候，调用该函数不会执行函数体代码,而是将函数变成了生成器。
yield的特点：
1.帮你提供了一种自定义生成器方式
2.会帮你将函数的运行状态暂停住
3.可以返回值
与return之间的异同点：
相同点：都可以返回值，并且都可以返回多个。
不同点：yield可以返回多次值，而return只能返回一次函数立即结束。
yield还可以接收外部传入的值。
生成器
res = (i for i in range(1,10) if i != 4)
print(res)
res = (i for i in range(1,10) if i != 4)
print(res)
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
生成器不会主动执行任何一行代码。必须通过__next__触发代码的运行
def add(n,i):
return n+i
def test():
for i in range(4):
yield i
g=test()
for n in [1,10]:
g=(add(n,i) for i in g)
# 第一次for循环g=(add(n,i) for i in test())
# 第二次for循环g=(add(n,i) for i in (add(n,i) for i in test()))
print(n)
res=list(g)
"""
for i in (add(10,i) for i in test()): 会执行所有的生成器内部的代码
add(n,i)
"""
res=[20,21,22,23]
面试题一
def demo():
for i in range(4):
yield i
g = demo()
g1 = (i for i in g)
g2 = (i for i in g1)
print(list(g1)) # [0,1,2,3]
print(list(g2)) # []
# g是第一个生成器，g1取得值来自g，g2的值来自于g1，归根到底还是g，list是可迭代对象，将g1赋予list方法，其实是从g中取值，而且取完了，g2自然就是空值了。
def demo():
for i in range(4):
yield i
g = demo()
g1 = (i for i in g)
g2 = (i for i in g1)
print(next(g)) # 0
print(next(g1)) # 1
print(next(g2)) # 2
面试题二
def add(n,i):
return n+i
def text():
for i in range(4):
yield i
g = text()
for n in [1,10]:
g = (add(n,i) for i in g)
print(list(g))
# 其结果为[20,21,22,23]
# 如果将for循环下面的表达式换成g = [add(n,i) for i in g] 结果为[11,12,13,14]
# 如果将for循环的表达式换成for n in [1,2,10],或者for n in [1,11,10]，其结果为[30,31,32,33]
# 如果是for n in [1,3,6,7,10,11,100,10],其结果为[80,81,82,83]
面试二总结：生成器的特点是惰性机制，也就是说你找它要，它才会给你值
在上一题的for循环中，不管你循环了多少次，生成器的取值都是[]中的最后一个值
g在取值之前，是一个内存地址，for循环一直改变着g的内存地址，最后是n=10的内存地址
for循环一次，g中的值就加一次，每次加的都是n=10的内存地址的值
for循环第一次：10+0 10+1 10+2 10+3
for循环第二次：10+10+0 10+10+1 10+10+2 10+10+3
如果有第三次：10*3+0 10*3+1 10*3+2 10*3+3
.........
常用内置方法
abs（）绝对值
print(abs(-13.5)) # 13.5
all（）,any（）
l = [0,1,2]
print(all(l)) # 只要有一个为False就返回False
print(any(l)) # 只要有一个为True就返回True
bin()/oct()/hex() 二进制/八进制/16进制
print(bin(17))
print(oct(17))
print(hex(17))
0b10001
0o21
0x11
bool（）布尔值
print(bool(1)) # True
print(bool(0)) # False
bytes（）字节二进制
s = 'hello'
print(s.encode('utf-8'))
print(bytes(s,encoding='utf-8'))
callable（)可调用的（可以加括号执行相应功能的）
l = [1,2,3]
def index():
pss
print(callable(l)) # False
print(callable(index)) # True
chr（）,ord（）
print(chr(97)) # 将数字转换成asill码表对应的字符 'a'
print(ord('a')) # 将字符按照ascii码表转成对应的数字 97
dir（）获取当前对象名称空间里面的名字
l = [1,2,4]
print(dir(l))
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
divmod（）分页器
print(divmod(101,10)) # （10,1）
total_num,more = divmod(900,11)
if more:
total_num += 1
print('总页数：',total_num) # 总页数： 82
enumerate（） 枚举
l = ['a','b']
for i,j in enumerate(l,1): # 带有所以索引的迭代
print(i,j)
1 a
2 b
eval（）,exec（）
s = """
print('hello baby~')
x = 1
y = 2
print(x+y)
"""
print(eval(s)) # eval不支持逻辑代码,支持支一些简单的python代码
s = """
print('hello baby~')
x = 1
y = 2
print(x+y)
"""
exec(s) # 支持逻辑代码
hello baby~
3
isinstance（）
# isinstance 判断对象是否属于某个数据类型
n = 1
print(type(n))
print(isinstance(n,list)) # 判断对象是否属于某个数据类型
pow（）,计算第一个数的几次方
print(pow(2,3)) # 8
round（）四舍五入
print(round(3,4)) # 3
global()/locals()
def index():
username = '我是局部名称空间里面的username'
print(locals()) # 当前语句在哪个位置，就会返回哪个位置所存储的所有的名字
print(globals) # 无论在哪，查看的都是全局名称空间
面向过程编程
面向过程编程：就类似于设计一条流水线
优点：复杂的问题流程化进而简单化
缺点：扩展性差，一旦需要修改，整体都会受到应影响。
面试题3
请写出一下代码的执行结果并解释。
def multipliers():
return [lambda x:i*x for i in range(4)]
print([m(2) for in multipliers()])
# 解析：
# [lambda x：i*x for i in range(4)]
[func(x):return 0*x,func(x):return 1*x,func(x):return 2*x,func(x):return 3*x]
# 闭包函数的延迟绑定，在内层函数执行时才会绑定变量
def multipliers2():
list1 = []
for i in range(4): # 0,1,2,3
def func(x):
return x * i
list1.append(func)
return list1
print([m(2) for m in multipliers2()])
m = lambda x:i*x
m = lambda x:i*x
m = lambda x:i*x
# 每次都执行一次m(2),也就是每次都调用了一下匿名函数，注意：此时此刻 匿名函数才真正被调用了，它会引用外层空间的变量i，那么此时i的值是多少呢？
# 因为for i in range(3)这个循环已经执行完毕，i的值等于3，所以每次当执行m(2)时，i的值都等于3。所以每次调用m(2)的结果都是6.
[6,6,6,6]
改进
def multipliers():
return [lambda x, i=i: i*x for i in range(4)]
# return [lambda x,i=0: i*x, lambda x,i=1: i*x, lambda x,i=2: i*x, lambda x,i=3:i*x i=3]
# x的引用是2 所以output的结果就是：[0,2,4,6]
print([m(2) for m in multipliers()])
def multipliers2():
list1 = []
for i in range(4):
def func(x, i=i):
return x * i
list1.append(func)
return list1
print([m(2) for m in multipliers2()]) # [0, 2, 4, 6]
添加了一个i = i后，就给匿名函数，添加了一个默认参数，而python函数中的默认参数，是在python解释器遇到def(i=i)或lambda关键字时，就必须初始化默认参数。
此时for i in range(4),每循环一次，匿名函数的默认参数i，就需要找一次i的引用。i=0时，第一个匿名函数的默认参数值就是0,i=1时，第二个匿名函数的默认参数值就是1，以此类推。
需求：读取一个文件并返回每行数据的长度
with open('text.txt','w',encoding='utf-8') as f:
for line in range(1000):
f.write(f'www{line}aaa'*(line + 1) + '
')
# 列表推导式：处理数据量大的文件会导致内存溢出。
res = [len(line) for line in open('text.txt','r',encoding='utf-8')]
# print(res)
# 生成器表达式：处理数据量大的文件推荐使用
res2 = (len(line) for line in open('text.txt','r',encoding='utf-8'))
print(res2) # <generator object <genexpr> at 0x000002B3748FD0A0>
print(next(res2))
print(next(res2))