Python教程

Python迭代器,生成器,装饰器

本文主要是介绍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)
# 还记得前文讲的引用吗?我们还可以换种写法达到跟

	
这篇关于Python迭代器,生成器,装饰器的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!