第一部分 迭代器
"""
迭代器
"""
li=[1,2,3,4]
tu=(1,2,3,4)
s="abc"
b=b"def"
d={"a":1,"b":2}
se={1,2,3}
for i in li:
pass
for i in tu:
pass
for i in s:
pass
for i in b:
pass
for i in d:
pass
for i in se:
pass
# for i in 1:
# pass
1. 可迭代对象
# 能够放在for循环中进行遍历的类型，就是可迭代类型，产生的对象就是可迭代对象
# 可迭代对象类型，在python collections.abc.Iterable，包括__iter__方法。所有的可迭代对象。
# 必须都实现__iter__方法。返回的是迭代器。
# 学过的list，tuple等可迭代对象都是继承了这个父类Iterable，实现__iter__
from collections.abc import Iterable print(issubclass(list,Iterable)) print(issubclass(tuple,Iterable)) print(issubclass(str,Iterable)) print(issubclass(bytes,Iterable)) print(issubclass(dict,Iterable)) print(issubclass(set,Iterable)) print(issubclass(int,Iterable))
# 说明：可迭代对象有一些没有实现__iter__方法，是特殊的，而是实现的__getiterm__方法
2. 迭代器
# 迭代器是迭代对象的特殊类型，迭代器是迭代对象的子类
from collections.abc import Iterator
print(issubclass(Iterator,Iterable))
# 在迭代器中两个重要方法 __next__ __iter__
# __next__方法：能够返回迭代器下一个元素
li=[1,2,3] # li是迭代对象
# __iter__方法:能够返回迭代器
# li.__iter__() iter(li)在调用上等价，但是建议用后一种方法
# it=iter(li)
# it 是迭代器，迭代器中包含了所有的元素
it=iter(li)
# it.__next__() next(it)在调用上等价，建议用后一种
print(it.__next__())
print(next(it))
print(next(it))
print(next(it)) # 当迭代器中的元素已经全部被next获得之后，会报StopIteration的异常
# 迭代器产生一次，只要遍历过，当前的迭代器中的元素就没有了。
# for 循环是怎么做到可以一直遍历迭代对象的呢？
# 是因为每次for的时候，都会新创建一个迭代器，进行迭代
li1=[1,2,3,4,5]
# it=li1.__iter__()
# 获得当前迭代对象的迭代器（这个迭代器一次只产生一个）
it=iter(li1)
while True:
try:
item=next(it)
except StopIteration:
del it
break
# 注意：
# 1. 分清迭代对象是什么？迭代器是什么？
# Iterable 迭代对象，我们学过的所有的list,tuple都是Iterable的子类
# 如果新创建一个列表，是一个对象，是list的对象，list是Iterable的子类
# 2. 他们之间的关系
# Iterator，是迭代对象的子类
# 3. 迭代对象下有什么方法？干什么的？
# # Iterable下有__iter__方法，注意，调用的时候，可以直接使用__iter__，建议使用iter(迭代对象)
# iter 方法能够返回一个迭代器。
# 4. 迭代器下有什么方法？干什么的？
# Iterator 有__next__:能够找到迭代器中的下一个对象。
# 还有 __iter__：return self。 为了扩展使用
# 注意，迭代器在遍历一次之后，迭代器的元素就没了，如果需要再次遍历，需要重新使用迭代对象
# 调用迭代对象下的iter方法创建新的迭代器。
3. 自定义迭代对象和迭代器。
# 符合如下规则：
迭代对象： 里面实现__iter__方法。
迭代器： 里面实现__iter__和__next__方法
class MyIterable:
def __iter__(self):
pass
class MyIterator:
def __iter__(self):
pass
def __next__(self):
pass
# 只要定义的迭代对象，实现了__iter__方法，那么它就是迭代对象，就是Iterable的子类，不需要显示继承
# 只要定义了迭代器，实现了__next__ 和__iter__，那么它就是迭代器，就是iterator的子类，不需要显示继承
m=MyIterable()
print(isinstance(m,Iterable))
print(issubclass(MyIterable,Iterable))
n=MyIterator
print(isinstance(n,Iterator))
print(issubclass(MyIterator,Iterator))
class MyIterable1:
def __iter__(self):
self.li=[1,2,3,"a"]
return
class MyIterator1:
def __init__(self,li):
self.li=li
self.index=0
def __iter__(self):
pass
def __next__(self):
if self.index<len(self.li):
s=self.li[self.index]
self.index+=1
return s
else:
# 当索引大于长度
raise StopIteration
m=MyIterable()
m1=iter(m)
print(m1.__next__())
print(next(m1))
# 为什么list 或者tuple这些可迭代的数据类型被设计成“迭代对象”，而不是直接设计成“迭代器"？
# 迭代器
# 写一个迭代器，实现一个倒数的迭代器
4. 迭代器的缺点
# (1) 必须要去实现iter方法和next方法
# (2) 如果不是用for 循环，那么无返回值的时候，需要捕捉StpIteration的异常
# (3) 一次性全部迭代，结果未必是一下子全部使用，当数量级太大的时候，会占用太多的内存
# 解决方法-------生成器
第二部分 生成器
"""
生成器
在python2.5之后出现的，生成器返回一个可迭代的对象，但是不是立即返回所有的值，而是一个一个的生成值
懒加载：延迟加载，按需加载。
生成器，其实就是给一个函数，生成一个懒加载的迭代器。
"""
# 将列表中的每一个元素的数，求平方
li=[]
for i in range(1,101):
li.append(i**2)
print(li)
print([i**2 for i in range(1,101)])
# 生成器的实现有两种方式：一种生成器表达式，另一种是生成器函数
1. 使用生成器表达式
linew=(i**2 for i in range(1,101))
# linew是一个生成器对象
print(linew)
# 因为生成器底层是迭代器，使用for 循环，可以触发生成器产生每一个元素
# for i in linew:
# print(i)
# 生成器就是迭代器，遍历完一次之后就没有东西了
print(next(linew))
2. 生成器函数
生成器函数就看有没有yield
# 定义一个普通函数
# def f():
# for i in range(1,101):
# print(i)
# f()
# 生成器函数
def f():
print("生成器函数开始执行")
for i in range(1,101):
yield i
print(i,"暂停之后继续执行")
a=f()
print(a)
a.__next__()
next(a)
next(a)
for i in a:
print(i)
# 练习：使用正常函数和生成器函数写出斐波那契数列
def f():
print("程序开始执行")
a=0
b=1
for i in range(100):
print("yield之前")
yield b
print("yield之后继续执行")
a,b=b,a+b
g=f()
print(next(g))
print(next(g))
print(next(g))
print(next(g))
# 说明： 1. 生成器函数，在被调用的时候，只会产生一个生成器对象（本质迭代器对象）
# 2. 不会运行函数中的任何一行代码
# 3. 当使用next（生成器对象），才触发函数执行，运行到yield暂停
# 4. 当继续调用next函数时，从刚才暂停的位置，继续向后执行
"""
生成器函数和普通函数的区别
1. 生成器函数会包含一个或者多个yield
2. 当生成器函数运行到yield，暂停，相当于把控制权交给调用者
"""
3. yield表达式。
# 在生成器函数除了可以使用yield产生一个值以外，其实，同时yield表达式本身还具有一个值，
# 不是产出的值，而是使用send方法传递进去的值
# send(值)
def fun():
for i in range(100):
value=yield i
print(value)
g=f()
print(g.send(None))
print(g.send("send传入的值"))
print(next(g))
print(g.send("这是send传进来的值"))
print(g.send(None))
# send 和 next 他们都可以调用生成器对象产生的元素
# 调用next函数，相当于传入值None,next函数的返回值是yield生成的内容
# 调用send函数，可以传入yield表达式的值（生成器函数中value值，value=yield i)
# send函数的返回值，也是yield生成的内容
# 第一次调用next唤醒生成器对象，跟使用send(None)效果一样
# 第一次调用只能使用send（None），分析原因，停在yield，还没有对左侧的value进行赋值
# 需求：使用生成器产生一系列的值，比如，1,2,3..到5时，返回给客户端，说太大了，变小点
# 生成器在继续产生4,3,2,1，到1的时候，客户端说太小了，变大点，生成器继续产生2,3,4,5
第三部分 闭包
"""
闭包：
在内部函数中，访问外部函数的变量，在外部函数中，直接返回内部函数引发调用
(1) 有嵌套函数
(2) 内部函数可以访问到外部函数的变量
(3) 外部函数返回内部函数的名字
"""
def abc():
print("已经存在的函数")
def outer(a):
x=1
def inner():
print(x)
print(a)
print("inner函数")
return inner
inner=outer("abc")
print(inner.__closure__)
inner()
# 闭包的作用：
# 1. 当函数执行结束时，内部函数依然可以引用到外部函数中定义的变量,下一次再调用内部函数时
# 依然可以调用到外部函数中变量值。
# 2. 内部函数的名称处于局部命名空间，不会对外部全局命名空间造成影响，即使函数名相同也没问题
# 实现bill第几天上班
def on_duty(name):
times=0
times+=1
print("这是{}第{}次上班".format(name,times))
on_duty("bill")
on_duty("bill")
# 闭包
def on_duty(name):
times=0
def inner():
nonlocal times
times+=1
print("这是{}第{}次上班".format(name,times))
return inner
duty=on_duty("bill")
duty()
duty()
duty()
# 通过类也能实现闭包
class Onduty:
def __init__(self,name):
self.name=name
self.times=0
def __call__(self, *args, **kwargs):
self.times+=1
print("这是{}第{}次上班".format(self.name,self.times))
duty=Onduty("bill")
duty()
duty()