概述

在Python中，特殊方法（也稱為魔術(shù)方法）是由Python解釋器自動調(diào)用的，我們不需要手動調(diào)用它們，而是使用內(nèi)置函數(shù)來間接地使用它們。舉個例子，我們可以實現(xiàn)特殊方法__len__()，然后通過使用內(nèi)置函數(shù)len()來獲取對象的長度。同樣地，一些特殊方法的調(diào)用是隱式的，比如在使用for循環(huán)時，實際上是在使用內(nèi)置函數(shù)iter(x)來迭代對象x。

在Java中，并沒有像Python那樣簡單的實現(xiàn)方式。如果要進(jìn)行比較，你需要實現(xiàn)compare方法；如果想要生成特定的對象，必須編寫適當(dāng)?shù)臉?gòu)造器方法；如果想要打印對象，就需要實現(xiàn)toString方法等等。此外，在Java中的魔術(shù)類或方法以及各種本地方法基本上是不允許我們修改的。因此，我們還是簡單地看一下Python是如何調(diào)用的吧。

常用特殊方法及實現(xiàn)

下面將介紹一些常用特殊方法和實現(xiàn)。

__init__(self, ...)

構(gòu)造函數(shù)主要用于初始化對象的屬性。通過在類中定義__init__方法，可以在創(chuàng)建對象時自動調(diào)用該方法來初始化對象的屬性。在構(gòu)造函數(shù)中，可以通過self參數(shù)來訪問對象的屬性和方法，并為其賦予初始值。構(gòu)造函數(shù)在對象創(chuàng)建時只會被調(diào)用一次，可以在其中執(zhí)行一些必要的初始化操作，以確保對象在創(chuàng)建后處于正確的狀態(tài)。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person('xiaoyu', 18)
print(person.name)  # 輸出: xiaoyu
print(person.age)   # 輸出: 18

__str__(self)

返回對象的字符串表示，可通過print(obj)來調(diào)用。這個方法對于調(diào)試和輸出對象信息非常有用，可以提供更友好和可讀性更高的輸出結(jié)果。通過實現(xiàn)__str__方法，我們可以輕松地控制對象的打印行為，使其更符合我們的需求和預(yù)期。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Person: {self.name}, {self.age} years old"

person = Person('xiaoyu', 18)
print(person)  # 輸出: Person: xiaoyu, 18 years old

__repr__(self)

返回對象的可打印字符串表示，可通過obj來調(diào)用。與__str__方法類似，__repr__方法也用于提供對象的字符串表示，但它的目標(biāo)是更加精確和完整地描述對象的內(nèi)部狀態(tài)和結(jié)構(gòu)。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person(name={self.name}, age={self.age})"

person = Person('xiaoyu', 18)
print(person)  # 輸出: Person(name=xiaoyu, age=18)

__len__(self)

返回對象的長度，可通過len(obj)來調(diào)用。在Python中，len()函數(shù)通常用于獲取容器對象的元素個數(shù)，比如列表、字符串、字典等。通過實現(xiàn)__len__方法，我們可以自定義對象的長度，并使其適應(yīng)于特定的應(yīng)用場景。例如，如果我們定義了一個自定義的容器類，可以通過實現(xiàn)__len__方法來返回容器中元素的個數(shù)。這樣，我們就可以像對待其他內(nèi)置容器一樣，使用len()函數(shù)來獲取自定義容器對象的長度。

class MyList:
    def __init__(self):
        self.data = []

    def __len__(self):
        return len(self.data)

my_list = MyList()
my_list.data = [1, 2, 3, 4, 5]
print(len(my_list))  # 輸出: 5

__getitem__(self, key)

獲取對象的指定元素，可通過obj[key]來調(diào)用。并將鍵值key傳遞給它作為參數(shù)。

class MyList:
    def __init__(self):
        self.data = []

    def __getitem__(self, key):
        return self.data[key]

my_list = MyList()
my_list.data = [1, 2, 3, 4, 5]
print(my_list[2])  # 輸出: 3

__setitem__(self, key, value)

設(shè)置對象的指定元素，通過重載該方法，可以實現(xiàn)通過obj[key] = value來調(diào)用該方法。

class MyList:
    def __init__(self):
        self.data = []

    def __setitem__(self, key, value):
        self.data[key] = value

my_list = MyList()
my_list.data = [1, 2, 3, 4, 5]
my_list[2] = 10
print(my_list.data)  # 輸出: [1, 2, 10, 4, 5]

__delitem__(self, key)

刪除對象的指定元素，可通過del obj[key]來調(diào)用。當(dāng)你想要從對象中刪除特定的元素時，這個方法會非常有用。

class MyList:
    def __init__(self):
        self.data = []

    def __delitem__(self, key):
        del self.data[key]

my_list = MyList()
my_list.data = [1, 2, 3, 4, 5]
del my_list[2]
print(my_list.data)  # 輸出: [1, 2, 4, 5]

__iter__(self)

返回一個可迭代對象，以便我們可以通過for item in obj的方式進(jìn)行迭代。

class MyList:
    def __init__(self):
        self.data = []

    def __iter__(self):
        return iter(self.data)

my_list = MyList()
my_list.data = [1, 2, 3, 4, 5]
for item in my_list:
    print(item)  # 輸出: 1 2 3 4 5

__next__(self)

返回迭代器的下一個元素，可通過next(obj)來調(diào)用。

class MyIterator:
    def __init__(self):
        self.data = [1, 2, 3, 4, 5]
        self.index = 0

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

my_iterator = MyIterator()
print(next(my_iterator))  # 輸出: 1
print(next(my_iterator))  # 輸出: 2
print(next(my_iterator))  # 輸出: 3

__call__(self, ...)

將對象作為函數(shù)調(diào)用時觸發(fā)，可通過obj(...)來調(diào)用。

class MyFunc:
    def __call__(self, x, y):
        return x + y

my_func = MyFunc()
result = my_func(3, 4)
print(result)  # 輸出: 7

__eq__(self, other)

判斷對象是否相等，可通過obj == other來調(diào)用。在Java中如果判斷對象引用的話，你也需要重寫equals這個方法。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

point1 = Point(1, 2)
point2 = Point(1, 2)
print(point1 == point2)  # 輸出: True

__lt__(self, other)

判斷對象是否小于另一個對象，可通過obj < other來調(diào)用。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __lt__(self, other):
        return self.x < other.x and self.y < other.y

point1 = Point(1, 2)
point2 = Point(3, 4)
print(point1 < point2)  # 輸出: True

__gt__(self, other)

判斷對象是否大于另一個對象，可通過obj > other來調(diào)用。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __gt__(self, other):
        return self.x > other.x and self.y > other.y

point1 = Point(3, 4)
point2 = Point(1, 2)
print(point1 > point2)  # 輸出: True

__add__(self, other)

定義對象的加法操作，可通過obj + other來調(diào)用。這樣的話，你也可以對對象進(jìn)行進(jìn)行運(yùn)算操作了

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

vector1 = Vector(1, 2)
vector2 = Vector(3, 4)
result = vector1 + vector2
print(result.x, result.y)  # 輸出: 4 6

__sub__(self, other)

定義對象的減法操作，可通過obj - other來調(diào)用。

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

vector1 = Vector(3, 4)
vector2 = Vector(1, 2)
result = vector1 - vector2
print(result.x, result.y)  # 輸出: 2 2

常用特殊（魔術(shù)）方法的匯總一覽表

以下是20個常用的特殊方法及其調(diào)用方式的表格，再多的用到了我們在看一下就可以了，只要記住（__）這個下劃線開頭和結(jié)尾的方法就可。請看下表：

總結(jié)

Python中的特殊方法（魔術(shù)方法）是由Python解釋器自動調(diào)用的，用于實現(xiàn)對象的特定功能。常用的特殊方法包括__init__、__str__、__repr__、__len__、__getitem__、__setitem__、__delitem__、__iter__、__next__、__call__等。通過實現(xiàn)這些特殊方法，我們可以自定義對象的行為，使其更加符合我們的需求和預(yù)期。這些特殊方法的調(diào)用方式也有所不同，可以通過內(nèi)置函數(shù)、運(yùn)算符、迭代等方式來調(diào)用。掌握了這些特殊方法的用法，可以提高我們在Python中編寫類和對象的靈活性和可擴(kuò)展性。文章來源地址http://www.zghlxwxcb.cn/news/detail-820031.html

到了這里，關(guān)于Java開發(fā)者的Python快速進(jìn)修指南：探索15種獨特的Python特殊方法的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！