1. 類的繼承

在 Python 3 中，類的繼承是通過定義一個新的類，該類繼承一個或多個已有的類，并在新類中添加自己的方法和屬性來實現(xiàn)的。
在 Python 中，每個類都是一個對象，都有一個基類（即 object 類），該類提供了一些默認(rèn)的屬性和方法。要實現(xiàn)類的繼承，可以通過在定義類時指定其父類來實現(xiàn)，例如：

class Parent:
    pass

class Child(Parent):
    pass

在這個例子中，Child 類繼承了 Parent 類，即 Parent 類是 Child 類的父類。這意味著 Child 類將繼承 Parent 類中的所有屬性和方法，并且可以添加自己的屬性和方法。在繼承過程中，如果父類中定義的屬性或方法與子類中的同名，則子類中的屬性或方法將覆蓋父類中的同名屬性或方法。

在 Python 中，類的繼承實現(xiàn)是通過修改類的 bases 屬性來完成的。該屬性是一個元組，包含類的父類。當(dāng)類被創(chuàng)建時，Python 解釋器會自動設(shè)置 bases 屬性來實現(xiàn)繼承。

類的多重繼承如何實現(xiàn)？

類的多重繼承可以通過在定義類時指定多個父類來實現(xiàn)，例如：

class Parent1:
    pass

class Parent2:
    pass

class Child(Parent1, Parent2):
    pass

在這個例子中，Child 類繼承了 Parent1 和 Parent2 兩個類，即 Parent1 和 Parent2 是 Child 類的父類。在多重繼承中，如果父類之間存在同名的屬性或方法，子類可以通過訪問父類的特定屬性或方法來進行區(qū)分。

如何避免繼承鏈過長帶來的性能問題？

在類的繼承過程中，如果繼承鏈過長，可能會導(dǎo)致性能問題。為了避免這種問題，可以采取以下措施：

• 盡量避免多重繼承，特別是繼承層數(shù)較深的情況。
• 將一些共用的屬性和方法提取出來，封裝成獨立的類或模塊，讓其他類進行組合或委托調(diào)用，而非繼承調(diào)用。
• 使用 Mixin 模式來實現(xiàn)代碼重用，這可以有效地減少繼承鏈的長度。

類的繼承中，MRO算法的實現(xiàn)原理是什么？

在 Python 中，類的多重繼承可能會導(dǎo)致繼承沖突的問題，即子類繼承的多個父類中存在同名的屬性或方法，這就需要使用 Method Resolution Order（MRO）算法來解決。MRO 算法是 Python 中用于確定多重繼承時方法解析順序的算法。MRO 算法通過一種特定的順序來確定方法的調(diào)用順序，以確保繼承關(guān)系中的方法調(diào)用順序是合理的。MRO 算法使用 C3 線性化算法來計算方法解析順序。

在 Python 中，可以通過 mro 屬性來查看類的方法解析順序。該屬性是一個元組，包含了按照 MRO 算法計算出來的方法解析順序。在方法調(diào)用時，Python 解釋器會按照 mro 屬性中的順序依次查找對應(yīng)的方法。

MRO 算法的實現(xiàn)原理涉及到 Python 的對象模型，其中主要涉及到以下幾個概念：

• 繼承圖：指繼承關(guān)系中所有的類所組成的有向無環(huán)圖。
• 子類：指繼承圖中的任何一個子節(jié)點。
• 祖先類：指繼承圖中任何一個子類的所有父節(jié)點，包括父類、祖父類等。
• 所有祖先類的合集：指繼承圖中任何一個子類的所有祖先類所組成的集合，包括父類、祖父類等。

MRO 算法的計算過程如下：

1. 創(chuàng)建一個空列表，作為最終方法解析順序的結(jié)果。
2. 將當(dāng)前類加入到列表中，并將其所有父類的 mro 屬性按照深度優(yōu)先的方式遞歸加入到列表中。
3. 對列表中的每個類進行去重操作，按照它們在繼承圖中的出現(xiàn)順序排序，形成最終的方法解析順序。

MRO 算法的實現(xiàn)原理涉及到多個源代碼文件，其中包括 object.c、typeobject.c 等文件。

如何使用 super() 函數(shù)實現(xiàn)父類方法的調(diào)用？

在 Python 中，子類可以通過 super() 函數(shù)調(diào)用父類的方法，這樣可以避免直接引用父類名稱的硬編碼問題，并且可以保證正確的 MRO 算法調(diào)用順序。

super() 函數(shù)可以接受兩個參數(shù)，第一個參數(shù)是子類自身，第二個參數(shù)是子類實例。調(diào)用 super() 函數(shù)返回一個 super 對象，該對象包含了子類的 MRO 算法所定義的下一個類。通過該對象可以調(diào)用父類的方法。

下面是一個例子：

class Parent:
    def __init__(self, name):
        self.name = name

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age

在這個例子中，Child 類繼承了 Parent 類，并重寫了 init() 方法。在子類的 init() 方法中，通過 super() 函數(shù)調(diào)用了父類的 init() 方法，以初始化從父類繼承而來的屬性 name，同時還添加了子類自身的屬性 age。

在類的繼承中，如何使用 Mixin 模式來實現(xiàn)代碼重用？

Mixin 模式是一種用于代碼重用的設(shè)計模式。在 Python 中，Mixin 可以通過多重繼承來實現(xiàn)。Mixin 類通常不會包含構(gòu)造函數(shù)，也不會被實例化，而是用于提供某些功能的類。

Mixin 類可以定義一些特定的方法，這些方法可以被多個類所繼承。如果某個類需要使用這些方法，只需要簡單地繼承相應(yīng)的 Mixin 類即可。

下面是一個例子：

class LoggingMixin:
    def log(self, message):
        print(f"[{type(self).__name__}] {message}")

class Car:
    def __init__(self, color, brand):
        self.color = color
        self.brand = brand

class ElectricCar(Car, LoggingMixin):
    def __init__(self, color, brand, battery_capacity):
        super().__init__(color, brand)
        self.battery_capacity = battery_capacity

    def charge(self):
        self.log("Charging...")

在這個例子中，LoggingMixin 是一個 Mixin 類，它定義了一個 log() 方法，用于輸出日志。Car 類是一個基類，ElectricCar 類繼承了 Car 類和 LoggingMixin 類，并重寫了 init() 方法。ElectricCar 類也添加了自己的方法 charge()，該方法通過調(diào)用 log() 方法來輸出日志。

在 ElectricCar 類中，由于 LoggingMixin 類在 Car 類之后繼承，因此在 MRO 算法中，會先調(diào)用 Car 類的方法，然后再調(diào)用 LoggingMixin 類的方法。這樣可以確保 ElectricCar 類的方法調(diào)用順序是正確的。

使用 Mixin 模式可以避免代碼重復(fù)，并且可以提高代碼的可讀性和可維護性。但是，在使用 Mixin 模式時需要注意一些問題，比如 Mixin 類的命名應(yīng)該清晰明確，避免與其他類沖突，同時需要確保 Mixin 類不會破壞類的封裝性。

2. 元類（Metaclass）

Python 3 中的元類和 Java 中的類似嗎？有何異同？

Python 3 中的元類和 Java 中的類似，都是用于控制類的創(chuàng)建和行為的機制。不同之處在于，Python 中的元類更加靈活和強大，允許在類定義時動態(tài)地修改類的屬性和行為。Java 中的類定義是靜態(tài)的，無法在類定義時進行動態(tài)修改。

Python 3 中如何自定義元類？

在 Python 3 中，可以通過繼承 type 類來自定義元類。自定義元類需要實現(xiàn) new 方法，并在其中進行對類的創(chuàng)建和修改。

如何使用元類來實現(xiàn)某些特殊功能，比如單例模式或緩存？

以下示例展示了如何使用元類來實現(xiàn)單例模式：

class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class MyClass(metaclass=Singleton):
    def __init__(self, value):
        self.value = value

obj1 = MyClass(1)
obj2 = MyClass(2)
print(obj1.value, obj2.value)  # Output: 1 1
print(obj1 is obj2)  # Output: True

這個示例中，定義了一個名為 Singleton 的元類，它重寫了 call 方法，使得每次調(diào)用該類時都返回同一個實例。然后通過將 MyClass 的元類指定為 Singleton，實現(xiàn)了 MyClass 的單例模式。

元類的實現(xiàn)原理是，當(dāng)定義一個類時，Python 解釋器會檢查該類是否指定了元類。如果指定了元類，則 Python 解釋器會將類的定義傳遞給元類，由元類來創(chuàng)建類對象。元類可以動態(tài)地修改類的屬性和方法，然后將修改后的類對象返回給 Python 解釋器。

要在元類中修改類的屬性或方法，可以在 new 方法中修改類的屬性和方法。例如，以下示例展示了如何使用元類來為類自動添加一個類變量：

class MyMeta(type):
    def __new__(cls, name, bases, attrs):
        attrs['counter'] = 0
        return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=MyMeta):
    pass

print(MyClass.counter)  # Output: 0

在這個示例中，定義了一個名為 MyMeta 的元類，它重寫了 new 方法，在其中為類動態(tài)地添加了一個名為 counter 的類變量。然后通過將 MyClass 的元類指定為 MyMeta，實現(xiàn)了為類自動添加類變量的功能。
除了在 new 方法中動態(tài)修改類的屬性和方法外，元類還可以通過重寫其他特殊方法來控制類的行為。例如，以下示例展示了如何使用元類來實現(xiàn)一個簡單的緩存功能：

class CacheMeta(type):
    _cache = {}

    def __call__(cls, *args, **kwargs):
        key = (cls, args, frozenset(kwargs.items()))
        if key not in cls._cache:
            cls._cache[key] = super().__call__(*args, **kwargs)
        return cls._cache[key]

class MyClass(metaclass=CacheMeta):
    def __init__(self, value):
        self.value = value

obj1 = MyClass(1)
obj2 = MyClass(1)
print(obj1 is obj2)  # Output: True

obj3 = MyClass(2)
print(obj1 is obj3)  # Output: False

在這個示例中，定義了一個名為 CacheMeta 的元類，它重寫了 call 方法，使得每次調(diào)用類時都會檢查緩存中是否已經(jīng)存在相同的實例。如果存在，則直接返回緩存中的實例，否則創(chuàng)建一個新的實例，并將其加入緩存中。然后通過將 MyClass 的元類指定為 CacheMeta，實現(xiàn)了為類自動添加緩存功能。

元類的實現(xiàn)原理是什么？

在 Python 中，類是一等公民，也就是說，類本身也是一個對象，可以動態(tài)地創(chuàng)建、修改和銷毀。元類就是用來控制類創(chuàng)建過程的對象，它本身也是一個類。當(dāng)我們使用 class 關(guān)鍵字定義一個新的類時，實際上是在調(diào)用元類的 new 和 init 方法來創(chuàng)建和初始化一個新的類對象。

元類的實現(xiàn)原理可以概括為以下幾個步驟：

• 創(chuàng)建一個新的類對象，作為元類的實例。這個類對象通常會繼承自 type 類。
• 解析類定義中的屬性和方法，生成類的命名空間，并將它們存儲在類對象的 dict 屬性中。
• 調(diào)用元類的 new 方法，將創(chuàng)建的類對象作為第一個參數(shù)傳入。new 方法可以對類對象進行修改，并返回一個新的類對象。
• 如果 new 方法返回的是一個類對象，那么就調(diào)用元類的 init 方法，將創(chuàng)建的類對象作為第一個參數(shù)傳入，以便進行初始化操作。
• 返回最終創(chuàng)建的類對象。

需要注意的是，元類只會影響類對象的創(chuàng)建過程，而不會影響類的實例化過程。也就是說，元類只能控制類的屬性和方法，不能控制類的實例。如果需要控制類的實例化過程，可以重寫類的 new 或 init 方法，或者使用裝飾器等其他技術(shù)。

如何在元類中修改類的屬性或方法？

在元類中修改類的屬性或方法，通常需要重寫元類的 new 方法。new 方法可以接收三個參數(shù)：

• cls: 元類對象本身。
• name: 類的名稱。
• bases: 類繼承的父類元組。
• attrs: 類的屬性和方法字典。

在 new 方法中，可以對類的屬性和方法進行修改，并返回一個新的類對象。以下是一個示例，展示了如何在元類中自動添加一個計數(shù)器屬性：

class CountMeta(type):
    def __new__(cls, name, bases, attrs):
        attrs['count'] = 0
        for attr, value in attrs.items():
            if callable(value):
                attrs[attr] = cls.wrap(attr, value)
        return super().__new__(cls, name, bases, attrs)

    @staticmethod
    def wrap(name, func):
        def wrapper(*args, **kwargs):
            cls = args[0].__class__
            cls.count += 1
            return func(*args, **kwargs)
        return wrapper

class MyClass(metaclass=CountMeta):
    def foo(self):
        pass

obj1 = MyClass()
obj1.foo()
print(obj1.__class__.count)  # Output: 1

obj2 = MyClass()
obj2.foo()
obj2.foo()
print(obj2.__class__.count)  # Output: 3

在這個示例中，定義了一個名為 CountMeta 的元類，它在 new 方法中自動添加了一個名為 count 的屬性，并將所有可調(diào)用的方法進行了修飾，以便在調(diào)用時自動增加計數(shù)器。然后通過將 MyClass 的元類指定為 CountMeta，實現(xiàn)了為類自動添加計數(shù)器功能。

需要注意的是，元類是一種高級特性，應(yīng)該謹(jǐn)慎使用。如果不了解元類的工作原理和使用方法，可能會導(dǎo)致代碼難以理解和維護。通常情況下，可以通過其他方式來實現(xiàn)同樣的功能，而不必使用元類。

3.垃圾回收

Python 3 中的垃圾回收機制使用了引用計數(shù)和標(biāo)記清除兩種機制來進行垃圾回收。

引用計數(shù)機制是指每個 Python 對象都維護著一個引用計數(shù)器，記錄有多少個變量引用該對象。當(dāng)引用計數(shù)器變?yōu)榱銜r，表示該對象已經(jīng)沒有任何引用，可以被回收。

標(biāo)記清除機制是指通過一種遍歷算法來識別無法訪問的對象，將它們從內(nèi)存中刪除。具體實現(xiàn)過程為：

• 遍歷所有的根對象（如全局變量、局部變量等），標(biāo)記它們?yōu)椤翱蛇_”（即可以被訪問）。
• 遍歷所有可達對象，標(biāo)記它們的所有引用對象為“可達”。
• 從第二步標(biāo)記的所有對象中，將沒有標(biāo)記的對象刪除，即為無法訪問的對象。

在 Python 3 中，具體實現(xiàn)垃圾回收機制的源代碼文件為 Modules/gcmodule.c 和 Objects/obmalloc.c。

Python 3 的垃圾回收機制和其他編程語言的實現(xiàn)有何異同？

與其他編程語言相比，Python 3 的垃圾回收機制具有以下特點：

• Python 3 支持循環(huán)引用的垃圾回收，可以自動處理循環(huán)引用的情況。
• Python 3 采用了引用計數(shù)機制和標(biāo)記清除機制相結(jié)合的方式進行垃圾回收，相比其他語言的垃圾回收機制更加高效。

如何判斷 Python 對象是否可回收？

判斷 Python 對象是否可回收的方法為：當(dāng)一個對象的引用計數(shù)器為零時，即可判斷該對象可以被回收。

Python 3 中的垃圾回收機制是如何處理循環(huán)引用的？

對于循環(huán)引用的情況，Python 3 中使用了另外一種機制，稱為“分代回收”。Python 3 將所有的對象分為三代：第 0 代為新建對象，第 1 代為一段時間后依然存活的對象，第 2 代為長期存活的對象。Python 3 會更頻繁地回收第 0 代和第 1 代的對象，而對第 2 代的對象則采用更少的回收頻率，以提高垃圾回收的效率。

如何手動控制 Python 對象的垃圾回收？

手動控制 Python 對象的垃圾回收可以使用 gc 模塊的 collect() 方法來手動啟動垃圾回收機制，使用 set_threshold() 方法來設(shè)置垃圾回收的閾值。
以下是一個簡單的示例代碼，展示了如何使用 Python 的 gc 模塊手動控制垃圾回收：

import gc

class MyObject:
    def __init__(self, name):
        self.name = name
    
    def __del__(self):
        print(f"{self.name}對象被銷毀了！")
    
    def __repr__(self):
        return f"<MyObject {self.name}>"

# 創(chuàng)建對象
obj1 = MyObject("Object 1")
obj2 = MyObject("Object 2")

# 手動觸發(fā)垃圾回收
gc.collect()

# 刪除對象的引用
obj1 = None
obj2 = None

# 手動觸發(fā)垃圾回收
gc.collect()

在這個示例代碼中，我們定義了一個 MyObject 類來創(chuàng)建自定義的對象。在創(chuàng)建完 obj1 和 obj2 對象后，我們使用 gc.collect() 方法手動觸發(fā)垃圾回收。在刪除 obj1 和 obj2 對象的引用后，我們再次使用 gc.collect() 方法手動觸發(fā)垃圾回收，以確保這些對象已經(jīng)被成功回收。

當(dāng)程序運行結(jié)束時，我們可以看到輸出：

Object 1對象被銷毀了！
Object 2對象被銷毀了！

這表明我們成功地使用了 gc 模塊手動控制了 Python 對象的垃圾回收。

如何調(diào)優(yōu) Python 的垃圾回收機制以提高性能？

調(diào)優(yōu) Python 的垃圾回收機制以提高性能可以使用以下方法：

1. 減少對象的創(chuàng)建和銷毀次數(shù)，盡量重用已有的對象。
2. 避免循環(huán)引用的產(chǎn)生。
3. 調(diào)整垃圾回收的閾值，根據(jù)應(yīng)用的特點和硬件的配置來優(yōu)化垃圾回收機制。
4. 使用 Python 的 C 擴展來處理大量的內(nèi)存分配，以避免垃圾回收機制的頻繁觸發(fā)。
5. 盡量使用不可變對象，因為不可變對象無需頻繁創(chuàng)建和銷毀，對垃圾回收機制的壓力較小。
6. 在多線程應(yīng)用中，使用局部變量來避免共享變量產(chǎn)生的垃圾回收問題。

4. 迭代器（Iterator）

迭代器和生成器有什么區(qū)別？

迭代器和生成器都是用來遍歷數(shù)據(jù)集合的工具，但是它們之間存在一些區(qū)別：

• 迭代器是一個對象，它可以在數(shù)據(jù)集合上進行遍歷，并且可以根據(jù)需要返回單個元素。而生成器是一個函數(shù)，它可以動態(tài)生成數(shù)據(jù)集合，并且可以在需要時返回單個元素。
• 迭代器通常是手動實現(xiàn)的，而生成器是使用 yield 關(guān)鍵字自動創(chuàng)建的。
• 迭代器可以使用 next() 函數(shù)來獲取下一個元素，而生成器會自動處理迭代過程中的狀態(tài)，所以不需要使用 next() 函數(shù)來獲取下一個元素。

如何使用 Python 的內(nèi)置函數(shù)實現(xiàn)迭代器？

Python 內(nèi)置函數(shù) iter() 和 next() 可以用來實現(xiàn)迭代器。

iter() 函數(shù)接受一個可迭代對象作為參數(shù)，并返回一個迭代器對象。例如：

my_list = [1, 2, 3]
my_iterator = iter(my_list)

next() 函數(shù)接受一個迭代器對象作為參數(shù)，并返回下一個元素。當(dāng)沒有更多的元素可供返回時，它會引發(fā) StopIteration 異常。例如：

my_list = [1, 2, 3]
my_iterator = iter(my_list)

print(next(my_iterator))  # 輸出 1
print(next(my_iterator))  # 輸出 2
print(next(my_iterator))  # 輸出 3
print(next(my_iterator))  # 引發(fā) StopIteration 異常

迭代器的實現(xiàn)原理是什么？

迭代器的實現(xiàn)原理是使用一個類來表示迭代器對象，并實現(xiàn)兩個方法：iter() 和 next()。

• iter() 方法返回迭代器對象本身。
• next() 方法返回迭代器的下一個元素。如果沒有更多的元素，則引發(fā) StopIteration 異常。

以下是一個簡單的迭代器實現(xiàn)示例：

class MyIterator:
    def __init__(self, my_list):
        self.my_list = my_list
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= len(self.my_list):
            raise StopIteration
        value = self.my_list[self.index]
        self.index += 1
        return value

my_list = [1, 2, 3]
my_iterator = MyIterator(my_list)

for item in my_iterator:
    print(item)

如何使用迭代器來遍歷自定義對象？

要使用迭代器來遍歷自定義對象，需要在自定義對象的類中實現(xiàn) iter() 和 next() 方法。

例如，下面是一個簡單的自定義類，其中實現(xiàn)了這兩個方法：

class MyCustomClass:
    def __init__(self, my_list):
        self.my_list = my_list
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= len(self.my_list):
            raise StopIteration
        value = self.my_list[self.index]
        self.index += 1
        return value

my_list = [1, 2, 3]
my_object = MyCustomClass(my_list)

for item in my_object:
    print(item)

在這個示例中，我們定義了一個名為 MyCustomClass 的類，并在其中實現(xiàn)了 iter() 和 next() 方法。然后我們創(chuàng)建了一個 MyCustomClass 的實例，并使用 for 循環(huán)遍歷它，就像我們遍歷一個列表或元組一樣。

如何手動實現(xiàn)一個簡單的迭代器？

手動實現(xiàn)一個簡單的迭代器，需要定義一個類，并在其中實現(xiàn) iter() 和 next() 方法。下面是一個簡單的迭代器實現(xiàn)示例：

class MyIterator:
    def __init__(self, my_list):
        self.my_list = my_list
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= len(self.my_list):
            raise StopIteration
        value = self.my_list[self.index]
        self.index += 1
        return value

my_list = [1, 2, 3]
my_iterator = MyIterator(my_list)

for item in my_iterator:
    print(item)

在這個示例中，我們定義了一個名為 MyIterator 的類，并在其中實現(xiàn)了 iter() 和 next() 方法。然后我們創(chuàng)建了一個 MyIterator 的實例，并使用 for 循環(huán)遍歷它，就像我們遍歷一個列表或元組一樣。

5. 生成器（Generator）

生成器和迭代器有什么區(qū)別？

生成器（Generator）是一種特殊的迭代器（Iterator），它可以動態(tài)生成值，而不是一次性生成所有值，這樣可以節(jié)省內(nèi)存空間和計算資源。

迭代器是一個可以遍歷一個可迭代對象的對象，可以通過 iter() 函數(shù)獲取一個迭代器對象，然后使用 next() 函數(shù)獲取序列中的下一個元素，直到序列中的所有元素都被遍歷完為止。

生成器和迭代器的主要區(qū)別在于，生成器在執(zhí)行過程中動態(tài)生成值，而迭代器一般是在遍歷前就生成了所有值，并且一旦生成就不能修改。

如何使用 Python 的 yield 關(guān)鍵字實現(xiàn)生成器？

在 Python 中，可以使用 yield 關(guān)鍵字來實現(xiàn)生成器。yield 關(guān)鍵字可以在函數(shù)中暫停函數(shù)執(zhí)行，然后返回一個值，并保存函數(shù)的狀態(tài)，等到下一次調(diào)用 next() 函數(shù)時，會從上一次的狀態(tài)繼續(xù)執(zhí)行函數(shù)，直到函數(shù)執(zhí)行完畢或者遇到下一個 yield 關(guān)鍵字。

例如，下面的代碼展示了一個簡單的生成器，它可以生成從 0 到 n 的所有整數(shù)：

def countdown(n):
    while n >= 0:
        yield n
        n -= 1

可以通過以下方式來遍歷這個生成器：

for i in countdown(5):
    print(i)

輸出結(jié)果為：

5
4
3
2
1
0

生成器的實現(xiàn)原理是什么？

生成器的實現(xiàn)原理是使用了 Python 中的協(xié)程（Coroutine）技術(shù)。協(xié)程是一種用戶級線程，可以在不同的代碼塊之間暫停和恢復(fù)執(zhí)行，與線程相比，協(xié)程具有更輕量級、更高效、更靈活的特點。

生成器通過 yield 關(guān)鍵字來實現(xiàn)協(xié)程，當(dāng)函數(shù)遇到 yield 關(guān)鍵字時，函數(shù)執(zhí)行會被暫停，返回一個值并保存當(dāng)前的狀態(tài)。等到下一次調(diào)用 next() 函數(shù)時，會從上一次的狀態(tài)繼續(xù)執(zhí)行函數(shù)，直到函數(shù)執(zhí)行完畢或者遇到下一個 yield 關(guān)鍵字。

如何使用生成器來遍歷自定義對象？

可以通過實現(xiàn) iter() 和 next() 方法來創(chuàng)建一個自定義的迭代器，也可以使用生成器來創(chuàng)建一個迭代器。

例如，下面的代碼展示了如何使用生成器來遍歷一個列表：

def iter_list(lst):
    for i in lst:
        yield i

my_list = [1, 2, 3, 4, 5]
for i in iter_list(my_list):
    print(i)

輸出結(jié)果為：

1
2
3
4
5

生成器的使用場景有哪些？

生成器可以用于遍歷大量數(shù)據(jù)時節(jié)省內(nèi)存空間和計算資源，也可以用于處理流式數(shù)據(jù)，例如從文件或網(wǎng)絡(luò)中讀取數(shù)據(jù)，處理一部分?jǐn)?shù)據(jù)，然后將其寫入另一個文件或網(wǎng)絡(luò)中。

另外，生成器還可以用于生成無限序列，例如斐波那契數(shù)列、素數(shù)序列等。

總的來說，生成器的使用場景包括：

• 遍歷大量數(shù)據(jù)時節(jié)省內(nèi)存空間和計算資源
• 處理流式數(shù)據(jù)
• 生成無限序列
• 其他需要動態(tài)生成值的場景

總之，生成器是 Python 中一個非常強大的特性，可以幫助我們更高效地處理數(shù)據(jù)和編寫代碼。