Python面向对象——魔术方法

在Python中，魔术方法（Magic Methods），也称为特殊方法（Special Methods）或双下方法（Dunder Methods），是一组用特殊命名和双下划线__包围的方法。这些方法允许开发者自定义类的行为，使其具有类似于内置类型的行为或支持特定的语言特性。

下面是一些常见的Python魔术方法及其用途：

1. 构造和初始化：

   • __init__(self, ...): 初始化对象，在创建对象时调用。
   • __new__(cls, ...): 创建并返回实例对象，在对象实例化之前调用。

2. 对象表示：

   • __str__(self): 返回对象的字符串表示形式，通过str(obj)或print(obj)调用。
   • __repr__(self): 返回对象的可打印字符串表示形式，通过repr(obj)调用。

3. 集合和序列：

   • __len__(self): 返回对象的长度，通过len(obj)调用。
   • __getitem__(self, key): 获取对象的索引值，通过obj[key]调用。
   • __setitem__(self, key, value): 设置对象的索引值，通过obj[key] = value调用。
   • __delitem__(self, key): 删除对象的索引值，通过del obj[key]调用。
   • __iter__(self): 返回对象的迭代器，通过iter(obj)调用。

4. 比较运算：

   • __eq__(self, other): 定义对象相等的比较操作，通过==调用。
   • __ne__(self, other): 定义对象不相等的比较操作，通过!=调用。
   • __lt__(self, other): 定义对象小于的比较操作，通过<调用。
   • __gt__(self, other): 定义对象大于的比较操作，通过>调用。
   • __le__(self, other): 定义对象小于等于的比较操作，通过<=调用。
   • __ge__(self, other): 定义对象大于等于的比较操作，通过>=调用。

5. 算术运算：

   • __add__(self, other): 定义对象加法操作，通过+调用。
   • __sub__(self, other): 定义对象减法操作，通过-调用。
   • __mul__(self, other): 定义对象乘法操作，通过*调用。
   • __div__(self, other): 定义对象除法操作，通过/调用。
   • __mod__(self, other): 定义对象取模操作，通过%调用。
   • __pow__(self, other): 定义对象幂运算操作，通过**调用。

6. 其它

   • __next__(self)：迭代器方法，返回迭代器的下一个元素，通过内置的next()函数调用。
   • __call__(self, ...)：使对象可调用，类似于函数的行为，通过在对象后面加上括号进行调用。

以下是一个示例，展示如何重写上述魔术方法：

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

    def __str__(self):
        return f"MyClass({self.value})"

    def __repr__(self):
        return f"MyClass({self.value})"

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

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

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

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

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

    def __next__(self):
        # 实现迭代返回每个字符
        if self.index >= len(self.value):
            raise StopIteration
        result = self.value[self.index]
        self.index += 1
        return result

    def __call__(self):
        print("Called MyClass")

# 创建对象
obj = MyClass([1, 2, 3, 4, 5])

# 调用魔术方法
print(obj)  # 输出: MyClass([1, 2, 3, 4, 5])
print(len(obj))  # 输出: 5

# 索引操作
print(obj[2])  # 输出: 3
obj[2] = 6
print(obj)  # 输出: MyClass([1, 2, 6, 4, 5])
del obj[3]
print(obj)  # 输出: MyClass([1, 2, 6, 5])

# 迭代操作
for item in obj:
    print(item)  # 输出: 1 2 6 5

# 调用对象
obj()  # 输出: Called MyClass

以下是另一个示例，展示如何重写上述比较运算魔术方法：

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

    def __eq__(self, other):
        if isinstance(other, Point):
            return self.x == other.x and self.y == other.y
        return False

    def __lt__(self, other):
        if isinstance(other, Point):
            return self.x < other.x and self.y < other.y
        return NotImplemented

    def __gt__(self, other):
        if isinstance(other, Point):
            return self.x > other.x and self.y > other.y
        return NotImplemented

# 创建两个Point对象
p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = Point(1, 2)

# 使用比较运算符进行对象比较
print(p1 == p2)  # 输出: False
print(p1 == p3)  # 输出: True
print(p1 < p2)  # 输出: True
print(p1 > p2)  # 输出: False

在上述示例中，我们创建了一个表示二维点的Point类，并重写了__eq__、__lt__和__gt__方法。我们通过比较运算符来比较两个Point对象的相等性、大小关系。

需要注意的是，对于某些比较运算符，如果对象之间的比较不可确定，则应返回NotImplemented，以便让解释器尝试使用反向运算符进行比较。

以上只是一小部分常见的魔术方法示例，Python还提供了更多用于自定义对象行为的魔术方法。可以根据需要选择并实现这些方法来自定义类的行为。希望这篇博文可以帮到大家，谢谢！