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迭代器,生成器,装饰器

迭代器

生成器

装饰器

最新文章

热门文章