快捷導(dǎo)航

深入理解Python虛擬機中常見魔術(shù)方法的使用

更新時間：2023年05月21日 14:08:57 作者：一無是處的研究僧

本文主要給大家介紹在 python 當(dāng)中與數(shù)學(xué)計算相關(guān)的一些常見的魔術(shù)方法，是在很多科學(xué)計算的包當(dāng)中都使用到的魔術(shù)方法，感興趣的小伙伴可以了解一下

在本篇文章當(dāng)中主要給大家介紹在 python 當(dāng)中一些常見的魔術(shù)方法，本篇文章主要是關(guān)于與數(shù)學(xué)計算相關(guān)的一些魔術(shù)方法，在很多科學(xué)計算的包當(dāng)中都使用到了這些魔術(shù)方法。

大小比較

當(dāng)我們在Python中定義自己的類時，可以通過重寫一些特殊方法來改變對象的比較行為。這些特殊方法包括__lt__、__le__、__eq__、__ne__、__gt__和__ge__，它們分別對應(yīng)于小于、小于等于、等于、不等于、大于和大于等于的比較運算符。這些方法允許我們自定義對象之間的比較規(guī)則。

下面是對每個方法的詳細介紹：

object.__lt__(self, other) 這個方法用于定義小于（<）運算符的行為。當(dāng)我們使用小于運算符比較兩個對象時，會調(diào)用該方法。如果self對象小于other對象，則返回True，否則返回False。
object.__le__(self, other) 這個方法用于定義小于等于（<=）運算符的行為。當(dāng)我們使用小于等于運算符比較兩個對象時，會調(diào)用該方法。如果self對象小于等于other對象，則返回True，否則返回False。
object.__eq__(self, other) 這個方法用于定義等于（==）運算符的行為。當(dāng)我們使用等于運算符比較兩個對象時，會調(diào)用該方法。如果self對象等于other對象，則返回True，否則返回False。
object.__ne__(self, other) 這個方法用于定義不等于（!=）運算符的行為。當(dāng)我們使用不等于運算符比較兩個對象時，會調(diào)用該方法。如果self對象不等于other對象，則返回True，否則返回False。
object.__gt__(self, other) 這個方法用于定義大于（>）運算符的行為。當(dāng)我們使用大于運算符比較兩個對象時，會調(diào)用該方法。如果self對象大于other對象，則返回True，否則返回False。
object.__ge__(self, other) 這個方法用于定義大于等于（>=）運算符的行為。當(dāng)我們使用大于等于運算符比較兩個對象時，會調(diào)用該方法。如果self對象大于等于other對象，則返回True，否則返回False。

這些比較方法允許我們根據(jù)自己的需求自定義對象的比較規(guī)則。當(dāng)我們使用比較運算符對對象進行比較時，Python會自動調(diào)用這些方法，并返回相應(yīng)的結(jié)果。

下面是一個簡單的示例，展示如何在自定義類中使用這些比較方法：

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
        return self.y < other.y
    
    def __le__(self, other):
        return self.x <= other.x and self.y <= other.y
    
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    
    def __ne__(self, other):
        return not self.__eq__(other)
    
    def __gt__(self, other):
        return self.x > other.x and self.y > other.y
    
    def __ge__(self, other):
        return self.x >= other.x and self.y >= other.y
 
 
p1 = Point(1, 2)
p2 = Point(3, 4)
 
 
print(p1 < p2)  
print(p1 <= p2)
print(p1 == p2)
print(p1 != p2)
print(p1 > p2)
print(p1 >= p2)

上面的代碼輸出結(jié)果如下所示：

2
True
False
True
False
False

在上面的示例中，我們定義了一個名為Point的類，它表示一個二維平面上的點。我們重寫了__lt__、__le__、__eq__、__ne__、__gt__和__ge__方法來定義點之間的比較規(guī)則。根據(jù)我們的定義，如果一個點的x坐標(biāo)和y坐標(biāo)都小于另一個點的相應(yīng)坐標(biāo)，則我們認為前一個點小于后一個點。

通過創(chuàng)建兩個Point對象并使用比較運算符進行比較，我們可以看到根據(jù)我們的定義，比較運算符返回了預(yù)期的結(jié)果。

模擬設(shè)計一個數(shù)學(xué)類型

當(dāng)我們在Python中定義自己的類時，可以通過重寫一些特殊方法來改變對象的算術(shù)運算行為。這些特殊方法包括__add__、__sub__、__mul__、__matmul__、__truediv__、__floordiv__、__mod__、__divmod__、__pow__、__lshift__、__rshift__、__and__、__xor__和__or__，它們分別對應(yīng)于加法、減法、乘法、矩陣乘法、真除法、整除法、取模運算、divmod函數(shù)、冪運算、左移位、右移位、按位與、按位異或和按位或的運算符。這些方法允許我們自定義對象之間的算術(shù)運算規(guī)則。

object.__add__(self, other) 這個方法用于定義加法（+）運算符的行為。當(dāng)我們使用加法運算符對兩個對象進行相加時，會調(diào)用該方法。它返回兩個對象相加的結(jié)果。
object.__sub__(self, other) 這個方法用于定義減法（-）運算符的行為。當(dāng)我們使用減法運算符對兩個對象進行相減時，會調(diào)用該方法。它返回兩個對象相減的結(jié)果。
object.__mul__(self, other) 這個方法用于定義乘法（*）運算符的行為。當(dāng)我們使用乘法運算符對兩個對象進行相乘時，會調(diào)用該方法。它返回兩個對象相乘的結(jié)果。
object.__matmul__(self, other) 這個方法用于定義矩陣乘法（@）運算符的行為。當(dāng)我們使用矩陣乘法運算符對兩個對象進行矩陣乘法時，會調(diào)用該方法。它返回兩個對象的矩陣乘法結(jié)果。
object.__truediv__(self, other) 這個方法用于定義真除法（/）運算符的行為。當(dāng)我們使用真除法運算符對兩個對象進行相除時，會調(diào)用該方法。它返回兩個對象相除的結(jié)果。
object.__floordiv__(self, other) 這個方法用于定義整除法（//）運算符的行為。當(dāng)我們使用整除法運算符對兩個對象進行相除并取整時，會調(diào)用該方法。它返回兩個對象相除取整的結(jié)果。
object.__mod__(self, other) 這個方法用于定義取模（%）運算符的行為。當(dāng)我們使用取模運算符對兩個對象進行取模運算時，會調(diào)用該方法。它返回兩個對象取模運算的結(jié)果。
object.__divmod__(self, other)這個方法用于定義divmod函數(shù)的行為。divmod函數(shù)接受兩個參數(shù)，并返回一個包含商和余數(shù)的元組。當(dāng)我們對兩個對象使用divmod函數(shù)時，會調(diào)用該方法。它返回一個包含兩個對象的商和余數(shù)的元組。
object.__pow__(self, other[, modulo]) 這個方法用于定義冪運算（**）運算符的行為。當(dāng)我們使用冪運算符對兩個對象進行冪運算時，會調(diào)用該方法。它返回兩個對象的冪運算結(jié)果?？蛇x的modulo參數(shù)用于指定取模運算的模數(shù)。
object.__lshift__(self, other) 這個方法用于定義左移位（<<）運算符的行為。當(dāng)我們對一個對象使用左移位運算符時，會調(diào)用該方法。它返回對象左移指定位數(shù)后的結(jié)果。
object.__rshift__(self, other) 這個方法用于定義右移位（>>）運算符的行為。當(dāng)我們對一個對象使用右移位運算符時，會調(diào)用該方法。它返回對象右移指定位數(shù)后的結(jié)果。
object.__and__(self, other) 這個方法用于定義按位與（&）運算符的行為。當(dāng)我們對兩個對象使用按位與運算符時，會調(diào)用該方法。它返回兩個對象按位與的結(jié)果。
object.__xor__(self, other) 這個方法用于定義按位異或（^）運算符的行為。當(dāng)我們對兩個對象使用按位異或運算符時，會調(diào)用該方法。它返回兩個對象按位異或的結(jié)果。
object.__or__(self, other) 這個方法用于定義按位或（|）運算符的行為。當(dāng)我們對兩個對象使用按位或運算符時，會調(diào)用該方法。它返回兩個對象按位或的結(jié)果。

通過重寫這些方法，我們可以在自定義類中定義對象之間的算術(shù)運算規(guī)則。當(dāng)我們使用相應(yīng)的算術(shù)運算符或函數(shù)對對象進行操作時，Python會自動調(diào)用這些方法，并返回相應(yīng)的結(jié)果。

下面是一個簡單的示例，展示如何在自定義類中使用這些算術(shù)方法：

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)
 
    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)
 
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)
 
    def __truediv__(self, scalar):
        return Vector(self.x / scalar, self.y / scalar)
 
    def __repr__(self):
        return f"Vector[{self.x}, {self.y}]"
 
 
# 創(chuàng)建兩個 Vector 對象
v1 = Vector(1, 2)
v2 = Vector(3, 4)
 
# 使用算術(shù)運算符進行操作
v3 = v1 + v2
v4 = v1 - v2
 
v5 = v1 * 2
v6 = v2 / 3
 
print(f"{v1 = }")
print(f"{v2 = }")
print(f"{v3 = }")
print(f"{v4 = }")
print(f"{v5 = }")
print(f"{v6 = }")

上面的代碼輸出結(jié)果如下所示：

v1 = Vector[1, 2]
v2 = Vector[3, 4]
v3 = Vector[4, 6]
v4 = Vector[-2, -2]
v5 = Vector[2, 4]
v6 = Vector[1.0, 1.3333333333333333]

在上面的示例中，我們定義了一個名為Vector的類，它表示二維向量。我們重寫了__add__、__sub__、__mul__和__truediv__方法來定義向量之間的加法、減法、乘法和真除法的規(guī)則。根據(jù)我們的定義，向量的加法是將對應(yīng)的分量相加，向量的減法是將對應(yīng)的分量相減，向量的乘法是將每個分量與標(biāo)量相乘，向量的真除法是將每個分量除以標(biāo)量。通過創(chuàng)建兩個Vector對象并使用算術(shù)運算符進行操作，我們可以看到根據(jù)我們的定義，算術(shù)運算符返回了預(yù)期的結(jié)果。

當(dāng)我們在Python中定義自己的類時，除了重寫一些魔術(shù)方法來改變對象的算術(shù)運算行為之外，還可以重寫對應(yīng)的反向魔術(shù)方法來處理反向運算。這些反向魔術(shù)方法以__r開頭，后面跟著對應(yīng)的運算符，例如__radd__、__rsub__、__rmul__等。它們用于在無法直接對另一個對象調(diào)用相應(yīng)的魔術(shù)方法時，嘗試使用當(dāng)前對象的魔術(shù)方法來處理反向運算。主要有下面的方法：

object.__iadd__(self, other)
object.__isub__(self, other)
object.__imul__(self, other)
object.__imatmul__(self, other)
object.__itruediv__(self, other)
object.__ifloordiv__(self, other)
object.__imod__(self, other)
object.__ipow__(self, other[, modulo])
object.__ilshift__(self, other)
object.__irshift__(self, other)
object.__iand__(self, other)
object.__ixor__(self, other)
object.__ior__(self, other)

比如 a + b，當(dāng) a 當(dāng)中沒有定義 __add__的時候，就會調(diào)用 b 的 __radd__ 。比如下面這個例子：

class A:
    def __init__(self, x):
        self.x = x
class B:
    def __init__(self, x):
        self.x = x
    def __radd__(self, other):
        print("In B __radd__")
        return self.x + other.x
if __name__ == '__main__':
    a = A(1)
    b = B(1)
    print(a + b)

上面的代碼輸出結(jié)果如下所示：

In B __radd__
2

除了上面關(guān)于數(shù)據(jù)的魔術(shù)方法之外，還有一些其他的魔術(shù)方法，具體如下所示：

object.__neg__(self)
object.__pos__(self)
object.__abs__(self)
object.__invert__(self)
object.__complex__(self)
object.__int__(self)
object.__float__(self)
object.__index__(self)
object.__round__(self[, ndigits])
object.__trunc__(self)
object.__floor__(self)
object.__ceil__(self)

object.__neg__(self) 這個方法用于定義負號（-）運算符的行為。當(dāng)應(yīng)用負號運算符到一個對象時，會調(diào)用該對象的__neg__方法。它返回一個表示當(dāng)前對象相反數(shù)的新對象。
object.__pos__(self) 這個方法用于定義正號（+）運算符的行為。當(dāng)應(yīng)用正號運算符到一個對象時，會調(diào)用該對象的__pos__方法。它返回當(dāng)前對象的副本。
object.__abs__(self) 這個方法用于定義絕對值（abs()）函數(shù)的行為。當(dāng)應(yīng)用abs()函數(shù)到一個對象時，會調(diào)用該對象的__abs__方法。它返回當(dāng)前對象的絕對值。
object.__invert__(self) 這個方法用于定義按位取反（~）運算符的行為。當(dāng)應(yīng)用按位取反運算符到一個對象時，會調(diào)用該對象的__invert__方法。它返回當(dāng)前對象按位取反后的結(jié)果。
object.__complex__(self) 這個方法用于定義complex()函數(shù)的行為，用于將對象轉(zhuǎn)換為復(fù)數(shù)形式。當(dāng)應(yīng)用complex()函數(shù)到一個對象時，會調(diào)用該對象的__complex__方法。它返回一個復(fù)數(shù)對象，表示當(dāng)前對象。
object.__int__(self) 這個方法用于定義int()函數(shù)的行為，用于將對象轉(zhuǎn)換為整數(shù)形式。當(dāng)應(yīng)用int()函數(shù)到一個對象時，會調(diào)用該對象的__int__方法。它返回一個整數(shù)對象，表示當(dāng)前對象。
object.__float__(self) 這個方法用于定義float()函數(shù)的行為，用于將對象轉(zhuǎn)換為浮點數(shù)形式。當(dāng)應(yīng)用float()函數(shù)到一個對象時，會調(diào)用該對象的__float__方法。它返回一個浮點數(shù)對象，表示當(dāng)前對象。
object.__index__(self) 這個方法用于定義operator.index()函數(shù)的行為，用于將對象轉(zhuǎn)換為整數(shù)索引。當(dāng)應(yīng)用operator.index()函數(shù)到一個對象時，會調(diào)用該對象的__index__方法。它返回一個整數(shù)對象，表示當(dāng)前對象可以用作索引。
object.__round__(self[, ndigits]) 這個方法用于定義round()函數(shù)的行為，用于對對象進行四舍五入。當(dāng)應(yīng)用round()函數(shù)到一個對象時，會調(diào)用該對象的__round__方法?？蛇x的ndigits參數(shù)指定小數(shù)位數(shù)，默認為None。它返回一個新的對象，表示當(dāng)前對象四舍五入后的結(jié)果。
object.__trunc__(self) 這個方法用于定義math.trunc()函數(shù)的行為，用于將對象截斷為整數(shù)。當(dāng)應(yīng)用math.trunc()函數(shù)到一個對象時，會調(diào)用該對象的__trunc__方法。

總結(jié)

本篇文章介紹了在Python中使用魔術(shù)方法來改變對象的比較和算術(shù)運算行為。對于比較運算符，可以通過重寫__lt__、__le__、__eq__、__ne__、__gt__和__ge__方法來定義自定義對象之間的比較規(guī)則。對于算術(shù)運算符，可以通過重寫__add__、__sub__、__mul__、__matmul__、__truediv__、__floordiv__、__mod__、__divmod__、__pow__、__lshift__、__rshift__、__and__、__xor__和__or__方法來定義對象之間的算術(shù)運算規(guī)則。這些方法允許自定義類的對象具有與內(nèi)置類型相似的行為。