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)

# 还记得前文讲的引用吗？我们还可以换种写法达到跟

来源：https://www.cnblogs.com/gide/p/15976314.html

本站部分图文来源于网络，如有侵权请联系删除。