這篇文章主要講解了“Python中的生成器、迭代器、動態(tài)新增屬性和方法怎么應(yīng)用”，文中的講解內(nèi)容簡單清晰，易于學(xué)習(xí)與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學(xué)習(xí)“Python中的生成器、迭代器、動態(tài)新增屬性和方法怎么應(yīng)用”吧！

成都創(chuàng)新互聯(lián)公司專注于福綿企業(yè)網(wǎng)站建設(shè),成都響應(yīng)式網(wǎng)站建設(shè)公司,商城網(wǎng)站開發(fā)。福綿網(wǎng)站建設(shè)公司,為福綿等地區(qū)提供建站服務(wù)。全流程按需求定制制作，專業(yè)設(shè)計，全程項目跟蹤，成都創(chuàng)新互聯(lián)公司專業(yè)和態(tài)度為您提供的服務(wù)

一、生成器

1、生成器定義

在Python中，一邊循環(huán)一邊計算的機制，稱為生成器：generator

2、生成器存在的意義

列表所有數(shù)據(jù)都在內(nèi)存中，如果有海量數(shù)據(jù)的話將會非常消耗內(nèi)存。

例如：僅需要訪問前面幾個元素，那后邊所有空間就浪費了

如果列表元素按照某種算法推算出來，就可以在循環(huán)的過程中不斷推算出后續(xù)的元素，這樣就不必創(chuàng)建完整的 list ，從而節(jié)省大量的空間。

3、創(chuàng)建生成器方式一（生成器表達式）

生成器表達式很簡單，只要把一個列表推導(dǎo)式的 [] 改成 () ，就創(chuàng)建了一個生成器(generator)：

L = [x * x for x in range(10)]  #推導(dǎo)式
print(L)
g = (x * x for x in range(10)) #加成括號就是生成器
print(g)
# at 0x1022ef630>
'''L是一個list，而g則是一個 generator'''

4. 創(chuàng)建生成器方式二（生成器函數(shù)）

1. 生成器函數(shù)

• 如果一個函數(shù)中包含了yield關(guān)鍵字，那么這個函數(shù)就不再是一個普通的函數(shù)，調(diào)用函數(shù)就是創(chuàng)建了一個生成器（generator）對象

• 生成器函數(shù)：利用關(guān)鍵字yield一次性返回一個結(jié)果，阻塞，重新開始

2. 生成器函數(shù)的工作原理

• 生成器函數(shù)返回一個迭代器，for循環(huán)對這個迭代器不斷調(diào)用 __next__() 函數(shù)，不斷運行到下一個 yield 語句，一次一次取得每一個返回值，直到?jīng)]有 yield 語句為止，最終引發(fā) StopIteration 異常

• yield 相當(dāng)于 return 返回一個值，并且記住這個返回的位置，下次迭代時，代碼從 yield 的下一條語句(不是下一行)開始執(zhí)行

• send() 和 next() 一樣，都能讓生成器往下走一步（下次遇到 yield 停），但 send() 能傳一個值，這個值作為 yield 表達式整體的結(jié)果

測試生成器工作原理（yield）

'''
如果一個函數(shù)中包含 yield 關(guān)鍵字，那么這個函數(shù)就不再是一個普通函數(shù)，
調(diào)用函數(shù)就是創(chuàng)建了一個生成器（generator）對象
生成器函數(shù)：其實就是利用關(guān)鍵字 yield 一次性返回一個結(jié)果，阻塞，重新開始
原理
1. 函數(shù)有了yield之后，調(diào)用它，就會生成一個生成器
2. 下次從下一個語句執(zhí)行，切記不是下一行（tmp = yield i）
3. return在生成器中代表生成器種植，直接報錯：StopIeratation
4. next方法作用：喚醒并繼續(xù)執(zhí)行
'''
def test():
    print("start")
    i = 0
    while i<3:
        '''yield i #第一次執(zhí)行，此處掛起；同時將i的值返回到i
                   #第二次執(zhí)行，從掛起的地方往下執(zhí)行'''
        temp = yield i #下次迭代時，代碼從`yield`的下一條語句(不是下一行)開始執(zhí)行
        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
'''

start
0
temp:None
1
temp:None
2
temp:None
end
Traceback (most recent call last):
 in 
    print(a.__next__())# 拋出異常：StopIteration
StopIteration: done
'''

測試生成器工作原理（send）

'''
send的作用是喚醒并繼續(xù)執(zhí)行，發(fā)送一個信息到生成器內(nèi)部
'''
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是內(nèi)置函數(shù)
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
'''

5. 總結(jié)

1. 什么是生成器

生成器僅僅保存了一套生成數(shù)值的算法，并且沒有讓這個算法現(xiàn)在就開始執(zhí)行，而是我什么時候調(diào)用它，它什么時候開始計算一個新的值，并給你返回

2. 生成器特點

• 生成器函數(shù)生成一系列結(jié)果。通過 yield 關(guān)鍵字返回一個值后，還能從其退出的地方繼續(xù)運行，因此可以隨時產(chǎn)生一系列的值。

• 生成器和迭代是密切相關(guān)的，迭代器都有一個 __next__() 成員方法，這個方法要么返回迭代的下一項，要么引起異常結(jié)束迭代。

• 生成器是一個特殊的程序，可以被用作控制循環(huán)的迭代行為，

二、迭代器

1、概念

• 迭代是Python最強大的功能之一，是訪問集合元素的一種方式

• 迭代器是一個可以記住遍歷的位置的對象

• 迭代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結(jié)束

• 迭代器只能往前不會后退

• 迭代器有兩個基本的方法：iter()和netx()

2、可迭代對象和迭代器區(qū)別

• 一個實現(xiàn)了 iter 方法的對象，稱為 "可迭代對象 Ieratable"

• 一個實現(xiàn)了 next 方法并且是可迭代的對象，稱為"迭代器" Iterator 即：實現(xiàn)了 iter 方法和 next 方法的對象就是迭代器

！生成器都是 Iterator對象，但 list、 dict、str雖然都是 Iterable（可迭代對象）， 卻不是Iterator（迭代器）

'''
生成器一定是迭代器
可迭代對象不一定是迭代器，使用iter([])封裝后可轉(zhuǎn)為迭代器
'''
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)
"""
執(zhí)行結(jié)果：
False
True
"""

'''list、dict、str 等 Iterable 變成 Iterator，可以使用 iter() 函數(shù)：'''
b = isinstance(iter([]), Iterator)
print(b)
b = isinstance(iter('花非人陌'), Iterator)
print(b)
 
"""
執(zhí)行結(jié)果：
True
True
"""

Python的 Iterator對象表示的是一個數(shù)據(jù)流。可以把這個數(shù)據(jù)看做是一個有序序列，但我們卻不能提前知道序列的長度，只能不斷通過 next()函數(shù)實現(xiàn)按需計算下一個數(shù)據(jù)，所以 Iterator的計算是惰性的，只有在需要返回下一個數(shù)據(jù)時它才會計算。

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

3、for循環(huán)本質(zhì)

#Python3 的 for 循環(huán)本質(zhì)就是通過不斷調(diào)用 next() 函數(shù)實現(xiàn)的。
 
for x in [1,2,3,4,5]:
    pass
 
'''本質(zhì)是：'''
#首先獲得Iterator對象：
it = iter([1,2,3,4,5])
#循環(huán)
while True:
    try:
        # 獲得下一個值：
        x = next(it)
    except StopIteration:
        # 遇到StopIteration 就退出循環(huán)
        break

4、創(chuàng)建一個迭代器

一個類作為一個迭代器使用需要在類中實現(xiàn)兩個方法 __iter__()與 __next__()

• __iter__()方法返回一個特殊的迭代器對象，這個迭代器對象實現(xiàn)了 __next__()方法并通過StopIteration 異常標(biāo)識迭代的完成

• __next__()方法會返回下一個迭代器對象

#創(chuàng)建一個依次返回10,20,30,...這樣數(shù)字的迭代器
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))
"""
執(zhí)行結(jié)果：
10
20
30
Traceback (most recent call last):
    raise StopIteration
StopIteration
"""
"""
程序解析：
在這段代碼中，MyNumbers 類定義了一個迭代器。該迭代器的作用是生成一系列數(shù)字，從 10 開始，每次增加 10，直到 40，然后停止。
在程序中，通過 iter(myclass) 方法獲取 MyNumbers 類的迭代器對象 myiter，然后調(diào)用 next(myiter) 方法獲取下一個數(shù)字。
在第一次調(diào)用 next(myiter) 方法時，迭代器會執(zhí)行 __next__() 方法，返回 self.num 的值 10，然后將 self.num 的值增加 10，變?yōu)?nbsp;20。
在第二次、第三次調(diào)用 next(myiter) 方法時，迭代器會再次執(zhí)行 __next__() 方法，返回 20 和 30，然后將 self.num 的值分別增加 10，變?yōu)?nbsp;30 和 40。
在第四次調(diào)用 next(myiter) 方法時，迭代器再次執(zhí)行 __next__() 方法，發(fā)現(xiàn) self.num 的值已經(jīng)大于等于 40，于是拋出 StopIteration 異常，表示迭代已經(jīng)結(jié)束。
"""

三、動態(tài)添加屬性和方法

1、動態(tài)編程語言定義

指在運行時可以改變其結(jié)構(gòu)的語言：例如新的函數(shù)、對象、甚至代碼可以被引進，

已有的函數(shù)可以被刪除或是其他結(jié)構(gòu)上的變化

2、運行過程中給對象添加屬性和方法

#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)
#動態(tài)給對象添加屬性和方法
p1.score = 100
print(p1.score) #加給p1的只能p1用,對象的也是一樣
 
#動態(tài)給對象添加方法
def run(self):
    print(f"{self.name}, running...")
p1.run = types.MethodType(run, p1)
#而types.MethodType(run,p1)則是告訴解釋器，self指的就是p1
p1.run()
"""
執(zhí)行結(jié)果：
100
zhangsan, running...
"""

3、給類動態(tài)添加靜態(tài)方法以及類方法

#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 #動態(tài)給對象靜態(tài)方法
print(Person.score)
 
@classmethod
def clsfunc(cls):
    print('--- cls method ---')
Person.clsfunc = clsfunc    #動態(tài)增加類方法
Person.clsfunc()

四、限制動態(tài)添加

1、slots

1. __slots__的作用

• __slots__ 對動態(tài)添加成員變量、成員方法有限制。對動態(tài)添加類屬性、類方法沒有限制

• __slots__ 只對本類有限制，不限制子類

2. 對動態(tài)添加成員變量、成員方法有限制

'''
MyClass 類使用 __slots__ 屬性限制了實例對象的屬性，只允許動態(tài)添加 x 屬性。
因此，obj.x = 1 可以成功，但是 obj.y = 2 會拋出 AttributeError 異常
'''
class MyClass:
    __slots__ = ['x']
 
obj = MyClass()
obj.x = 1  # 可以動態(tài)添加 x 屬性
obj.y = 2  # 報錯，__slots__ 限制了不能動態(tài)添加 y 屬性
"""
執(zhí)行結(jié)果：
AttributeError: 'MyClass' object has no attribute 'y'
"""

3. 對動態(tài)添加類屬性、類方法沒有限制

class MyClass:
    __slots__ = ['x']
    classattr = 1
 
    @classmethod
    def myclassmethod(cls):
        print("class method")
 
 
MyClass.newclassattr = 2  # 可以動態(tài)添加類屬性
print(MyClass.newclassattr)
MyClass.mynewclassmethod = lambda cls: print("new class method")  # 可以動態(tài)添加類方法
MyClass.mynewclassmethod(MyClass)   #傳遞類本身作為參數(shù)
obj = MyClass()
obj.x  = 3    # 可以動態(tài)添加實例屬性
print(obj.x)  # 可以動態(tài)添加 x 屬性
"""
執(zhí)行結(jié)果：
2
new class method
3
"""

感謝各位的閱讀，以上就是“Python中的生成器、迭代器、動態(tài)新增屬性和方法怎么應(yīng)用”的內(nèi)容了，經(jīng)過本文的學(xué)習(xí)后，相信大家對Python中的生成器、迭代器、動態(tài)新增屬性和方法怎么應(yīng)用這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是創(chuàng)新互聯(lián)，小編將為大家推送更多相關(guān)知識點的文章，歡迎關(guān)注！