Python迭代器,生成器,装饰器
迭代器
通常来讲从一个对象中依次取出数据,这个过程叫做遍历,这个手段称为迭代(重复执行某一段代码块,并将每一次迭代得到的结果作为下一次迭代的初始值)。
可迭代对象(iterable):是指该对象可以被用于for…in…循环,例如:集合,列表,元祖,字典,字符串,迭代器等。
在python中如果一个对象实现了 __iter__方法,我们就称之为可迭代对象,可以查看set\list\tuple…等源码内部均实现了__iter__方法
如果一个对象未实现__iter__方法,但是对其使用for…in则会抛出TypeError: 'xxx' object is not iterable
可以通过isinstance(obj,Iterable)来判断对象是否为可迭代对象。如:
from collections.abc import Iterable
# int a
a = 1
print(isinstance(a, Iterable)) # False # str b
b = "lalalalala"
print(isinstance(b, Iterable)) # True # set c
c = set([1, 2])
print(isinstance(c, Iterable)) # True # list d d = [1,2,3,"a"]
print(isinstance(d, Iterable)) # True # dict e
e = {"a":1,"b":2,"c":333}
print(isinstance(e, Iterable)) # True # tuple f
f = (1,3,4,"b","d",)
print(isinstance(f, Iterable)) # True我们也可以自己实现__iter__来将一个类实例对象变为可迭代对象:
我们也可以自己实现__iter__来将一个类实例对象变为可迭代对象:
自己实现迭代对象的要求
1、在python中如果一个对象同时实现了__iter__和__next__(获取下一个值)方法,那么它就是一个迭代器对象。2、可以通过内置函数next(iterator)或实例对象的__next__()方法,来获取当前迭代的值
3、迭代器一定是可迭代对象,可迭代对象不一定是迭代器。
4、如果可迭代对象遍历完后继续调用next(),则会抛出:StopIteration异常。
from collections.abc import Iterator, Iterable class MyIterator:
def __init__(self, array_list):
self.array_list = array_list
self.index = 0 def __iter__(self):
return self def __next__(self):
if self.index < len(self.array_list):
val = self.array_list[self.index]
self.index += 1
return val
else:
raise StopIteration # 父类如果是迭代器,子类也将是迭代器
class MySubIterator(MyIterator):
def __init__(self):
pass myIterator = MyIterator([1, 2, 3, 4])
# 判断是否为可迭代对象
print(isinstance(myIterator, Iterable)) # True
# 判断是否为迭代器
print(isinstance(myIterator, Iterator)) # True # 子类实例化
mySubIterator = MySubIterator()
print(isinstance(mySubIterator, Iterator)) # True
# 进行迭代 print(next(myIterator)) # 1
print(myIterator.__next__()) # 2
print(next(myIterator)) # 3
print(next(myIterator)) # 4
print(next(myIterator)) # raise StopIteration
迭代器优缺点:
- 优点:
迭代器对象表示的是一个数据流,可以在需要时才去调用next来获取一个值;因而本身在内存中始终只保留一个值,
对于内存占用小可以存放无限数据流。
优于其他容器需要一次将所有元素都存放进内存,如:列表、集合、字典...等。
- 缺点:
1.无法获取存放的元素长度,除非取完计数。
2.取值不灵活,只能向后取值,next()永远返回的是下一个值;无法取出指定值(无法像字典的key,或列表的下标),而且迭代器对象的生命周期是一次性的,元素被迭代完则生命周期结束。
生成器
定义:在Python中,一边循环一边计算的机制,称为生成器:generator;同时生成器对象也是迭代器对象,所以他有迭代器的特性;
例如支持for循环、next()方法…等
作用:对象中的元素是按照某种算法推算出来的,在循环的过程中不断推算出后续的元素,这样就不必创建完整的list,从而节省大量的空间。 简单生成器:通过将列表生成式[]改成()即可得到一个生成器对象。
# 列表生成式
_list = [i for i in range(10)]
print(type(_list)) # <class 'list'>
print(_list) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 生成器
_generator = (i for i in range(10))
print(type(_generator)) # <class 'generator'>
print(_generator) # <generator object <genexpr> at 0x7fbcd92c9ba0>
# 生成器对象取值
print(_generator.__next__()) # 0
print(next(_generator)) # 1
# 注意从第三个元素开始了!
for x in _generator:
print(x) # 2,3,4,5,6,7,8,9
因为生成器对象也有迭代器的特性,所以元素迭代完后继续调用next()方法则会引发StopIteration。
函数对象生成器:带yield语句的函数对象的返回值则是个生成器对象。
def gen_generator():
yield 1
def func():
return 1
print(gen_generator(), type(gen_generator()))
# <generator object gen_generator at 0x7fe68b2c8b30> <class 'generator'>
print(func(), type(func()))
# 1 <class 'int'>
def gen_generator():
yield "start"
for i in range(2):
yield i
yield "finish"
gen = gen_generator()
print("从gen对象中取出第一个值",next(gen))
print("从gen对象中取出第二个值",next(gen))
print("从gen对象中取出第三个值",next(gen))
print("从gen对象中取出第四个值",next(gen))
#
#从gen对象中取出第一个值 start
#从gen对象中取出第二个值 0
#从gen对象中取出第三个值 1
#从gen对象中取出第四个值 finish
#
# StopIteration
#print("从gen对象中取出五个值",next(gen))
#就相当于
#gen2 = (i for i in ["start",1,2,"finish"])
注意:yield 一次只会返回一个元素,即使返回的元素是个可迭代对象,也是一次性返回
def gen_generator2():
yield [1, 2, 3]
s = gen_generator2()
print(next(s)) # [1, 2, 3]
yield生成器高级应用: send()方法,传递值给yield返回(会立即返回!);
如果传None,则等同于next(generator)。
def consumer():
r = ''
while True:
n = yield r
if not n:
return
print(f'[CONSUMER] Consuming get params.. ({n})')
if n == 3:
r = '500 Error'
else:
r = '200 OK'
def produce(c):
c.send(None) # 启动生成器
n = 0
while n < 5:
n = n + 1
print(f'[PRODUCER] Producing with params.. ({n})')
r = c.send(n) # 一旦n有值,则切换到consumer执行
print(f'[PRODUCER] Consumer return : [{r}]')
if not r.startswith('200'):
print("消费者返回服务异常,则结束生产,并关闭消费者")
c.close() # 关闭生成器
break
consume = consumer()
produce(consume)
[PRODUCER] Producing with params.. (1)
[CONSUMER] Consuming get params.. (1)
[PRODUCER] Consumer return : [200 OK]
[PRODUCER] Producing with params.. (2)
[CONSUMER] Consuming get params.. (2)
[PRODUCER] Consumer return : [200 OK]
[PRODUCER] Producing with params.. (3)
[CONSUMER] Consuming get params.. (3)
[PRODUCER] Consumer return : [500 Error]
消费者返回服务异常,则结束生产,并关闭消费者
yield from iterable 语法,基本作用为:返回一个生成器对象,提供一个“数据传输的管道”,
yield from iterable 是 for item in iterable: yield item的缩写;
并且内部帮我们实现了很多异常处理,简化了编码复杂度。 yield 无法获取生成器return的返回值:
def my_generator2(n, end_case):
for i in range(n):
if i == end_case:
return f'当 i==`{i}`时,中断程序。'
else:
yield i
g = my_generator2(5, 2) # 调用
try:
print(next(g)) # 0
print(next(g)) # 1
print(next(g)) # 此处要触发end_case了
except StopIteration as exc:
print(exc.value) # 当 i==`2`时,中断程序。
使用yield from 可以简化成:
def my_generator3(n, end_case):
for i in range(n):
if i == end_case:
return f'当 i==`{i}`时,中断程序。'
else:
yield i
def wrap_my_generator(generator): # 将my_generator的返回值包装成一个生成器
result = yield from generator
yield result
g = my_generator3(5, 2) # 调用
for _ in wrap_my_generator(g):
print(_)
# 输出:
# 0
# 1
# 当 i==`2`时,中断程序。
"""
yield from 有以下几个概念名词:
1、调用方:调用委派生成器的客户端(调用方)代码(上文中的wrap_my_generator(g))
2、委托生成器:包含yield from表达式的生成器函数(包装),作用就是提供一个数据传输的管道(上文中的wrap_my_generator)
3、子生成器:yield from后面加的生成器函数对象(上文中的my_generator3的实例对象g)
调用方是通过这个 “包装函数” 来与生成器进行交互的,即“调用方——>委托生成器——>生成器函数”
下面有个例子帮助大家理解
"""
# 子生成器
def average_gen():
total = 0
count = 0
average = 0
while True:
new_num = yield average
if new_num is None:
break
count += 1
total += new_num
average = total / count
# 每一次return,都意味着当前协程结束。
return total, count, average
# 委托生成器
def proxy_gen():
while True:
# 只有子生成器要结束(return)了,yield from左边的变量才会被赋值,后面的代码才会执行。
total, count, average = yield from average_gen()
print("总共传入 {} 个数值, 总和:{},平均数:{}".format(count, total, average))
# 调用方
def main():
calc_average = proxy_gen()
next(calc_average) # 激活协程
calc_average.send(10) # 传入:10
calc_average.send(None) # 结束协程 send(None)等于next(calc_acerage),也就是会走到average_gen里面的return语句
print("================== 重开协程 ===================")
calc_average.send(20) # 传入:20
calc_average.send(30) # 传入:30
calc_average.send(None) # 结束协程
if __name__ == '__main__':
main()
# 输出:
# 总共传入 1 个数值, 总和:10,平均数:10.0
# ================== 重开协程 ===================
# 总共传入 2 个数值, 总和:50,平均数:25.0
装饰器
一句话来解释装饰器,就是函数的嵌套调用
主要应用在3个方面:
- 打印程序的执行时间
- 收集程序的执行日志
- 用于接口访问鉴权
先看一个简单的例子
def decorator_get_function_name(func):
"""
获取正在运行函数名
:return:
"""
def wrapper(*arg):
"""
wrapper
:param arg:
:return:
"""
print(f"当前运行方法名:{func.__name__} with params: {arg}")
return func(*arg)
return wrapper
# @func_name是python的语法糖
@decorator_get_function_name
def test_func_add(x, y):
print(x + y)
def test_func_sub(x, y):
print(x - y)
test_func_add(1, 2)
# 输出:
# 当前运行方法名:test_func_add with params: (1, 2)
# 3
# 不使用语法糖的话也可以用以下方法,效果是一样的
decorator_get_function_name(test_func_sub)(3, 5)
# 还记得前文讲的引用吗?我们还可以换种写法达到跟一样的效果
dec_obj = decorator_get_function_name(test_func_sub) # 这里等同于wrapper对象
dec_obj(3,5) # 这里等同于wrapper(3,5)
# 输出:
# 当前运行方法名:test_func_sub with params: (3, 5)
# -2
常用于如鉴权校验,例如笔者会用于登陆校验:
def login_check(func):
def wrapper(request, *args, **kwargs):
if not request.session.get('login_status'):
return HttpResponseRedirect('/api/login/')
return func(request, *args, **kwargs)
return wrapper
@login_check
def edit_config():
pass
多个装饰器事例
def w1(func):
@wraps(func)
def wrapper(*args, **kwargs):
print("这里是第一个校验")
return func(*args, **kwargs)
return wrapper
def w2(func):
@wraps(func)
def wrapper(*args, **kwargs):
print("这里是第二个校验")
return func(*args, **kwargs)
return wrapper
def w3(func):
def wrapper(*args, **kwargs):
print("这里是第三个校验")
return func(*args, **kwargs)
return wrapper
@w2 # 这里其实是w2(w1(f1))
@w1 # 这里是w1(f1)
def f1():
print(f"i`m f1, at {f1}")
f1()
这里是第二个校验
这里是第一个校验
i`m f1, at <function f1 at 0x113fe83a0>
注意:写一个decorator的时候,最好在实现之前加上functools的wrap,它能保留原有函数的名称和函数属性
#不加wraps
def my_decorator(func):
def wrapper(*args, **kwargs):
'''decoratord'''
print('Calling decorated function...')
return func(*args, **kwargs)
return wrapper
@my_decorator
def example():
"""Docstring"""
print('Called example function')
print(example.__name__, example.__doc__)
# 加wraps
import functools
def my_decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
'''decorator'''
print('Calling decorated function...')
return func(*args, **kwargs)
return wrapper
@my_decorator
def example():
"""Docstring"""
print('Called example function')
print(example.__name__, example.__doc__)
##########################
wrapper decoratord
example Docstring
日志打印事例
from functools import wraps
# 这是装饰函数
def logger(func):
@wraps(func)
def wrapper(*args, **kw):
print('我准备开始计算:{} 函数了:'.format(func.__name__))
# 真正执行的是这行。
func(*args, **kw)
print('啊哈,我计算完啦。给自己加个鸡腿!!')
return wrapper
@logger
def add(x, y):
print('{} + {} = {}'.format(x, y, x+y))
add(200, 50)
##########################
我准备开始计算:add 函数了:
200 + 50 = 250
啊哈,我计算完啦。给自己加个鸡腿!!
带参数的装饰器实现
from functools import wraps
def say_hello(contry):
@wraps(contry)
def wrapper(func):
def deco(*args, **kwargs):
if contry == "china":
print("你好!")
elif contry == "america":
print('hello.')
else:
return
# # 真正执行函数的地方
func(*args, **kwargs)
return deco
return wrapper
@say_hello("china")
def chinese():
print("我来自中国。")
@say_hello("america")
def american():
print("I am from America.")
chinese()
american()
#######################
你好!
我来自中国。
hello.
I am from America.
装饰器类
以上都是基于函数实现的装饰器,在阅读别人代码时,还可以时常发现还有基于类实现的装饰器。
基于类装饰器的实现,必须实现 call 和 __init__两个内置函数。
init :接收被装饰函数
call :实现装饰逻辑。
1、不带参数
class logger(object):
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
print("[INFO]: the function {func}() is running..."\
.format(func=self.func.__name__))
return self.func(*args, **kwargs)
@logger
def say(something):
print("say {}!".format(something))
say("hello")
################
[INFO]: the function say() is running...
say hello!
2、带参数的类
#带参数装饰器
class logger(object):
def __init__(self,level='INFO'):
self.level = level
def __call__(self,func):
def wrapper(*args, **kwargs):
print("[{level}]: the function {func}() is running..." \
.format(level=self.level, func=func.__name__))
func(*args,**kwargs)
return wrapper
@logger(level='WARNING')
def say(something):
print("say {}!".format(something))
say("hello")
#########################
[WARNING]: the function say() is running...
say hello!
Python迭代器,生成器,装饰器的更多相关文章
- Python 迭代器&生成器,装饰器,递归,算法基础:二分查找、二维数组转换,正则表达式,作业:计算器开发
本节大纲 迭代器&生成器 装饰器 基本装饰器 多参数装饰器 递归 算法基础:二分查找.二维数组转换 正则表达式 常用模块学习 作业:计算器开发 实现加减乘除及拓号优先级解析 用户输入 1 - ...
- 4.python迭代器生成器装饰器
容器(container) 容器是一种把多个元素组织在一起的数据结构,容器中的元素可以逐个地迭代获取,可以用in, not in关键字判断元素是否包含在容器中.通常这类数据结构把所有的元素存储在内存中 ...
- Python迭代器&生成器&装饰器
1. 迭代器 1.1 可迭代对象(Iterator) 迭代器协议:某对象必须提供一个__next__()方法,执行方法要么返回迭代中的下一项,要么引起一个Stopiteration异常,以终止迭代(只 ...
- Python(迭代器 生成器 装饰器 递归 斐波那契数列)
1.迭代器 迭代器是访问集合元素的一种方式.迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束.迭代器只能往前不会后退,不过这也没什么,因为人们很少在迭代途中往后退.另外,迭代器的一大优 ...
- Python基础-迭代器&生成器&装饰器
本节内容 迭代器&生成器 装饰器 Json & pickle 数据序列化 软件目录结构规范 作业:ATM项目开发 1.列表生成式,迭代器&生成器 列表生成式 我现在有个需求,看 ...
- 迭代器/生成器/装饰器 /Json & pickle 数据序列化
本节内容 迭代器&生成器 装饰器 Json & pickle 数据序列化 软件目录结构规范 作业:ATM项目开发 1.列表生成式,迭代器&生成器 列表生成式 孩子,我现在有个需 ...
- Day04 - Python 迭代器、装饰器、软件开发规范
1. 列表生成式 实现对列表中每个数值都加一 第一种,使用for循环,取列表中的值,值加一后,添加到一空列表中,并将新列表赋值给原列表 >>> a = [0, 1, 2, 3, 4, ...
- python学习笔记(5)--迭代器,生成器,装饰器,常用模块,序列化
生成器 在Python中,一边循环一边计算的机制,称为生成器:generator. 如: >>> g = (x * x for xin range(10)) >>> ...
- python中的迭代器&&生成器&&装饰器
迭代器iterator 迭代器是访问集合元素的一种方式.迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束. 迭代器只能往前不会后退,不过这也没什么,因为人们很少在迭代途中往后退.另外, ...
随机推荐
- 第08讲:Flink 窗口、时间和水印
Flink系列文章 第01讲:Flink 的应用场景和架构模型 第02讲:Flink 入门程序 WordCount 和 SQL 实现 第03讲:Flink 的编程模型与其他框架比较 第04讲:Flin ...
- uni微信小程序优化,打包后的import vue路径是可删除的
这次的优化我公司项目主包只减小了32kb,但是减小的不仅仅是主包,所有分包均在没有改动任何业务代码的情况下完成了压缩空间的优化. 主包分包压缩空间的优化都要视项目而定,32kb只是我公司的小程序项目. ...
- 计算机电子书 2020 CDNDrive 备份(预览版)
下载方式 pip install CDNDrive # 或 # pip install git+https://github.com/apachecn/CDNDrive cdrive download ...
- RocketMQ在Windows和Linux下的安装
windows下的RocketMQ的安装 鉴于Quick Start,选择单mater模式,环境简单: win10 64 jdk1.8 maven 3.5.4 Git rocketMQ安装版本 4.4 ...
- JavaWeb编码浅解
感谢原文作者:少年无形 原文链接:https://blog.csdn.net/dl18215164175/article/details/72512131?depth_1-utm_source=dis ...
- 深入epoll
转载请注明来源:https://www.cnblogs.com/hookjc/ 一. 介绍Epoll 是一种高效的管理socket的模型,相对于select和poll来说具有更高的效率和易用性.传统的 ...
- NSMutableArray基本概念
1.NSMutableArray介绍 什么是NSMutableArray NSMutableArray是NSArray的子类 NSArray是不可变的,一旦初始化完毕后,它里面的内容就永远是固定的, ...
- NSMutableString常用方法
1.NSMutableString常用方法 - (void)appendString:(NSString *)aString; 拼接aString到最后面 NSMutableString *strM ...
- Javascript疑问【长期更新】
1.插入 Javacript 的正确位置是? 答:<body> 部分和 <head> 部分均可. 2.外部脚本必须包含 <script> 标签吗? 答:外部脚本不能 ...
- python篇第6天【数据类型】
Python有五个标准的数据类型: Numbers(数字) String(字符串) List(列表) Tuple(元组) Dictionary(字典) Python数字 数字数据类型用于存储数值. 他 ...