在Python中，一邊循環一邊計算的機制，稱為生成器：generator
列表所有資料都在記憶體中，如果有海量資料的話將會非常消耗記憶體。
例如：只需要存取前面幾個元素，那後邊所有空間就浪費了
如果列表元素按照某種演算法推算出來，就可以在循環的過程中不斷推算出後續的元素，這樣就不必創建完整的list ，從而節省大量的空間。
生成器表達式很簡單，只要把一個列表推導式的[] 改成() ，就創建了一個生成器(generator)：
L = [x * x for x in range(10)] #推导式 print(L) g = (x * x for x in range(10)) #加成括号就是生成器 print(g) #<generator object <genexpr> at 0x1022ef630> '''L是一个list，而g则是一个 generator'''
如果一個函數中包含了yield關鍵字，那麼這個函數就不再是一個普通的函數，呼叫函數就是創建了一個生成器（generator）物件
生成器函數：利用關鍵字yield一次回傳一個結果，阻塞，重新開始
測試生成器工作原理（yield）
'''
如果一个函数中包含 yield 关键字，那么这个函数就不再是一个普通函数，
调用函数就是创建了一个生成器（generator）对象
生成器函数：其实就是利用关键字 yield 一次性返回一个结果，阻塞，重新开始
原理
1. 函数有了yield之后，调用它，就会生成一个生成器
2. 下次从下一个语句执行，切记不是下一行（tmp = yield i）
3. return在生成器中代表生成器种植，直接报错：StopIeratation
4. next方法作用：唤醒并继续执行
'''
def test():
print("start")
i = 0
while i<3:
'''yield i #第一次执行，此处挂起；同时将i的值返回到i
#第二次执行，从挂起的地方往下执行'''
temp = yield i #下次迭代时，代码从`yield`的下一条语句(不是下一行)开始执行
print(f"i:{i}")
i += 1
print("end")
return "done"
if __name__ == '__main__':
a = test()
print(type(a))
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())# 抛出异常：StopIteration
'''
<class 'generator'>
start
0
temp:None
1
temp:None
2
temp:None
end
Traceback (most recent call last):
in <module>
print(a.__next__())# 抛出异常：StopIteration
StopIteration: done
'''測試生成器工作原理（send）
'''
send的作用是唤醒并继续执行，发送一个信息到生成器内部
'''
def foo():
print("start")
i = 0
while i < 2:
temp = yield i
print(f"temp:{temp}")
i += 1
print("end")
g = foo()
print(next(g)) #等同g.__next__(),next是内置函数
print("*"*20)
print(g.send(100))
print(next(g))
# for a in g:#g所返回的值是yield处的i
# print(a)
'''
start
0
********************
temp:100
1
temp:None
end
Traceback (most recent call last):
print(next(g))
StopIteration
'''和netx( )
！生成器都是 Iterator對象，但 list 、 dict 、str 雖然都是 Iterable （可迭代物件），卻不是Iterator（迭代器）
''' 生成器一定是迭代器 可迭代对象不一定是迭代器，使用iter([])封装后可转为迭代器 ''' from collections.abc import Iterator from collections.abc import Iterable a = isinstance([], Iterator) #list、dict、str虽然是Iterable（可迭代对象），却不是Iterator（迭代器） print(a) a = isinstance([], Iterable) #可迭代对象 print(a) """ 执行结果： False True """登入後複製'''list、dict、str 等 Iterable 变成 Iterator，可以使用 iter() 函数：''' b = isinstance(iter([]), Iterator) print(b) b = isinstance(iter('花非人陌'), Iterator) print(b) """ 执行结果： True True """登入後複製
Iterator物件表示的是一個資料流。可以把這個數據看做是一個有序序列，但我們卻不能提前知道序列的長度，只能不斷透過 next() 函數實現按需計算下一個數據，所以Iterator 的計算是惰性的，只有在需要傳回下一個資料時它才會計算。 所以，生成器一定是迭代器。
3、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與 __next__()
方法傳回一個特殊的迭代器對象，這個迭代器物件實現了 __next__() 方法並透過StopIteration 異常標識迭代的完成
__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))
"""
执行结果：
10
20
30
Traceback (most recent call last):
raise StopIteration
StopIteration
"""
"""
程序解析：
在这段代码中，MyNumbers 类定义了一个迭代器。该迭代器的作用是生成一系列数字，从 10 开始，每次增加 10，直到 40，然后停止。
在程序中，通过 iter(myclass) 方法获取 MyNumbers 类的迭代器对象 myiter，然后调用 next(myiter) 方法获取下一个数字。
在第一次调用 next(myiter) 方法时，迭代器会执行 __next__() 方法，返回 self.num 的值 10，然后将 self.num 的值增加 10，变为 20。
在第二次、第三次调用 next(myiter) 方法时，迭代器会再次执行 __next__() 方法，返回 20 和 30，然后将 self.num 的值分别增加 10，变为 30 和 40。
在第四次调用 next(myiter) 方法时，迭代器再次执行 __next__() 方法，发现 self.num 的值已经大于等于 40，于是抛出 StopIteration 异常，表示迭代已经结束。
"""指在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，
已有的函数可以被删除或是其他结构上的变化
#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", 18)
#动态给对象添加属性和方法
p1.score = 100
print(p1.score) #加给p1的只能p1用,对象的也是一样
#动态给对象添加方法
def run(self):
print(f"{self.name}, running...")
p1.run = types.MethodType(run, p1)
#而types.MethodType(run,p1)则是告诉解释器，self指的就是p1
p1.run()
"""
执行结果：
100
zhangsan, running...
"""#encoding=utf-8
class Person():
__slots__ = {"name", "age"}
def __init__(self, name, age):
self.name = name
self.age = age
@staticmethod
def staticfunc():
print("--- static method ---")
Person.staticfunc = staticfunc
Person.staticfunc()
Person.score = 1000 #动态给对象静态方法
print(Person.score)
@classmethod
def clsfunc(cls):
print('--- cls method ---')
Person.clsfunc = clsfunc #动态增加类方法
Person.clsfunc()__slots__ 对动态添加成员变量、成员方法有限制。对动态添加类属性、类方法没有限制
__slots__ 只对本类有限制，不限制子类
'''
MyClass 类使用 __slots__ 属性限制了实例对象的属性，只允许动态添加 x 属性。
因此，obj.x = 1 可以成功，但是 obj.y = 2 会抛出 AttributeError 异常
'''
class MyClass:
__slots__ = ['x']
obj = MyClass()
obj.x = 1 # 可以动态添加 x 属性
obj.y = 2 # 报错，__slots__ 限制了不能动态添加 y 属性
"""
执行结果：
AttributeError: 'MyClass' object has no attribute 'y'
"""class MyClass:
__slots__ = ['x']
classattr = 1
@classmethod
def myclassmethod(cls):
print("class method")
MyClass.newclassattr = 2 # 可以动态添加类属性
print(MyClass.newclassattr)
MyClass.mynewclassmethod = lambda cls: print("new class method") # 可以动态添加类方法
MyClass.mynewclassmethod(MyClass) #传递类本身作为参数
obj = MyClass()
obj.x = 3 # 可以动态添加实例属性
print(obj.x) # 可以动态添加 x 属性
"""
执行结果：
2
new class method
3
"""以上是Python中的生成器、迭代器、動態新增屬性和方法詳解的詳細內容。更多資訊請關注PHP中文網其他相關文章！
