迭代器和生成器

1.迭代器

什么是迭代器

　　迭代:更新换代的过程,每次迭代都需要基于上次的结果,是Python最强大的功能之一,是访问集合元素的一种方式

　　迭代器,更新换代取值的工具

　　迭代器从第一个元素开始访问,直到最后一个元素访问完毕,只能往前

为什么使用迭代器

　　迭代器给我们提供了一种不依赖索引取值的方式

每次迭代都是基于上一次的结果而来的

一个简单的迭代器

# 每次迭代都是基于上一次的结果
l =[1,2,3,4]
i = 0
while i < len(l):
    print(l[i])
    i += 1

可迭代的数据类型

　　字符串、列表、元组、字典、集合

2.可迭代对象

内置了__iter__方法的都可以叫做可迭代对象

　　__iter__读做双下iter

基本数据类型中的可迭代对象

　　字符串、列表、元组、字典、集合

# 可以跟__iter__的基本数据类型
s = 'sxc'
l = [1,2,3,4]
t = (1,2,3,4)
d = {'name':'sxc'}
s1 = {1,2,3,4}
s.__iter__()
l.__iter__()
t.__iter__()
d.__iter__()
s1.__iter__()

这些基本数据类型可以加__iter__,并且并未报错

文件类型

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

 

文件类型也是可迭代对象

3.迭代器对象

迭代器对象

　　内置有__iter__方法并且内置有__next__方法的可以叫做迭代器对象

　　所以,迭代器对象一定是可迭代对象,但是可迭代对象,不一定是迭代器对象

　　基本数据类型(可迭代对象)后面跟__iter__之后产生的就是迭代器对象

一个迭代器

s = 'sxc'  # 字符串s是可迭代对象
iter_1 = s.__iter__()  # 后面跟了__iter__变成了迭代器对象
print(iter_1)  # 这就是一个迭代器,相当于老母猪
print(iter_1.__next__())  # 打印之后就能取值,每次只能取一个
print(iter_1.__next__())
print(iter_1.__next__())
# print(iter_1.__next__())  # 打印的值不能超过原本的范围,会报错StopIteration

需要注意的是,一旦超过取值范围就会报错:StopIteration

迭代器对象的__iter__方法

f =open('aaa.txt','r',encoding='utf-8')
print(f)  # 是可迭代对象也是迭代器对象
iter_f = f.__iter__()  # 调用__iter__方法
print(iter_f)  # 打印出来的还是本身
iter_f1 = iter_f.__iter__()
print(iter_f1)  # 还是本身
print(iter_f1.__next__())
print(iter_f1.__next__())
print(iter_f1.__next__())

 

注意:迭代器对象不管调用多少次调用了__iter__方法之后还是本身

一个小问题

问:__iter__方法就是用来帮我们生成迭代器对象而文件对象本身就是迭代器对象,为什么还内置有__iter__方法???

答:因为python中的迭代场景必须使用可迭代对象,而可迭代对象必须有__iter__方法,并且有了__iter__方法之后可以兼容python已有的迭代场景和工具，例如:for循环、列表解析、map、sum、zip等等。

异常处理

 一个迭代取值的过程

l = [1,2,3,4]
iter_l = l.__iter__()
print(iter_l.__next__())  # 运行第一次得到1
print(iter_l.__next__())  # 运行第二次得到2
print(iter_l.__next__())  # 运行第三次得到3
print(iter_l.__next__())  # 运行第四次得到4
print(iter_l.__next__())  # 运行第五次列表内的值已取完,报错StopIteration

我们可以进行异常处理消除掉报错

l = [1,2,3,4]
iter_l = l.__iter__()
while True:  # 循环执行
    try:
        print(iter_l.__next__())
    except StopIteration:  # 如果报错StopIteration,就返回下面这句话,从而消除报错
        print('列表中的值已取完')
        break

注意:迭代取值只能一个个往后取值,不能往前取值

4.for循环的本质

for循环内部的本质:

　　1.将in后面的可迭代对象循环调用__iter__方法转化为迭代器对象

　　2.调用__next__方法迭代循环取值

　　3.当内部异常报错StopIteration时,自动结束循环

其实和上面的异常处理类似,迭代取值,只不过当发现异常之后直接结束,不返回或者打印任何值

l = [1,2,3,4]
for i in l:  # 这两行代码通过内置方法,完成了下面的代码
    print(i)
# iter_l = l.__iter__()
# while True:  # 循环执行
#     try:
#         print(iter_l.__next__())
#     except StopIteration:  # 如果报错StopIteration,就返回下面这句话
#         break

迭代取值的优缺点:
　　优点:1.不依赖索引取值

　　　　 2.每次取值都只占一小份空间,节省空间

　　缺点:1.不能指定取某个值,只能往前,不能往后

　　　　 2.值取完之后会报错StopIteration

一些内置函数也是基于for循环使用迭代器的方法

l1 = [1,2,3,4]
l2= [4,3,2,1]
res = map(lambda x,y:x+y,l1,l2)
print(res)  # 结果表明了他是一个迭代器
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(list(res))  # 每次迭代取值之后,res的值都是被取走的,不在存于res中

内置函数map()、zip()等都是使用迭代器的方法,因为这样能节省内存

5.生成器

什么是生成器

　　用户自己定义的迭代器,本质就是迭代器,他的特点是使用了yiled

　　用户在调用生成器每次运行的时候,遇到yiled就暂停运行并且返回后面跟的值,直到下一次执行__next__方法时再从当前位置继续执行

def func():
    print('第一次')
    yield 111  # 函数内部如果有yield,则遇到func()不会执行函数体
    print('第二次')
    yield 222
    print('第三次')
    yield 333,444,555,666
# 因为函数内部又yield,所以函数体代码并不会执行
g = func()  # 生成器初始化:将函数变为迭代器
# 调用__next__方法之后,函数体才会执行,并且会返回yield后面跟的值
print(g.__next__())  # 返回111,并且在此暂停
print(g.__next__())  # 遇到下一个__next__继续执行直到遇到下一个yield再次暂停返回值222
print(g.__next__())  # yield也可以返回多个值,并且多个值用元组表示

注意:函数只要有yield时即使遇到函数名加括号func(),函数也不会执行,这时候函数已经变为一个生成器,只有调用__next__方法时才会执行

生成器实现for循环取值

# 生成器实现for循环
# for i in range(1,10,2):
#     print(i)

def my_range(x,y,z=1):
    while x < y:
        yield x
        x += z
for i in my_range(1,10,2):
    print(i)

6.yield表达式形式

yield支持外界给其传参

# yield支持外界给他传参
def dog(name):
    print('%s好饿' % name)
    while True:
        food = yield
        print('%s吃了%s'%(name,food))
# 当函数体有yield时,函数名加括号不会执行函数,而是将函数变为一个生成器
g = dog('zzz')  # 生成器初始化
g.__next__()  # 需要先运行代码至yield
g.send('包子')  # 为yield传参数,并且内置执行__next__
g.send('馒头')
g.send('骨头')

yield:1.帮你提供了一种自定义生成器的方式

　　 2.会将你的函数运行状态暂停

　　 3.可以返回值

和return的异同点

　　相同点:都可以返回值,并且可以返回多个

　　不同点:yield可以返回多次值,return只能返回一次并且直接结束函数

　　　　　 yield还可以接受外部传的值

7.生成器表达式

生成器表达式代码

# 生成器表达式
res = (i for i in range(100) if i != 3)
print(res)  # 生成器初始化
# 生成器不会执行任何一行代码,只有遇到__next__才会执行代码
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__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)
    # 第一次g = (add(n,i) for i in test())  # 第一次的g是test(),因为test()里有yield,所以不执行
    # 第二次g = (add(n,i) for i in (add(n,i) for i in test()))  # 第二次的g是第一次的g,所以直接把第一次的g表达式带入就行
print(n)
res=list(g) # 基于for循环,自带__next__,代码到这才会执行,这时n是第二次的10
print(res)

8.常用内置方法

(1)abs()求绝对值

res = abs(-89568.56465156)  # 求数字的绝对值
print(res)

(2)all(),any()判断多个值的布尔值

l = [0,1,2]
print(all(l))  # 只要有一个为False就为False
print(any(l))  # 只要有一个为True就为True

 

(3)locals(),globals().返回名称空间的名字

def index():
    username = '局部名称空间'
    print(locals())  # 在哪就返回哪里的名称空间的名字
index()
print(locals())
print(globals())  # 不管在哪,返回的都是全局名称空间的名字

(4)bin(),oct(),hex().进制转化

print(bin(10))  # 10进制转2进制
print(oct(10))  # 10进制转8进制
print(hex(10))  # 10进制转16进制
print(int('0b1010',2))  # 2进制转10进制

(5)bool().判断布尔值

# 只有0,None,空集合,字典等为False,其他都是True
print(bool(2))  # 判断布尔值
print(bool(0))

(6)bytes().字符串转二进制

s = 'sxc'
print(bytes(s,encoding='utf-8'))  # 字符串转二进制
print(s.encode(encoding='utf-8'))  # 字符串转二进制

(7)callable()能否被调用

s = 'sxc'
def index():
    pass
print(callable(s))  # 能否被调用
print(callable(index))  # 暂时只有能加括号的()能被调用

(8)chr(),ord().数字与字符在ascii码表的对应关系

print(chr(98))  # 将数字转化为ascii码表对应的字符
print(ord('B'))  # 将字符转化为ascii码表对应的数字

(9)dir().返回参数的属性、方法列表

l = [1,2,3,4,5]
print(dir(l))  # 返回该参数的属性、方法列表

(10)divmod().两数相除取整,两数相除取余

print(divmod(100,10))  # 两数相除取整,两数相除取余
def index(x,y):
    total_paper,more = divmod(x,y)
    if more:
        total_paper += 1
    print('总共需要%s页'%total_paper)
index(101,10)  # 可以解决分页需要页数的问题

(11)enumerate()枚举.传入所要枚举的对象和初始值

l = ['name','pwd','age']
for i,j in enumerate(l,1):  # 枚举,传入所要枚举的对象和初始值
    print(i,j)

(12)eval(),exec().可以简单的执行字符串中编写的代码

s = '''
print("sxc")
'''
eval(s)
exec(s)

都可以执行字符串中的代码

eval()只能简单的执行,不支持逻辑代码

exec()可以执行复杂的代码

s = '''
print("sxc")
age = 123
print(age)
'''
exec(s)  # exec能执行
eval(s)  # eval不能执行

(13)format()格式化函数的三种方式

# format格式化函数
print('{}第一句在这,{}第二句在这'.format(1,2))  # 按位置占位
print('{1}第一句在这,{0}第二句在这'.format(1,2))  # 按索引占位
print('{x}第一句在这,{y}第二句在这'.format(x = 1,y = 2))  # 按关键字占位

(14)help()调出函数的注释

def index():
    '''
    这是注释
    :return: 
    '''
    pass

print(help(index))  # 调出函数的注释

(15)isinstance(),判断数据是否是我们后面指定的数据类型

n = 'sxc'
print(type(n))
print(isinstance(n,int))  # 判断数据类型是否为后面指定的那个

(16)pow().方法返回 x^y（x的y次方） 的值

　   round().方法返回浮点数x的四舍五入值

print(pow(3,3))  # 3的3次方等于27
print(round(10.4))  # 10.4四舍五入等于10

9.面向过程编程

面向过程编程:类似于流水线

　　优点:可以使复杂的问题流程化,从而简单化

　　缺点:可扩展性差,一旦需要修改,整体都会受到影响

一个注册功能按照面向过程编程

# 注册功能
# 获取用户输入
def get_info():
    while True:
        username = input('请输入您的用户名').strip()
        if not username.isalpha():
            print('输入有误,请重新输入')
            continue
        pwd = input('请输入您的密码').strip()
        re_pwd = input('请再次输入您的密码').strip()
        if pwd != re_pwd:
            print('两次密码不一致,请重新输入')
            continue
        deal_info(username,pwd)
        break

# 处理用户信息
def deal_info(username,pwd):
    res = '|'.join([username,pwd])
    save(res,'{username}.txt')

# 把用户信息存入文件中
def save(res,file_name):
    with open(file_name,'w',encoding='utf-8') as f:
        f.write(res)

def register():
    get_info()

register()

把一个注册功能分为三步,获取用户输入,处理用户信息和把用户信息存入文件中,这就是面向过程编程.

 13