Dalam Python, mekanisme yang mengira semasa gelung dipanggil penjana
Semua data dalam senarai berada dalam ingatan Jika terdapat sejumlah besar data, ia akan menggunakan banyak memori.
Contohnya: jika anda hanya perlu mengakses beberapa elemen pertama, maka semua ruang berikutnya akan terbuang
Jika elemen senarai dikira mengikut algoritma tertentu, anda boleh mengira secara berterusan elemen seterusnya semasa gelung, jadi anda tidak perlu membuat senarai lengkap, sekali gus menjimatkan banyak ruang.
Ungkapan penjana adalah sangat mudah. Cuma tukar [] dalam pemahaman senarai kepada () untuk mencipta Penjana:
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'''
Jika sesuatu fungsi mengandungi kata kunci hasil, maka fungsi bukan lagi fungsi biasa. Memanggil fungsi mencipta objek penjana
Fungsi penjana: Gunakan hasil kata kunci untuk mengembalikan hasil sekaligus, sekat dan mulakan semula
< . untuk menjalankan ke pernyataan hasil seterusnya, mendapatkan setiap nilai pulangan satu demi satu sehingga tiada pernyataan hasil, dan akhirnya mencetuskan pengecualian StopIterationHantar(), seperti seterusnya(), boleh buat penjana pergi selangkah lebih jauh (berhenti lain kali ia menemui hasil), tetapi send() boleh lulus nilai, yang digunakan sebagai hasil keseluruhan ungkapan hasil
Ringkasan
'''
如果一个函数中包含 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
'''1. Apakah itu penjanaPenjana hanya menyimpan satu set algoritma untuk menjana nilai, dan tidak membenarkan algoritma mula dilaksanakan sekarang, tetapi Apabila saya memanggilnya, bilakah ia mula mengira nilai baharu dan mengembalikan anda
'''
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( )
2. Perbezaan antara objek boleh lelar dan lelaran
Objek yang melaksanakan kaedah iter dipanggil Objek boleh lelar"<🎜. >
Iterator
objek, tetapidictIterator, str semuanya Boleh Diulang (Iterable objek), tetapi bukan Iterator (Iterator)
Python's
''' 生成器一定是迭代器 可迭代对象不一定是迭代器，使用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 """
. Data ini boleh dianggap sebagai urutan tersusun, tetapi kami tidak dapat mengetahui panjang jujukan terlebih dahulu Kami hanya boleh mengira data seterusnya atas permintaan melalui fungsi 
next()
Iterator <. Pengiraan 🎜> malas, ia hanya akan dikira apabila data seterusnya perlu dikembalikan.__next__()Jadi, penjana mestilah seorang lelaran. 3. Intipati untuk gelung4. Mencipta lelaran
Kelas yang digunakan sebagai lelaran perlu melaksanakan dua kaedah dalam kelas.__iter__()
dan
#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__() kaedah mengembalikan objek iterator khas, ini The iterator objek melaksanakan kaedah __next__() dan mengenal pasti penyiapan lelaran melalui pengecualian 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
"""Atas ialah kandungan terperinci Penjelasan terperinci tentang penjana, iterator, atribut dan kaedah yang ditambah secara dinamik dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
