py13函数迭代器与生成器

"""
什么是迭代器
迭代:更新换代(重复)的过程,每次的迭代都必须基于上一次的结果
迭代器:迭代取值的工具

为什么要用
迭代器给你提供了一种不依赖于索引取值的方式

如何用
"""
# 不算 因为只是简单的重复
# n = 0
# while True:
# print(n)

# 重复 + 每次迭代都是基于上一次的结果而来的
# l = [1,2,3,4]
# s = 'hello'
# n = 0
# while n < len(s):
# print(s[n])
# n += 1
"""
需要迭代取值的数据类型
字符串
列表
元组
字典
集合
"""

# 可迭代对象
# 只有内置有__iter__方法的都叫做可迭代对象
"""
补充:针对双下线开头双下划线结尾的方法
推荐读:双下+方法名

基本数据类型中
是可迭代对象的有
str list tuple dict set
文件对象(执行内置的__iter__之后还是本身 没有任何变化):文件对象本身就是迭代器对象

"""
n = 1
f = 1.1
s = 'hello'
l = [1,2,34,]
t = (1,2,34)
s1 = {1,2,3,4}
d = {'name':'jason'}
f1 = open('xxx.txt','w',encoding='utf-8')

#
# res = s.__iter__() # res = iter(s)
#
# print(s.__len__()) # 简化成了len(s)
# res1 = l.__iter__() # res1 = iter(l)
# res2 = f1.__iter__() # res2 = iter(f1)
# print(res,res1,res2)
# print(f1)

# 可迭代对象执行内置的__iter__方法得到就是该对象的迭代器对象

"""
迭代器对象
1.内置有__iter__方法
2.内置有__next__方法
ps:迭代器一定是可迭代对象
而可迭代对象不一定是迭代器对象
"""

# l = [1,2,3,4]
# # 生成一个迭代器对象
# iter_l = l.__iter__()
#
# # 迭代器取值 调用__next__
# print(iter_l.__next__())
# print(iter_l.__next__())
# print(iter_l.__next__())
# print(iter_l.__next__())
# print(iter_l.__next__()) # 如果取完了 直接报错

# d = {'name':'jason','password':'123','hobby':'泡m'}
# # 将可迭代对象d转换成迭代器对象
# iter_d = d.__iter__()
# # 迭代器对象的取值 必须用__next__
# print(iter_d.__next__())
# print(iter_d.__next__())
# print(iter_d.__next__())
# print(iter_d.__next__()) # 取完了 报错StopIteration

f1 = open('xxx.txt','r',encoding='utf-8')
# 调用f1内置的__iter__方法
# iter_f = f1.__iter__()
# print(iter_f is f1)
"""
迭代器对象无论执行多少次__iter__方法得到的还是迭代器对象本身(******)
"""
# print(f1 is f1.__iter__().__iter__().__iter__().__iter__())
"""
问:__iter__方法就是用来帮我们生成迭代器对象
而文件对象本身就是迭代器对象,为什么还内置有__iter__方法???
"""

d = {'name':'jason','password':'123','hobby':'泡m'}
# iter_d = d.__iter__()

# print(d.__iter__().__next__())
# print(d.__iter__().__next__())
# print(d.__iter__().__next__())

# print(iter_d.__next__())
# print(iter_d.__next__())
# print(iter_d.__next__())
# print(iter_d.__next__())

# 异常处理
# while True:
# try:
# print(iter_d.__next__())
# except StopIteration:
# # print('老母猪生不动了')
# break

# f = open('xxx.txt','r',encoding='utf-8')
# iter_f = f.__iter__()
# print(iter_f.__next__())
# print(iter_f.__next__())
# print(iter_f.__next__())
# print(iter_f.__next__())
# print(iter_f.__next__())

 

"""
迭代器取值的特点
1.只能往后依次取 不能后退

"""

04 for循环的本质

d = {'name':'jason','password':'123','hobby':'泡m'}
# for i in d:
# print(i)
# for循环后面的in关键 跟的是一个可迭代对象
"""
for循环内部的本质
1.将in后面的对象调用__iter__转换成迭代器对象
2.调用__next__迭代取值
3.内部有异常捕获StopIteration,当__next__报这个错 自动结束循环
"""
# for i in 1:
# pass
# iter(1)

"""
可迭代对象:内置有__iter__方法的
迭代器对象:既内置有__iter__也内置有__next__方法

迭代取值:
优点
1.不依赖于索引取值
2.内存中永远只占一份空间,不会导致内存溢出

缺点
1.不能够获取指定的元素
2.取完之后会报StopIteration错

"""
# l = [1,2,3,4]
# res = map(lambda x:x+1,l)
# print(map(lambda x:x+1,l))
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())

l1 = [1,2,3,4,5]
l2 = ['a','b','c']
print(zip(l1,l2))

 05 生成器

"""
生成器:用户自定义的迭代器,本质就是迭代器

"""
# def func():
# print('first')
# yield 666 # 函数内如果有yield关键字,那么加括号执行函数的时候并不会触发函数体代码的运行
# print('second')
# yield 777
# print('third')
# yield 888
# print('forth')
# yield
# yield
# # yield后面跟的值就是调用迭代器__next__方法你能得到的值
# # yield既可以返回一个值也可以返回多个值 并且多个值也是按照元组的形式返回
# g = func() # 生成器初始化:将函数变成迭代器
# print(g)
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())

 

# print(range(1,10))

# for i in range(1,10,2):
# print(i)

def my_range(start,end,step=1):
while start < end:
yield start
start += step

for j in my_range(1,100,2):
print(j)

06 yield表达式形式(了解)

# yield支持外界为其传参
def dog(name):
print('%s 准备开吃'%name)
while True:
food = yield
print('%s 吃了 %s'%(name,food))
# def index():
# pass

# 当函数内有yield关键字的时候,调用该函数不会执行函数体代码
# 而是将函数变成生成器
# g = dog('egon')
# g.__next__() # 必须先将代码运行至yield 才能够为其传值
# g.send('狗不理包子') # 给yield左边的变量传参 触发了__next__方法
# g.send('饺子')

"""
yield
1.帮你提供了一种自定义生成器方式
2.会帮你将函数的运行状态暂停住
3.可以返回值

与return之间异同点
相同点:都可以返回值,并且都可以返回多个
不同点:
yield可以返回多次值,而return只能返回一次函数立即结束
yield还可以接受外部传入的值
"""

07 生成器表达式

# 列表生成式
# res = [i for i in range(1,10) if i != 4]
# print(res)

# res = (i for i in range(1,100000000) if i != 4) # 生成器表达式
# print(res)
# """
# 生成器不会主动执行任何一行代码
# 必须通过__next__触发代码的运行
# """
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())

# 占内存
# f = open('xxx.txt','r',encoding='utf-8')
# data = f.read()
# print(len(data))
# f.close()

# with open('xxx.txt','r',encoding='utf-8') as f:
# # n = 0
# # for line in f:
# # n += len(line)
# # print(n)
# g = (len(line) for line in f)
# # print(g.__next__())
# # print(g.__next__())
# # print(g.__next__())
# # print(g.__next__())
# print(sum(g))

08 常用内置方法

# print(abs(-11.11)) # 求绝对值
# l = [0,1,0]
# print(all(l)) # 只要有一个为False就返回False
# print(any(l)) # 只要有一个位True就返回True
def index():

username = '我是局部名称空间里面的username'
# print(locals()) # 当前语句在哪个位置 就会返回哪个位置所存储的所有的名字
print(globals()) # 无论在哪 查看的都是全局名称空间
# index()
# print(bin(10))
# print(oct(10))
# print(hex(10))
# print(int('0b1010',2))

# print(bool(1))
# print(bool(0))

# s = 'hello'
# print(s.encode('utf-8'))
# print(bytes(s,encoding='utf-8'))

# 可调用的(可以加括号执行相应功能的)
# l = [1,2,3]
# def index():
# pass
# print(callable(l))
# print(callable(index))

 

 

# print(chr(97)) # 将数字转换成ascii码表对应的字符
# print(ord('a')) # 将字符按照ascii表转成对应的数字

"""
面向对象需要学习的方法
classmethod
delattr
getattr
hasattr
issubclass
property
repr
setattr
super
staticmethod
"""
# dir获取当前对象名称空间里面的名字
# l = [1,2,3]
# print(dir(l))
#
# import test
# print(dir(test))
# print(test.name)

# divmod 分页器

# print(divmod(101,10))
# total_num,more = divmod(900,11)
# if more:
# total_num += 1
# print('总页数:',total_num)

# enumerate 枚举
# l = ['a','b']
# for i,j in enumerate(l,1):
# print(i,j)

# eval exec
s = """
print('hello baby~')
x = 1
y = 2
print(x + y)
"""
# eval(s)
# exec(s)

# eval不支持逻辑代码,只支持一些简单的python代码
s1 = """
print(1 + 2)
for i in range(10):
print(i)
"""
# eval(s1)
# exec(s1)

# name = 'jason'
# s2 = """
# name
# """
# print(eval(s2))

# format 三种玩法
# {}占位
# {index} 索引
# {name} 指名道姓

# print(globals())
def login():
"""
一起嗨皮
:return:
"""
# print(help(login))

# isinstance 后面统一改方法判断对象是否属于某个数据类型
# n = 1
# print(type(n))
# print(isinstance(n,list)) # 判断对象是否属于某个数据类型

# print(pow(2,3))

# print(round(3.4))