生成器、迭代器、动态性

生成器

生成器定义

在Python中，一边循环一边计算的机制，称为生成器：generator

为什么要有生成器

列表所有数据都在内存中，如果有海量数据的话将会非常耗内存。

如：仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

如果列表元素按照某种算法推算出来，那我们就可以在循环的过程中不断推算出后续的元素，这样就不必创建完整的list，从而节省大量的空间。

简单说：

• 时间换空间！想要得到庞大的数据，又想让它占用空间少，那就用生成器！
• 延迟计算！需要的时候，再计算出数据！

创建生成器的方式一(生成器表达式)

生成器表达式很简单，只要把一个列表推导式的[]改成()，就创建了一个生成器(generator)：

L = [x * x for x in range(10)]
print(L)
g = (x * x for x in range(10))
print(g)
# at 0x1022ef630>

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

生成器函数_yield的用法

创建生成器的方式二(生成器函数)

生成器函数：

• 如果一个函数中包含yield关键字，那么这个函数就不再是一个普通函数，调用函数就是创建了一个生成器（generator）对象。
• 生成器函数：其实就是利用关键字yield一次性返回一个结果，阻塞，重新开始

生成器函数的工作原理

原理是这样的：

1. 生成器函数返回一个迭代器，for循环对这个迭代器不断调用__next__()函数，不断运行到下一个yield语句，一次一次取得每一个返回值，直到没有yield语句为止，最终引发StopIteration异常。
2. yield相当于return 返回一个值，并且记住这个返回的位置，下次迭代时，代码从yield的下一条语句(不是下一行)开始执行。
3. send() 和next()一样，都能让生成器继续往下走一步（下次遇到yield停），但send()能传一个值，这个值作为yield表达式整体的结果

生成器推导式底层原理也是这样的。

【示例】测试生成器工作原理(yield)

#coding=utf-8
"""
1. 函数有了yield之后，调用它，就会生成一个生成器
2. yield作用：程序挂起，返回相应的值。下次从下一个语句开始执行。
3. return在生成器中代表生成器终止，直接报错：StopIeratation
4. next方法作用：唤醒并继续执行
"""
def test():
  print("start")
  i=0
  while i<3:
    temp = yield i #下次迭代时，代码从`yield`的下一条语句(不是下一行)开始执行
    print(f"temp:{temp}")
    i += 1
  print("end")
  return "done"
if __name__ == '__main__':
  a = test()
  print(type(a))
  print(a.__next__())
  print(a.__next__())
  print(a.__next__())  # next(a) 一样
  print(a.__next__())  # 抛出异常：StopIteration
​

生成器函数_send的用法

【示例】测试生成器工作原理(send)

# send的作用是唤醒并继续执行，发送一个信息到生成器内部
def foo():
  print("start")
  i = 0
  while i<2:
    temp = yield i
    print(f"temp:{temp}")
    i=i+1
  print("end")
​
g = foo()
print(next(g))
print("*"*20)
print(g.send(100))
print(next(g))

总结

• 什么是生成器？

  生成器仅仅保存了一套生成数值的算法，并且没有让这个算法现在就开始执行，而是我什么时候调它，它什么时候开始计算一个新的值，并给你返回。

• 生成器特点：

  1. 生成器函数生成一系列结果。通过yield关键字返回一个值后，还能从其退出的地方继续运行，因此可以随时间产生一系列的值。
  2. 生成器和迭代是密切相关的，迭代器都有一个__next__()成员方法，这个方法要么返回迭代的下一项，要么引起异常结束迭代。
  3. 生成器是一个特殊的程序，可以被用作控制循环的迭代行为，python中生成器是迭代器的一种，使用yield返回值函数，每次调用yield会暂停，而可以使用next()函数和send()函数恢复生成器。
  4. 生成器看起来像是一个函数，但是表现得却像是迭代器

  迭代器的概念_for循环的本质

概念

1. 迭代是Python最强大的功能之一，是访问集合元素的一种方式。
2. 迭代器是一个可以记住遍历的位置的对象。
3. 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
4. 迭代器只能往前不会后退。
5. 迭代器有两个基本的方法：iter() 和 next()

可迭代对象和迭代器区别

1. 一个实现了iter方法的对象，称为"可迭代对象Ieratable"

2. 一个实现next方法并且是可迭代的对象，称为"迭代器Iterator"

   即：实现了iter方法和next方法的对象就是迭代器。

⚠️生成器都是Iterator对象，但list、dict、str虽然是Iterable（可迭代对象），却不是Iterator（迭代器）。

#python3.6之前不加.abc，之后的加
from collections.abc import Iterator
from collections.abc import Iterable
a = isinstance([], Iterable)
a = isinstance([], Iterator)
print(a)

list、dict、str等Iterable变成Iterator, 可以使用iter()函数：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

为什么list、dict、str等数据类型不是Iterator？

Python的Iterator对象表示的是一个数据流。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

所以，生成器一定是迭代器。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

for循环的本质

Python3的for循环本质上就是通过不断调用next()函数实现的。

for x in [1, 2, 3, 4, 5]:
 pass

本质是：

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
 try:
   # 获得下一个值:
   x = next(it)
 except StopIteration:
   # 遇到StopIteration就退出循环
   break

迭代器_手动创建一个迭代器

创建一个迭代器

一个类作为一个迭代器使用需要在类中实现两个方法__iter__() 与__next__()

1. __iter__()方法返回一个特殊的迭代器对象， 这个迭代器对象实现了__next__() 方法并通过 StopIteration 异常标识迭代的完成。
2. __next__() 方法会返回下一个迭代器对象。

【示例】创建一个依次返回10,20,30,...这样数字的迭代器

class MyNumbers:
  def __iter__(self):
    self.num = 10
    return self
​
  def __next__(self):
    if self.num<40:
      x = self.num
      self.num += 10
      return x
    else:
      raise StopIteration
​
myclass = MyNumbers()
myiter = iter(myclass)
​
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

动态语言特性_动态给对象添加属性和方法

动态编程语言是高级程序设计语言的一个类别，在计算机科学领域已被广泛应用。

它是指在运行时可以改变其结构的语言 ：例如新的函数、 对象、甚至代码可以被引进， 已有的函数可以被删除或是其他结构上的变化。

运行过程中给对象、类添加属性和方法

#coding=utf-8
import types
​
class Person():
  def __init__(self,name,age):
    self.name = name
    self.age = age
​
p1 = Person("zhangsan",20)
p2 = Person("lisi",30)
​
#动态给对象添加属性和方法
p1.score = 100
print(p1.score)
​
def run(self):
  print(f"{self.name},running...")
#动态的对象添加方法
p1.run = types.MethodType(run,p1)
p1.run()

types.MethonType的使用

p1.run = types.MethodType(run,p1)
# 即使换成
xxx = types.MethodType(run,p1)
# xxx()调用一样还用
# 因为之前提示缺少参数，主要是不知道self到底是谁，
# 而types.MethodType(run,p1)则是告诉解释器，self指的就是p1

动态语言特性_动态给类添加静态方法和类方法

给类动态添加静态方法以及类方法

@staticmethod
def staticfunc():
  print("---static method---")
Person.staticfunc = staticfunc
Person.staticfunc()
​
@classmethod
def clsfunc(cls):
  print('---cls method---')
Person.clsfunc = clsfunc
Person.clsfunc()

动态语言特性_slots限制成员属性和方法

__slots__的作用

1. __slots__对动态添加成员变量、成员方法有限制。对动态添加类属性、类方法没有限制。
2. __slots__只对本类有限制，不限制子类

class Person():
  __slots__ = {"name","age"}
  def __init__(self,name,age):
    self.name = name
    self.age = age
  def eat(self):
    print("人是铁饭是钢，要吃！")
​
if __name__ == '__main__':
  p1 = Person("gaoqi",18)
#   p1.gender = "man" #AttributeError: 'Person' object has no attribute 'gender'