python三器一闭
前言：python三器一闭i 包含 迭代器、生成器、装饰器，闭包
迭代器
- 概念：迭代器是一种可以记录可迭代对象遍历的位置，迭代器从第一个元素开始访问，直到访问所有元素访问结束，迭代器只会往前，不会后退的访问
- 可迭代对象： 是一种可以通过for..in 循环的对象，称之为可迭代对象，通常有 字典、列表、字符串，元祖
如何判断一个数据类型是否是可以迭代的
# 可以导入模块 from collections.abc import Iterable
# 然后通过isinstance 来判断出 Iterable 的实例，正确返回True
# Iterator 是判断这个对象是否是迭代器 Iterable 是判断一个对象是否是可迭代的
from collections.abc import Iterable, Iterator
print(isinstance([], Iterable)) # 列表是可以迭代的
print(isinstance({}, Iterable)) # 字典是可以迭代的
print(isinstance("abc", Iterable)) # 字符串是可以迭代的
print(isinstance(100, Iterable)) # 数字是不能迭代的
nums = [11, 33, 22, 55, 66]
print(type(nums))
nums_iter = iter(nums) # 获取可迭代对象中的迭代器
print(type(nums_iter))
# Iterator 是判断这个对象是否是迭代器 Iterable 是判断一个对象是否是可迭代的
print("num is iterator ? {}".format(isinstance(nums, Iterator))) # False
print("num_iter is iterator ？{}".format(isinstance(nums_iter, Iterator))) # True
获取迭代器数据的方式
nums = [11, 33, 22, 55, 66]
print(type(nums))
nums_iter = iter(nums) # 获取可迭代对象中的迭代器
# 获取迭代器中的数据 方式一 使用 next
# 注意使用next获取迭代器的数据时，下标不能越界，否则会抛出异常StopIteration
print(next(nums_iter)) # 11
print(next(nums_iter)) # 22
print(next(nums_iter)) # 33
# 获取迭代器中的数据 方式二 使用 循环，因为它是可迭代的
for x in nums_iter:
print(x)
自定义迭代器类
- 在一个类中有 iter 方法称之为 可迭代对象， 有iter和next方法的称之为迭代器
# 在一个类中 有 __iter__ 方法 这个对象就是可迭代对象,但不是迭代器
# 在一个类中 既实现了 __iter__ 方法 和 __next__ 方法 的对象 既是可迭代对象 也是迭代器
from collections.abc import Iterable
from collections.abc import Iterator
class MyList(object):
"""自定义的一个可迭代对象"""
def __init__(self):
self.items = []
def add(self, val):
self.items.append(val)
def __iter__(self):
return MyIterator()
class MyIterator(object):
"""自定义的供上面可迭代对象使用的一个迭代器"""
def __init__(self):
pass
def __next__(self):
pass
def __iter__(self):
pass
mylist = MyList()
mylist_iter = iter(mylist)
print("mylist是否是可以迭代对象", isinstance(mylist, Iterable)) # True
print("mylist是否是迭代器", isinstance(mylist, Iterator)) # Flase
print("mylist_iter是否是可以迭代对象", isinstance(mylist_iter, Iterable)) # True
print("mylist_iter是否是迭代器", isinstance(mylist_iter, Iterator)) # True
# 可迭代对象不一定是迭代器， 但迭代器第一定是可迭代对象
案例
# 学生管理系统
class Students(object):
"""自定义迭代器"""
def __init__(self):
self.stus = []
# 记录迭代的位置
self.current = 0
def add(self):
"""添加学生信息"""
name = input("请输入学生的姓名:")
phone = input("请输入学生的手机号码")
address = input("请输入学生的地址：")
new_stu = dict()
new_stu["name"] = name
new_stu["phone"] = phone
new_stu["address"] = address
# 将字典添加到列表中
self.stus.append(new_stu)
def __iter__(self):
return self
def __next__(self):
if self.current < len(self.stus):
ret = self.stus[self.current] # 每调用一次，就通过下标访问一个数据
# print("11")
# print(ret)
self.current += 1
return ret
else:
self.current = 0
raise StopIteration
stu_sys = Students()
stu_sys.add()
stu_sys.add()
# stu_sys.add()
# 使用for循环，因为它是迭代器，也是可迭代对象，所以是可迭代的
# for stu in stu_sys:
# print(stu)
# 改列表推导式
x = [x for x in stu_sys]
print(x)
生成器
- 概念：生成器- 一边循环一边生成的机制称之为生成器
- 特点：存储的是生成数据的方式，而不是存储生存的数据，节约内存
创建生成器的方式一
- 将列表推导式中的中括号 改为 大括号[] --->()
# 创建生成器的方式一 将列表推导式中的中括号 改为 大括号
nums = [x for x in range(11)]
print(type(nums)) # <class 'list'>
print(nums) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 生成器
nums2 = (x for x in range(5))
print(type(nums2)) # <class 'generator'>
print(nums2) # 返回的是一个生成器对象(<generator object <genexpr> at 0x103289050>)，如果想要获取里面的数据的话，可以使用next
# print(next(nums2)) # 0
# print(next(nums2)) # 1
# 也可以通过for循环来获取数据，生成器也是迭代器的一种方式，它自动实现了iter 和 next 方法
# for x in nums2:
# print(x)
创建生成器的方式二
- 在一个函数中 有 yield关键字 的称之为 生成器(generator)
- yield 在一个函数中称之为生成器，并且在函数中执行到了yield的时候会暂停这个函数，并且把返回值返回，然后在继续执行下一次
# 使用生成器完成斐波那契数列
# 斐波那契数列 是从数列中的第三项开始，往后就是每一项的数据等于前两项的之和
def fib(n):
a, b = 1, 0
for _ in range(n):
a, b = b, a + b
yield a
for x in fib(10):
print(x)
# 斐波那契数列
def fib(n):
num1 = 1
num2 = 1
# 记录访问的位置
current = 0
while current <= n:
temp_num = num1
num1, num2 = num2, num1+num2
current += 1
yield temp_num # 此时不能使用return，yield自带iter() next() 方法
# 生产数据,生成器每生产一个都会计算一次
for x in fib(5):
print(x) # 1 1 2 3 5 8
案例
"""
问题：
假如有一个的文件 test.txt 大小约为 10K，之前处理文件的,代码如下所示：
"""
# def get_lines():
# l = []
# with open('test.txt', 'rb') as f:
# for eachline in f:
# l.append(eachline)
# return l
#
#
# def process(temp_data):
# print(temp_data) # 用打印来模拟处理过程
#
#
# if __name__ == '__main__':
# for e in get_lines():
# process(e.decode("utf-8")) # 处理每一行数据
"""
现在要处理一个大小为 10G 的文件，但是内存只有 4G，如果在只修改 get_lines 函数而其他代
码保持不变的情况下，应该如何实现？需要考虑的问题都有哪些？
"""
# 使用生成器
def get_list():
with open("test.txt", "r") as f:
while True:
data = f.read(1000 * 1000) # 每次读取1兆数据
if data:
yield data
else:
return
if __name__ == '__main__':
for x in get_list():
print(x)
总结
# 生成器是一种一边循环一边生成的机制称之为生成器。
# 在一个函数中有 yield 关键字的称之为 生成器
# yield 关键字 的特点 1 能够保存程序的执行状态，并且在函数中执行到了yield的时候会暂停这个函数，
# 并且把返回值返回，然后在继续执行下一次
# 2 能够节省了内存的空间地址。使用yield的好处在于它不会一次性将所有数据计算计算，而是取一次然后就计算一个
# 这样节省了空间和计算的时间
# 生成器的主要一个特点就是，生成器是一种存储生成数据的方式，而不是存储生存的数据。
# return 和 yield 的区别
# 两者都是 返回程序的运行结果
# 不同的是，return 在返回结果后程序会立刻结束
# yield 在程序执行完结果后不会立刻结束，而是等待下一次执行，并且能被记录最后一次计算的数据结果。
闭包
-
概念：在一个函数中嵌套了另外一个函数，并且函数内部引用了外部函数的形参或局部变量的称之为闭包
引入闭包
def make_print(num1): # 外部函数 def inter(num2): # 内部函数 print(num1 + num2) # 300 return inter ret = make_print(100) # 该100 存入 外部函数中 ret(200) # 该200是传入内部函数中 -
闭包中能够修改外部函数中的局部变量，闭包中可以使用 nonlocal 修改变量
def demo_out(): m = 100 # 局部变量 def inter(): # 内部函数修改外部函数 使用 nonlocal nonlocal m m = 300 print("3", m) # 300 print("1", m) # 100 inter() # 返回内部函数中的引用 print("2", m) # 300 demo_out()
案例一
# 下面应用案例是理解闭包的经典题目，模拟了一个人站在原点，然后向X、Y轴进行移动，每次移动后及时打印当前的位置
def create():
# 外部函数中定义一个局部变量
pos = [0, 0] # 坐标原点x,y
def inter(direction, step):
new_x = pos[0] + direction[0] * step
new_y = pos[1] + direction[1] * step
pos[0] = new_x
pos[1] = new_y
return pos
return inter
player = create() # 创建棋子player，起点为原点
print(player([1, 0], 10)) # 向x轴正方向移动10步
print(player([0, 1], 10)) # 向y轴正向移动20步
print(player([-1, 0], 10)) # 向x轴负方向移动10步
# [10, 0]
# [10, 10]
# [0, 10]
案例二
#
# 有时我们需要对某些文件的特殊行进行分析，先要提取出这些特殊行,就可以使用闭包, 在内部获取文件名，外部引入要在文件提取的关键字
#
# 例如，需要取得文件"result.txt"中含有"163.com"关键字的行，看如下代码
def make_file(keep): # 外部函数
# 内部函数
def file_name(file):
# 读取出文件
read_file = open(file)
ret = read_file.readlines()
read_file.close()
ret_list = [i for i in ret if keep in i]
return ret_list
return file_name
filter_file = make_file("163.com")
file_name = filter_file("result.txt")
print(file_name)
总结
-
闭包概念：在一个函数中嵌套了另外一个函数，并且函数内部引用了外部函数的形参、或局部变量，称之为闭包
-
闭包和普通函数的区别
闭包在函数中执行完结果后，函数外部的局部变量不会被释放，会给内部函数使用
普通函数在执行完结果后不会保存值
-
闭包是在函数内再嵌套函数 闭包可以访问另外一个函数的局部变量或形参, 闭包可以让参数和变量不会被垃圾回收机制回收，始终保持在内存中
