python魔法函数示例

在 Python 中，魔法函数（也称为特殊方法）是以双下划线（__）开头和结尾的方法。它们允许开发者定义类的行为。以下是一些常见的魔法函数，它们的用法和使用场景：

对象创建和初始化

__new__

__new__(cls, [...])：创建一个新实例。用于控制对象的创建过程。
__new__ 是一个特殊的静态方法，它在 __init__ 之前被调用，用于创建类的新实例。它是在对象实例化时最先被调用的方法，并且它返回类的新实例。__new__ 主要用于不可变类型和当你需要精确控制对象创建过程的时候。

以下是一个 __new__ 方法的示例，它展示了如何使用它来实现一个单例模式，这个模式确保了一个类只有一个实例被创建。

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

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

# 使用Singleton类创建对象
singleton1 = Singleton('value1')
singleton2 = Singleton('value2')

print(singleton1 == singleton2)  # 输出: True
print(singleton1.value)  # 输出: value1
print(singleton2.value)  # 输出: value1

singleton2.value = 'value3'
print(singleton1.value)  # 输出: value3

在这个例子中，__new__ 方法检查类属性 _instance 是否已经存在，如果不存在，它会使用 super().__new__ 调用基类的 __new__ 方法来创建一个实例并将其存储在 _instance 中。如果 _instance 已经存在，那么 __new__ 将直接返回这个现存的实例。这确保了不管你尝试创建多少次 Singleton 类的实例，你始终只会得到同一个实例。

请注意，__init__ 方法在每次实例化时仍然会被调用，即使是对同一个实例，但由于 __new__ 方法确保只有一个实例存在，因此所有对该类的引用都会指向同一个对象，并且它们共享相同的状态。

__init__

__init__(self, [...])：初始化新创建的对象。用于对象属性的初始化。
当一个对象被创建时，__init__ 方法会被自动调用以初始化该对象。在这个方法中，您可以设置对象的初始状态，比如定义它的属性和初始值。

下面是一个示例，展示了如何在 __init__ 方法中初始化一个简单的 Person 类的对象：

class Person:
    def __init__(self, name, age):
        self.name = name  # 为对象设置 name 属性
        self.age = age    # 为对象设置 age 属性

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

# 创建 Person 类的实例
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)

# 调用方法
person1.greet()  # 输出: Hello, my name is Alice and I am 30 years old.
person2.greet()  # 输出: Hello, my name is Bob and I am 25 years old.

在这个例子中，Person 类有两个属性：name 和 age。__init__ 方法接受三个参数：self、name 和 age。self 是对当前对象的引用，而 name 和 age 是传递给 __init__ 方法的参数，用于设置对象的 name 和 age 属性。

当我们创建 Person 类的实例时，如 person1 = Person("Alice", 30)，__init__ 方法被调用，"Alice" 作为 name 参数传递，30 作为 age 参数传递。这些值被用来初始化 person1 对象的属性。

同样，person2 也是用传递给 __init__ 方法的参数 "Bob" 和 25 来初始化的。

greet 方法是一个实例方法，它使用 self.name 和 self.age 来访问对象的属性，并打印一条问候消息。

__del__

__del__(self)：对象被销毁的时候调用，可以用于资源清理。
__del__ 方法是一个特殊的方法，它在对象的生命周期结束时被调用，用来执行清理工作，比如关闭文件、断开网络连接等。但是，由于Python使用自动垃圾回收机制，__del__ 方法的调用时间是不确定的，因此它并不是资源管理的首选方式。通常情况下，使用上下文管理器（with 语句）或者显式地关闭资源会更加可靠。

下面是一个使用 __del__ 方法的示例：

class Resource:
    def __init__(self):
        print("Resource created.")
        # 假设这里打开了某种资源，比如文件或网络连接

    def __del__(self):
        print("Resource deleted.")
        # 在这里执行资源清理工作，比如关闭文件或网络连接

# 创建Resource类的实例
res = Resource()

# 在这里使用资源
# ...

# 删除对象引用，触发垃圾回收
del res

# 由于垃圾回收的不确定性，__del__ 方法可能会在不可预测的时间点被调用
# 为了演示，我们可以强制进行垃圾回收
import gc
gc.collect()  # 这将触发 __del__ 方法，输出 "Resource deleted."

请注意，由于 __del__ 方法的调用依赖于垃圾回收器的行为，所以不应该依赖它来管理资源。更好的做法是使用上下文管理器或者显式地释放资源。例如，使用 with 语句可以确保资源被正确地清理：

class Resource:
    def __enter__(self):
        print("Enter resource context.")
        # 假设这里打开了某种资源
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exit resource context.")
        # 在这里执行资源清理工作

with Resource() as res:
    # 在这里使用资源
    pass

# 当with语句块执行完毕后，__exit__ 方法会被自动调用，确保资源被清理

在这个例子中，__enter__ 方法在进入上下文管理器时被调用，__exit__ 方法则在退出上下文管理器时被调用，这样就可以确定资源被及时且正确地清理了。

表示和格式化

__repr__

• __repr__(self)：官方字符串表示，用于调试和日志记录，通常应该返回一个可以用来重新创建这个对象的字符串。
  __repr__ 方法应该返回一个对象的“官方”字符串表示，这个字符串通常可以被用来重新创建该对象。换句话说，__repr__ 的返回值通常看起来像是一个有效的Python表达式，能够传递给 eval() 函数来重新创建一个相同的对象。

下面是一个简单的 __repr__ 方法的示例：

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

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

# 创建一个点对象
p = Point(1, 2)

# 打印对象的官方字符串表示
print(repr(p))  # 输出: Point(1, 2)

# 使用eval来创建一个新的相同的点对象
new_p = eval(repr(p))

# 检查两个对象是否相同（它们的值）
print(p == new_p)  # 输出: False，因为默认情况下，不同的对象即使属性相同也被认为是不相等的

在上面的例子中，Point 类的 __repr__ 方法返回了一个字符串，这个字符串如果传递给 eval() 函数，将会创建一个新的 Point 对象，其属性和原来的对象相同。

请注意，尽管 eval(repr(obj)) 应该重新创建对象，但在实际编程中，出于安全考虑通常不推荐使用 eval() 函数，因为它可以执行任意代码。此外，为了让 __repr__ 返回的字符串能够被 eval() 正确地执行，所有涉及的对象都必须在当前作用域中是可访问的，并且 __repr__ 方法必须返回一个精确的字符串表示。在实际应用中，__repr__ 更多的是用于调试和日志记录，而不是为了能够通过 eval() 来重新创建对象。

__str__

__str__(self)：非官方的字符串表示，用于用户输出，比如 print 函数。
__str__ 方法定义了一个对象的“非官方”可读字符串表示，它通常用于为用户提供更友好的输出。当你使用 print 函数或者 str() 函数时，Python 会调用对象的 __str__ 方法来获取这个字符串表示。

下面是一个 __str__ 方法的示例：

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

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

# 创建一个人物对象
person = Person("Alice", 30)

# 使用print函数输出对象
print(person)  # 输出: Person named Alice who is 30 years old

# 直接调用str函数获取对象的字符串表示
print(str(person))  # 输出: Person named Alice who is 30 years old

在上面的例子中，Person 类的 __str__ 方法返回了一个描述人物的字符串，这个字符串对用户来说是友好的，包含了人物的名字和年龄。

通常，__str__ 方法返回的字符串更注重可读性，而 __repr__ 方法返回的字符串则注重明确性和一致性，有时可以被用来重新创建对象。如果一个类只定义了 __repr__ 而没有定义 __str__，那么当调用 str() 函数时，Python 会使用 __repr__ 的结果作为替代。因此，建议至少定义一个 __repr__ 方法，以确保即便没有 __str__ 方法，对象也有一个有用的字符串表示。

__format__

__format__(self, format_spec)：定义当使用 format() 函数时对象的格式。
__format__ 方法允许你定义一个对象在使用 format() 函数时应该如何被格式化。你可以在 format_spec 参数中指定格式化选项，然后在 __format__ 方法内部解析这些选项并返回相应的格式化字符串。

下面是一个简单的例子，我们定义了一个 Date 类，并实现了 __format__ 方法，使得我们可以根据不同的格式化指令输出日期的不同字符串表示：

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def __format__(self, format_spec):
        if format_spec == 'short':
            return f"{self.day:02d}/{self.month:02d}/{self.year%100:02d}"
        elif format_spec == 'long':
            return f"{self.day:02d} {self.month_name()} {self.year}"
        else:
            # 默认格式
            return f"{self.year:04d}-{self.month:02d}-{self.day:02d}"

    def month_name(self):
        month_names = [
            "January", "February", "March", "April", "May", "June",
            "July", "August", "September", "October", "November", "December"
        ]
        return month_names[self.month - 1]

# 创建一个日期对象
date = Date(2023, 4, 5)

# 使用format函数和不同的格式规范
print(format(date, 'short'))  # 输出: 05/04/23
print(format(date, 'long'))   # 输出: 05 April 2023
print(format(date))            # 输出: 2023-04-05 (使用默认格式)

在这个例子中，Date 类的 __format__ 方法支持了两种自定义格式 'short' 和 'long'，以及一种默认格式。你可以根据需要实现任何数量的自定义格式化选项。

当你调用 format(obj, format_spec) 函数时，Python 会自动调用 obj 的 __format__ 方法，并将 format_spec 字符串作为参数传递给它。这个方法应该返回一个新的格式化后的字符串。如果 format_spec 是空字符串，则通常意味着应该使用默认的格式化方式。

集合/序列相关

__len__

__len__(self)：返回集合中元素的数量。
__len__ 方法在 Python 中用于定义一个对象的“长度”。对于集合类的对象，如列表、元组、字典等，__len__ 方法通常返回集合中元素的数量。当你调用内置的 len() 函数时，Python 会自动调用对象的 __len__ 方法。

下面是一个自定义集合类 CustomList 的例子，它实现了 __len__ 方法来返回集合中元素的数量：

class CustomList:
    def __init__(self, elements):
        self.elements = elements

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

# 创建一个自定义列表对象
custom_list = CustomList([1, 2, 3, 4, 5])

# 使用len函数获取集合中元素的数量
print(len(custom_list))  # 输出: 5

在这个例子中，CustomList 类有一个名为 elements 的属性，它是一个普通的 Python 列表，用于存储集合中的元素。__len__ 方法简单地返回 self.elements 列表的长度，这是通过调用内置的 len() 函数实现的。

__len__ 方法应该返回一个整数值，表示集合的长度。如果返回的不是一个整数（例如，返回了一个浮点数或字符串），则会引发一个 TypeError 异常。

请注意，__len__ 方法的返回值应该保持在合理的范围内，因为它被设计为返回一个非负整数。如果你的集合表示的是一个非常大的或无限的集合，你可能需要重新考虑是否应该提供 __len__ 方法。

__getitem

__getitem__(self, key)：获取指定键/索引对应的值。
__getitem__ 方法使得对象可以使用索引操作符 [] 来访问其元素。这个方法通常用于序列（如列表或元组）和映射（如字典）类型的对象。当你使用 obj[key] 语法时，Python 会自动调用 obj 的 __getitem__ 方法，并将 key 作为参数传递给它。

下面是一个简单的例子，我们定义了一个 CustomDict 类，该类模拟了字典的行为，并实现了 __getitem__ 方法来根据键获取值：

class CustomDict:
    def __init__(self, data):
        self.data = data

    def __getitem__(self, key):
        if key in self.data:
            return self.data[key]
        else:
            raise KeyError(f"Key {key} not found.")

# 创建一个自定义字典对象
custom_dict = CustomDict({'apple': 'red', 'banana': 'yellow', 'cherry': 'red'})

# 使用索引操作符[]获取指定键对应的值
print(custom_dict['apple'])  # 输出: red
print(custom_dict['banana']) # 输出: yellow

# 尝试获取一个不存在的键将抛出KeyError
# print(custom_dict['orange'])  # KeyError: Key orange not found.

在这个例子中，CustomDict 类有一个名为 data 的属性，它是一个普通的 Python 字典，用于存储键值对。__getitem__ 方法检查给定的键是否存在于 self.data 字典中，如果存在，则返回对应的值；如果不存在，则抛出一个 KeyError 异常。

请注意，__getitem__ 方法还可以用于实现切片操作，如果你的对象支持切片，你需要在 __getitem__ 方法中检查 key 是否是一个 slice 对象，并相应地处理。

__setitem__

__setitem__(self, key, value)：设置指定键/索引对应的值。
__setitem__ 方法允许你使用索引操作符 [] 来设置对象中特定键或索引的值。这个方法通常用于可变的序列和映射类型的对象。当你使用 obj[key] = value 语法时，Python 会自动调用 obj 的 __setitem__ 方法，并将 key 和 value 作为参数传递给它。

下面是一个简单的例子，我们定义了一个 CustomDict 类，该类模拟了字典的行为，并实现了 __setitem__ 方法来根据键设置值：

class CustomDict:
    def __init__(self):
        self.data = {}

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

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

    def __repr__(self):
        return str(self.data)

# 创建一个自定义字典对象
custom_dict = CustomDict()

# 使用索引操作符[]设置键值对
custom_dict['apple'] = 'red'
custom_dict['banana'] = 'yellow'

# 使用__getitem__方法或索引操作符[]获取值
print(custom_dict['apple'])  # 输出: red
print(custom_dict)  # 输出: {'apple': 'red', 'banana': 'yellow'}

在这个例子中，CustomDict 类有一个名为 data 的属性，它是一个普通的 Python 字典，用于存储键值对。__setitem__ 方法将键值对设置到 self.data 字典中。如果键已经存在，它将更新对应的值；如果键不存在，它将创建一个新的键值对。

__getitem__ 方法用于获取键对应的值，而 __repr__ 方法提供了一个简单的字符串表示，用于打印 CustomDict 对象时显示其内容。

这种方式允许你像操作普通字典一样操作 CustomDict 类的实例，包括设置和获取键值对。

__delitem__

__delitem__(self, key)：删除指定键/索引对应的值。
__delitem__ 方法允许你使用 del 语句来删除对象中特定键或索引对应的值。这个方法通常用于可变的序列和映射类型的对象。当你使用 del obj[key] 语法时，Python 会自动调用 obj 的 __delitem__ 方法，并将 key 作为参数传递给它。

下面是一个简单的例子，我们定义了一个 CustomDict 类，该类模拟了字典的行为，并实现了 __delitem__ 方法来根据键删除键值对：

class CustomDict:
    def __init__(self):
        self.data = {}

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

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

    def __delitem__(self, key):
        if key in self.data:
            del self.data[key]
        else:
            raise KeyError(f"Key {key} not found.")

    def __repr__(self):
        return str(self.data)

# 创建一个自定义字典对象
custom_dict = CustomDict()

# 使用索引操作符[]设置键值对
custom_dict['apple'] = 'red'
custom_dict['banana'] = 'yellow'

print(custom_dict)  # 输出: {'apple': 'red', 'banana': 'yellow'}

# 使用del语句删除一个键值对
del custom_dict['apple']

print(custom_dict)  # 输出: {'banana': 'yellow'}

# 尝试删除一个不存在的键将抛出KeyError
# del custom_dict['orange']  # KeyError: Key orange not found.

在这个例子中，CustomDict 类有一个名为 data 的属性，它是一个普通的 Python 字典，用于存储键值对。__delitem__ 方法检查给定的键是否存在于 self.data 字典中，如果存在，则使用 del 语句删除对应的键值对；如果不存在，则抛出一个 KeyError 异常。

__setitem__ 和 __getitem__ 方法分别用于设置和获取键对应的值，而 __repr__ 方法提供了一个简单的字符串表示，用于打印 CustomDict 对象时显示其内容。

这种方式允许你像操作普通字典一样操作 CustomDict 类的实例，包括设置、获取和删除键值对。

__iter__

__iter__(self)：返回对象的迭代器。
__iter__ 方法使得一个对象成为可迭代的，也就是说，你可以在这个对象上使用 for 循环。当你定义了 __iter__ 方法后，该方法需要返回一个迭代器，这个迭代器必须实现 __next__ 方法。

以下是一个 CustomDict 类的实现，它包含了 __iter__ 方法，使得我们可以迭代其内部数据 data 的键：

class CustomDict:
    def __init__(self):
        self.data = {}

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

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

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

    def __repr__(self):
        return str(self.data)

# 创建一个自定义字典对象
custom_dict = CustomDict()

# 使用索引操作符[]设置键值对
custom_dict['apple'] = 'red'
custom_dict['banana'] = 'yellow'
custom_dict['cherry'] = 'red'

# 迭代 custom_dict 的键
for key in custom_dict:
    print(f"{key}: {custom_dict[key]}")

# 输出:
# apple: red
# banana: yellow
# cherry: red

在这个例子中，__iter__ 方法通过调用 iter(self.data) 返回了 self.data 字典的迭代器。因为字典本身就是可迭代的，所以我们可以直接返回其迭代器。这样，当我们在 CustomDict 对象上进行迭代时，实际上是在迭代内部字典的键。

请注意，迭代器必须实现 __next__ 方法，但在这个例子中，我们直接使用了字典的迭代器，它已经实现了 __next__ 方法，所以我们不需要自己定义它。

当使用 for 循环迭代 custom_dict 时，for 循环会自动调用 __iter__ 方法来获取迭代器，并在每次循环中调用迭代器的 __next__ 方法来获取下一个元素，直到迭代结束。

__reversed__

__reversed__(self)：定义对象被 reversed() 调用时的行为。
__reversed__ 方法允许你定义一个对象在被 reversed() 函数调用时的行为。这个方法应该返回一个迭代器，该迭代器按相反的顺序产生对象的元素。

下面是一个 CustomList 类的例子，它实现了 __reversed__ 方法，使得我们可以使用 reversed() 函数来反转列表中的元素：

class CustomList:
    def __init__(self, initial_data=[]):
        self.data = initial_data

    def __repr__(self):
        return str(self.data)

    def __reversed__(self):
        return reversed(self.data)

# 创建一个自定义列表对象
custom_list = CustomList([1, 2, 3, 4, 5])

# 使用 reversed() 函数来反转列表中的元素
for item in reversed(custom_list):
    print(item)

# 输出:
# 5
# 4
# 3
# 2
# 1

在这个例子中，CustomList 类有一个名为 data 的属性，它是一个普通的 Python 列表，用于存储元素。__reversed__ 方法通过调用 reversed(self.data) 返回了 self.data 列表的反向迭代器。因为列表本身支持反向迭代，所以我们可以直接返回其反向迭代器。

当我们在 CustomList 对象上使用 reversed() 函数时，reversed() 函数会自动调用 __reversed__ 方法来获取反向迭代器，并通过这个迭代器按相反的顺序产生列表的元素。

请注意，如果你没有在类中实现 __reversed__ 方法，但类实现了 __len__ 和 __getitem__ 方法，那么 reversed() 函数会尝试使用这两个方法来创建一个反向迭代器。如果你的类有特殊的反向迭代需求，或者你想提供比默认行为更高效的实现，那么实现 __reversed__ 方法会是一个好选择。

__contains__

__contains__(self, item)：定义 in 操作符的行为。
__contains__ 方法使得你可以自定义 in 操作符的行为，它应该返回一个布尔值，指示给定的元素是否包含在对象中。当你使用 in 关键字来检查成员资格时，Python 会调用这个方法。

以下是一个简单的 CustomContainer 类的例子，该类实现了 __contains__ 方法，使得我们可以使用 in 操作符来检查一个元素是否在自定义容器中：

class CustomContainer:
    def __init__(self, elements):
        self._elements = elements

    def __contains__(self, item):
        return item in self._elements

# 创建一个自定义容器对象
container = CustomContainer([1, 2, 3, 4, 5])

# 检查元素是否在容器中
print(2 in container)  # 输出: True
print(6 in container)  # 输出: False

在这个例子中，CustomContainer 类有一个名为 _elements 的属性，它是一个普通的 Python 列表，用于存储元素。__contains__ 方法通过检查 item 是否在 _elements 列表中来实现成员资格测试，并返回相应的布尔值。

当我们使用 in 关键字时，Python 会自动调用 __contains__ 方法，并传入要检查的元素。如果 __contains__ 方法返回 True，则表示元素在容器中；如果返回 False，则表示元素不在容器中。

如果你没有在类中实现 __contains__ 方法，但类实现了 __iter__ 或 __getitem__ 方法，那么 in 操作符将会默认遍历对象的元素来检查成员资格。如果你的类有特殊的成员资格检查需求，或者你想提供比默认行为更高效的实现，那么实现 __contains__ 方法会是一个好选择。

算术运算符

__add__

__add__(self, other)：加法操作符。
__add__ 方法允许你定义加法操作符 + 的行为。当你的对象需要支持加法操作时，你可以实现这个方法来定义加法应该如何进行。

以下是一个 Vector 类的例子，该类表示二维向量，并实现了 __add__ 方法来实现向量的加法：

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

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        else:
            raise ValueError("Both operands must be Vector instances")

# 创建两个向量对象
v1 = Vector(2, 3)
v2 = Vector(5, 7)

# 使用加法操作符来计算两个向量的和
v3 = v1 + v2

print(v3)  # 输出: Vector(7, 10)

在这个例子中，Vector 类有两个属性 x 和 y，分别表示向量的水平和垂直分量。__add__ 方法接收另一个 Vector 对象 other 作为参数，并返回两个向量分量相加后的新 Vector 对象。

当我们使用加法操作符 + 时，Python 会自动调用 __add__ 方法，并传入右侧的操作数。如果 other 不是 Vector 的实例，__add__ 方法会抛出一个 ValueError 异常。

如果你的类需要支持与其他数据类型的加法操作（例如，与数字的加法），你可以在 __add__ 方法中添加额外的逻辑来处理这些情况。如果你没有实现 __add__ 方法，而尝试使用 + 操作符，Python 将会抛出一个 TypeError 异常。

__sub__

__sub__(self, other)：减法操作符。
__sub__ 方法允许你定义减法操作符 - 的行为。当你的对象需要支持减法操作时，你可以实现这个方法来定义减法应该如何进行。

以下是一个 Vector 类的例子，该类表示二维向量，并实现了 __sub__ 方法来实现向量的减法：

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

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

    def __sub__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x - other.x, self.y - other.y)
        else:
            raise ValueError("Both operands must be Vector instances")

# 创建两个向量对象
v1 = Vector(5, 7)
v2 = Vector(2, 3)

# 使用减法操作符来计算两个向量的差
v3 = v1 - v2

print(v3)  # 输出: Vector(3, 4)

在这个例子中，Vector 类有两个属性 x 和 y，分别表示向量的水平和垂直分量。__sub__ 方法接收另一个 Vector 对象 other 作为参数，并返回两个向量分量相减后的新 Vector 对象。

当我们使用减法操作符 - 时，Python 会自动调用 __sub__ 方法，并传入右侧的操作数。如果 other 不是 Vector 的实例，__sub__ 方法会抛出一个 ValueError 异常。

如果你的类需要支持与其他数据类型的减法操作（例如，与数字的减法），你可以在 __sub__ 方法中添加额外的逻辑来处理这些情况。如果你没有实现 __sub__ 方法，而尝试使用 - 操作符，Python 将会抛出一个 TypeError 异常。

__mul__

__mul__(self, other)：乘法操作符。
__mul__ 方法允许你定义乘法操作符 * 的行为。当你的对象需要支持乘法操作时，你可以实现这个方法来定义乘法应该如何进行。

以下是一个 Vector 类的例子，该类表示二维向量，并实现了 __mul__ 方法来实现向量与标量的乘法，以及向量与向量的点积（dot product）：

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

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

    def __mul__(self, other):
        if isinstance(other, Vector):
            # 如果 other 是 Vector，执行点积
            return self.x * other.x + self.y * other.y
        elif isinstance(other, (int, float)):
            # 如果 other 是数字，执行标量乘法
            return Vector(self.x * other, self.y * other)
        else:
            raise TypeError("Operand must be a Vector, int, or float")

    def __rmul__(self, other):
        # 这使得左乘标量也能够工作
        return self.__mul__(other)

# 创建一个向量对象
v1 = Vector(3, 4)

# 使用乘法操作符来与标量相乘
v2 = v1 * 2
print(v2)  # 输出: Vector(6, 8)

# 使用乘法操作符来计算两个向量的点积
v3 = Vector(2, 3)
dot_product = v1 * v3
print(dot_product)  # 输出: 18

# 由于实现了 __rmul__，可以将标量放在左侧
v4 = 2 * v1
print(v4)  # 输出: Vector(6, 8)

在这个例子中，Vector 类有两个属性 x 和 y，分别表示向量的水平和垂直分量。__mul__ 方法接收另一个对象 other 作为参数，并根据 other 的类型执行不同的操作：

• 如果 other 是 Vector 的实例，方法执行点积，返回一个数值。
• 如果 other 是 int 或 float 类型，方法执行标量乘法，返回一个新的 Vector 对象，其分量是原向量分量与标量的乘积。
• 如果 other 不是 Vector、int 或 float，方法抛出一个 TypeError 异常。

__rmul__ 方法是 __mul__ 的反射（或右侧）版本，它确保了当 Vector 对象在乘法操作符的右侧时，乘法仍然可以正确地执行。这对于标量与 Vector 对象的乘法是必要的，因为 Python 会首先尝试左侧对象的 __mul__ 方法。如果不存在或不适用，它会尝试右侧对象的 __rmul__ 方法。

__truediv__

__truediv__(self, other)：真除法操作符。
__truediv__ 方法定义了使用真除法操作符 / 时的行为。真除法总是返回一个浮点数，即使两个操作数都是整数。当你的对象需要支持除法操作时，你可以实现这个方法。

以下是一个 Fraction 类的例子，该类表示分数，并实现了 __truediv__ 方法来执行两个分数的除法：

class Fraction:
    def __init__(self, numerator, denominator):
        self.numerator = numerator
        self.denominator = denominator

    def __repr__(self):
        return f"Fraction({self.numerator}, {self.denominator})"

    def __truediv__(self, other):
        if isinstance(other, Fraction):
            # 如果 other 是 Fraction，执行分数之间的除法
            # (a/b) / (c/d) = (a*d) / (b*c)
            new_numerator = self.numerator * other.denominator
            new_denominator = self.denominator * other.numerator
            return Fraction(new_numerator, new_denominator)
        else:
            raise TypeError("Operand must be a Fraction")

# 创建两个分数对象
f1 = Fraction(1, 2)  # 表示 1/2
f2 = Fraction(3, 4)  # 表示 3/4

# 使用真除法操作符来执行两个分数的除法
f3 = f1 / f2
print(f3)  # 输出: Fraction(4, 6)

在这个例子中，Fraction 类有两个属性 numerator 和 denominator，分别表示分数的分子和分母。__truediv__ 方法接收另一个对象 other 作为参数，并根据 other 的类型执行除法操作：

• 如果 other 是 Fraction 的实例，方法执行两个分数之间的除法，并返回一个新的 Fraction 对象，其分子是原分数的分子乘以 other 分数的分母，分母是原分数的分母乘以 other 分数的分子。
• 如果 other 不是 Fraction 的实例，方法抛出一个 TypeError 异常。

请注意，这个例子中的 Fraction 类没有考虑分数的约简和负数处理，实际使用时你可能需要增加这些功能。此外，如果你希望支持分数与整数或浮点数之间的除法，你需要在 __truediv__ 方法中添加相应的逻辑。

__floordiv__

__floordiv__(self, other)：地板除法操作符。
__floordiv__ 方法定义了使用地板除法操作符 // 时的行为。地板除法会执行除法运算并返回结果向下取整到最接近的整数值。这在定义整数除法或需要取整结果的类时很有用。

以下是一个 Vector 类的例子，该类表示二维向量，并实现了 __floordiv__ 方法来执行向量与标量的地板除法：

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

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

    def __floordiv__(self, other):
        if isinstance(other, (int, float)):
            # 如果 other 是 int 或 float，执行地板除法
            return Vector(self.x // other, self.y // other)
        else:
            raise TypeError("Operand must be an int or float")

# 创建一个向量对象
v1 = Vector(10, 20)

# 使用地板除法操作符来执行向量与标量的地板除法
v2 = v1 // 3
print(v2)  # 输出: Vector(3, 6)

在这个例子中，Vector 类有两个属性 x 和 y，分别表示向量的水平和垂直分量。__floordiv__ 方法接收另一个对象 other 作为参数，并根据 other 的类型执行地板除法操作：

• 如果 other 是 int 或 float 类型，方法执行地板除法，并返回一个新的 Vector 对象，其分量是原向量分量与标量的地板除法结果。
• 如果 other 不是 int 或 float 类型，方法抛出一个 TypeError 异常。

请注意，地板除法仅适用于数值类型，因此在这个例子中，我们没有为 Vector 对象之间的地板除法提供实现。如果你需要支持这种操作，你可以添加相应的逻辑。

__mod__

__mod__(self, other)：模除操作符。
在Python中，__mod__ 方法是魔术方法，用于定义一个类的实例如何响应 % 模除操作符。当你使用 % 对类的实例进行模除操作时，Python 会自动调用这个方法。

下面是一个简单的示例，我们定义一个 Clock 类，表示一个时钟，它可以通过 % 操作符来计算时间的模（例如，分钟数对60取模等于分钟数）：

class Clock:
    def __init__(self, hour, minutes):
        self.hour = hour
        self.minutes = minutes

    def __str__(self):
        return f"{self.hour:02d}:{self.minutes:02d}"

    def __mod__(self, other):
        if isinstance(other, int):
            total_minutes = (self.hour * 60 + self.minutes) % other
            return Clock(total_minutes // 60, total_minutes % 60)
        else:
            raise TypeError("Modulo by non-int is not supported")

# 使用Clock类
clock = Clock(5, 45)  # 表示5:45
print(clock)  # 输出: 05:45

# 使用 % 操作符来计算模
mod_clock = clock % 60  # 模60
print(mod_clock)  # 输出: 00:45

mod_clock = clock % 30  # 模30
print(mod_clock)  # 输出: 00:15

在这个例子中，Clock 类有一个 __mod__ 方法，它接受一个整数 other 作为参数，然后计算当前时间的分钟数对这个整数取模的结果，并返回一个新的 Clock 实例，表示模除后的时间。

请注意，我们在 __mod__ 方法中进行了类型检查，以确保我们只对整数进行模除操作。如果尝试对非整数进行操作，它将引发一个 TypeError。

__pow__

__pow__(self, other[, modulo])：幂运算符。
在Python中，__pow__ 方法用于定义一个类的实例如何响应 ** (幂) 运算符。此外，__pow__ 方法可以接受一个可选的 modulo 参数，允许进行幂运算后的模运算。

下面是一个简单的示例，定义一个 MyNumber 类，它可以处理幂运算：

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

    def __pow__(self, exponent, modulo=None):
        if modulo is None:
            # 不带模的幂运算
            return MyNumber(self.value ** exponent)
        else:
            # 带模的幂运算
            return MyNumber(pow(self.value, exponent, modulo))

# 使用 MyNumber 类
num = MyNumber(2)

# 不带模的幂运算
result = num ** 3
print(result.value)  # 输出: 8

# 带模的幂运算
mod_result = pow(num, 3, 5)  # 等同于 (num ** 3) % 5
print(mod_result.value)  # 输出: 3

# 直接使用 ** 运算符和模运算
mod_result_direct = (num ** 3) % 5
print(mod_result_direct.value)  # 输出: 3

在这个例子中，MyNumber 类有一个 __pow__ 方法，它接受一个指数 exponent 和一个可选的模 modulo 作为参数。如果没有提供 modulo 参数，方法只执行幂运算。如果提供了 modulo 参数，它将执行幂运算后的模运算。

请注意，当使用内置的 pow 函数并传入三个参数时，__pow__ 方法会自动接受这三个参数。这是因为 pow 函数也可以接受三个参数：底数、指数和模数。在 MyNumber 类的 __pow__ 方法中，我们使用了内置的 pow 函数来处理带模的幂运算。

另外，虽然在上面的例子中我们没有直接使用 ** 运算符和模运算的组合，但是可以通过先进行幂运算然后使用 % 运算符来获得相同的结果。在 mod_result_direct 的计算中，我们展示了这种用法。

__lshift__

__lshift__(self, other)：左移操作符。
在Python中，__lshift__ 方法用于定义一个类的实例如何响应 << (左移) 运算符。左移操作通常用于整数类型，其中它将整数的位向左移动指定的位数。在自定义类中，我们可以给 << 操作符赋予特定的含义。

以下是一个示例，定义了一个 BitString 类，它表示一个简单的二进制字符串，并实现了左移操作：

class BitString:
    def __init__(self, bits):
        self.bits = bits

    def __str__(self):
        return self.bits

    def __lshift__(self, shift_by):
        # 将二进制字符串向左移动指定的位数
        shifted_bits = self.bits[shift_by:] + '0' * shift_by
        return BitString(shifted_bits)

# 使用 BitString 类
bitstring = BitString('1011')

# 使用 << 操作符进行左移
shifted_bitstring = bitstring << 2
print(shifted_bitstring)  # 输出: 1100

在这个例子中，BitString 类有一个 __lshift__ 方法，它接受一个参数 shift_by，表示要左移的位数。该方法将原始二进制字符串向左移动 shift_by 位，并在末尾添加相应数量的 0 以保持字符串长度不变。然后，它返回一个新的 BitString 实例，表示左移后的二进制字符串。

当你使用 << 操作符时，Python会自动调用 __lshift__ 方法。在上面的代码中，bitstring << 2 调用了 bitstring 实例的 __lshift__ 方法，并且 2 作为参数传递给 shift_by。结果是，'1011' 被左移两位，变成了 '1100'。

__rshift__

__rshift__(self, other)：右移操作符。
在Python中，__rshift__ 方法用于定义一个类的实例如何响应 >> (右移) 运算符。右移操作通常用于整数类型，其中它将整数的位向右移动指定的位数。在自定义类中，我们可以给 >> 操作符赋予特定的含义。

以下是一个示例，定义了一个 BitString 类，它表示一个简单的二进制字符串，并实现了右移操作：

class BitString:
    def __init__(self, bits):
        self.bits = bits

    def __str__(self):
        return self.bits

    def __rshift__(self, shift_by):
        # 将二进制字符串向右移动指定的位数
        shifted_bits = '0' * shift_by + self.bits[:-shift_by]
        return BitString(shifted_bits)

# 使用 BitString 类
bitstring = BitString('1011')

# 使用 >> 操作符进行右移
shifted_bitstring = bitstring >> 2
print(shifted_bitstring)  # 输出: 0010

在这个例子中，BitString 类有一个 __rshift__ 方法，它接受一个参数 shift_by，表示要右移的位数。该方法将原始二进制字符串向右移动 shift_by 位，并在开头添加相应数量的 0 以保持字符串长度不变。然后，它返回一个新的 BitString 实例，表示右移后的二进制字符串。

当你使用 >> 操作符时，Python会自动调用 __rshift__ 方法。在上面的代码中，bitstring >> 2 调用了 bitstring 实例的 __rshift__ 方法，并且 2 作为参数传递给 shift_by。结果是，'1011' 被右移两位，变成了 '0010'。请注意，右移通常会丢弃被移出的位，并在左侧添加零。在这个简单的示例中，我们假设这是一个无符号的位移，所以我们在左侧添加零。

__and__

__and__(self, other)：按位与操作符。
在Python中，__and__ 方法用于定义一个类的实例如何响应 & (按位与) 运算符。按位与操作通常用于整数类型，其中它对两个整数的二进制表示进行按位与操作。在自定义类中，我们可以给 & 操作符赋予特定的含义。

以下是一个示例，定义了一个 BitString 类，它表示一个简单的二进制字符串，并实现了按位与操作：

class BitString:
    def __init__(self, bits):
        self.bits = bits

    def __str__(self):
        return self.bits

    def __and__(self, other):
        # 执行按位与操作
        # 确保两个操作数的长度相同
        length = min(len(self.bits), len(other.bits))
        and_result = ''.join(['1' if self.bits[i] == '1' and other.bits[i] == '1' else '0'
                              for i in range(length)])
        # 可能需要在结果前面填充0，以匹配最长的操作数
        and_result = '0' * (max(len(self.bits), len(other.bits)) - length) + and_result
        return BitString(and_result)

# 使用 BitString 类
bitstring1 = BitString('1011')
bitstring2 = BitString('1101')

# 使用 & 操作符进行按位与
result_bitstring = bitstring1 & bitstring2
print(result_bitstring)  # 输出: 1001

在这个例子中，BitString 类有一个 __and__ 方法，它接受另一个 BitString 实例作为参数 other，并执行按位与操作。该方法遍历两个二进制字符串的每一位，并且只有当两个字符串在相同位置上都是 1 时，结果字符串的对应位置才是 1；否则是 0。

当你使用 & 操作符时，Python会自动调用 __and__ 方法。在上面的代码中，bitstring1 & bitstring2 调用了 bitstring1 实例的 __and__ 方法，并且 bitstring2 作为参数传递给 other。结果是，两个二进制字符串 '1011' 和 '1101' 进行按位与操作，得到 '1001'。

请注意，为了简化示例，代码假设两个 BitString 实例的长度相同。在实际应用中，你可能需要处理不同长度的二进制字符串，并适当地填充它们以匹配最长的字符串。在上述代码中，这是通过在结果字符串前面添加 0 来实现的，以确保结果的长度与最长的操作数相同。

__or__

__or__(self, other)：按位或操作符。
在Python中，__or__ 方法用于定义一个类的实例如何响应 | (按位或) 运算符。按位或操作通常用于整数类型，其中它对两个整数的二进制表示进行按位或操作。在自定义类中，我们可以给 | 操作符赋予特定的含义。

以下是一个示例，定义了一个 BitString 类，它表示一个简单的二进制字符串，并实现了按位或操作：

class BitString:
    def __init__(self, bits):
        self.bits = bits

    def __str__(self):
        return self.bits

    def __or__(self, other):
        # 执行按位或操作
        # 确保两个操作数的长度相同
        length = min(len(self.bits), len(other.bits))
        or_result = ''.join(['1' if self.bits[i] == '1' or other.bits[i] == '1' else '0'
                             for i in range(length)])
        # 可能需要在结果前面填充0或1，以匹配最长的操作数
        if len(self.bits) > len(other.bits):
            or_result = self.bits[:len(self.bits) - length] + or_result
        else:
            or_result = other.bits[:len(other.bits) - length] + or_result
        return BitString(or_result)

# 使用 BitString 类
bitstring1 = BitString('1010')
bitstring2 = BitString('1100')

# 使用 | 操作符进行按位或
result_bitstring = bitstring1 | bitstring2
print(result_bitstring)  # 输出: 1110

在这个例子中，BitString 类有一个 __or__ 方法，它接受另一个 BitString 实例作为参数 other，并执行按位或操作。该方法遍历两个二进制字符串的每一位，并且如果两个字符串中任意一个在相同位置上是 1，则结果字符串的对应位置就是 1；如果都是 0，则结果是 0。

当你使用 | 操作符时，Python会自动调用 __or__ 方法。在上面的代码中，bitstring1 | bitstring2 调用了 bitstring1 实例的 __or__ 方法，并且 bitstring2 作为参数传递给 other。结果是，两个二进制字符串 '1010' 和 '1100' 进行按位或操作，得到 '1110'。

请注意，为了简化示例，代码假设两个 BitString 实例的长度相同。在实际应用中，你可能需要处理不同长度的二进制字符串，并适当地填充它们以匹配最长的字符串。在上述代码中，这是通过在结果字符串前面添加来自最长操作数的对应位来实现的，以确保结果的长度与最长的操作数相同。

__xor__

__xor__(self, other)：按位异或操作符。
在Python中，__xor__ 方法用于定义一个类的实例如何响应 ^ (按位异或) 运算符。按位异或操作对两个整数的二进制表示进行按位异或操作，即对应位相同则结果为0，不同则为1。

以下是一个示例，定义了一个 BitString 类，它表示一个简单的二进制字符串，并实现了按位异或操作：

class BitString:
    def __init__(self, bits):
        self.bits = bits

    def __str__(self):
        return self.bits

    def __xor__(self, other):
        # 执行按位异或操作
        # 确保两个操作数的长度相同
        length = min(len(self.bits), len(other.bits))
        xor_result = ''.join(['0' if self.bits[i] == other.bits[i] else '1'
                             for i in range(length)])
        # 可能需要在结果前面填充0，以匹配最长的操作数
        if len(self.bits) > len(other.bits):
            xor_result = self.bits[:len(self.bits) - length] + xor_result
        elif len(self.bits) < len(other.bits):
            xor_result = other.bits[:len(other.bits) - length] + xor_result
        return BitString(xor_result)

# 使用 BitString 类
bitstring1 = BitString('1010')
bitstring2 = BitString('1100')

# 使用 ^ 操作符进行按位异或
result_bitstring = bitstring1 ^ bitstring2
print(result_bitstring)  # 输出: 0110

在这个例子中，BitString 类有一个 __xor__ 方法，它接受另一个 BitString 实例作为参数 other，并执行按位异或操作。该方法遍历两个二进制字符串的每一位，并且如果两个字符串在相同位置上的位相同，则结果字符串的对应位置是 0；如果不同，则结果是 1。

当你使用 ^ 操作符时，Python会自动调用 __xor__ 方法。在上面的代码中，bitstring1 ^ bitstring2 调用了 bitstring1 实例的 __xor__ 方法，并且 bitstring2 作为参数传递给 other。结果是，两个二进制字符串 '1010' 和 '1100' 进行按位异或操作，得到 '0110'。

请注意，为了简化示例，代码假设两个 BitString 实例的长度相同。在实际应用中，你可能需要处理不同长度的二进制字符串，并适当地填充它们以匹配最长的字符串。在上述代码中，这是通过在结果字符串前面添加 0 来实现的，以确保结果的长度与最长的操作数相同。

反向算术运算符

__radd__

__radd__(self, other)：加法的反向运算符。
在Python中，__radd__ 方法定义了一个对象如何响应加法操作，当它在加法表达式的右边时。通常，a + b 调用 a 的 __add__ 方法。但是，如果 a 没有定义 __add__ 方法，或者 __add__ 方法不支持与 b 的加法操作（即返回 NotImplemented），那么Python会尝试调用 b 的 __radd__ 方法。

以下是一个示例，定义了一个 Point 类，它表示二维空间中的点，并实现了 __add__ 和 __radd__ 方法，以便可以将两个点相加，或者将点与元组相加：

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

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __add__(self, other):
        if isinstance(other, Point):
            return Point(self.x + other.x, self.y + other.y)
        return NotImplemented

    def __radd__(self, other):
        if isinstance(other, (tuple, list)) and len(other) == 2:
            return Point(self.x + other[0], self.y + other[1])
        return NotImplemented

# 使用 Point 类
point1 = Point(1, 2)
point2 = Point(3, 4)

# 使用 + 操作符进行加法
result_point = point1 + point2
print(result_point)  # 输出: (4, 6)

# 反向加法：将元组（或列表）与 Point 对象相加
tuple_point = (5, 6)
result_point = tuple_point + point1
print(result_point)  # 输出: (6, 8)

在上述代码中，Point 类定义了 __add__ 方法来处理两个 Point 实例相加的情况。它还定义了 __radd__ 方法来处理当 Point 实例在加法表达式的右边时的情况，例如，当它与一个元组相加时。

当 tuple_point + point1 执行时，由于元组没有定义 __add__ 方法来与 Point 实例相加，因此Python尝试调用 point1 的 __radd__ 方法，将 tuple_point 作为参数传递。结果是，元组 (5, 6) 和 Point 实例 (1, 2) 相加，得到新的 Point 实例 (6, 8)。

请注意，__radd__ 方法通常用于使自定义对象能够与内置类型或其他自定义类型进行互操作。在实际应用中，你可能需要考虑更多的错误检查和边界情况来确保代码的健壮性。

__rsub__

__rsub__(self, other)：减法的反向运算符。
在Python中，__rsub__ 方法定义了一个对象如何响应减法操作，当它在减法表达式的右边时。通常，a - b 调用 a 的 __sub__ 方法。但是，如果 a 没有定义 __sub__ 方法，或者 __sub__ 方法不支持与 b 的减法操作（即返回 NotImplemented），那么Python会尝试调用 b 的 __rsub__ 方法。

以下是一个示例，定义了一个 Point 类，它表示二维空间中的点，并实现了 __sub__ 和 __rsub__ 方法，以便可以将两个点相减，或者用元组减去一个点：

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

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __sub__(self, other):
        if isinstance(other, Point):
            return Point(self.x - other.x, self.y - other.y)
        return NotImplemented

    def __rsub__(self, other):
        if isinstance(other, (tuple, list)) and len(other) == 2:
            return Point(other[0] - self.x, other[1] - self.y)
        return NotImplemented

# 使用 Point 类
point1 = Point(1, 2)
point2 = Point(3, 4)

# 使用 - 操作符进行减法
result_point = point2 - point1
print(result_point)  # 输出: (2, 2)

# 反向减法：用元组（或列表）减去 Point 对象
tuple_point = (5, 6)
result_point = tuple_point - point1
print(result_point)  # 输出: (4, 4)

在上述代码中，Point 类定义了 __sub__ 方法来处理两个 Point 实例相减的情况。它还定义了 __rsub__ 方法来处理当 Point 实例在减法表达式的右边时的情况，例如，用一个元组减去 Point 实例。

当 tuple_point - point1 执行时，由于元组没有定义 __sub__ 方法来与 Point 实例相减，因此Python尝试调用 point1 的 __rsub__ 方法，将 tuple_point 作为参数传递。结果是，元组 (5, 6) 减去 Point 实例 (1, 2)，得到新的 Point 实例 (4, 4)。

请注意，__rsub__ 方法通常用于使自定义对象能够与内置类型或其他自定义类型进行互操作。在实际应用中，你可能需要考虑更多的错误检查和边界情况来确保代码的健壮性。

__rmul__

__rmul__(self, other)：乘法的反向运算符。
在Python中，__rmul__ 方法定义了一个对象如何响应乘法操作，当它在乘法表达式的右边时。通常，a * b 调用 a 的 __mul__ 方法。但是，如果 a 没有定义 __mul__ 方法，或者 __mul__ 方法不支持与 b 的乘法操作（即返回 NotImplemented），那么Python会尝试调用 b 的 __rmul__ 方法。

以下是一个示例，定义了一个 Point 类，它表示二维空间中的点，并实现了 __mul__ 和 __rmul__ 方法，以便可以将点与一个数值相乘，或者将数值与点相乘：

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

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __mul__(self, other):
        if isinstance(other, (int, float)):
            return Point(self.x * other, self.y * other)
        return NotImplemented

    def __rmul__(self, other):
        return self.__mul__(other)

# 使用 Point 类
point = Point(1, 2)

# 使用 * 操作符进行乘法
result_point = point * 3
print(result_point)  # 输出: (3, 6)

# 反向乘法：用数值乘以 Point 对象
scalar = 4
result_point = scalar * point
print(result_point)  # 输出: (4, 8)

在上述代码中，Point 类定义了 __mul__ 方法来处理 Point 实例与数值相乘的情况。它还定义了 __rmul__ 方法来处理当 Point 实例在乘法表达式的右边时的情况，例如，用一个数值乘以 Point 实例。

在这个例子中，__rmul__ 方法直接调用了 __mul__ 方法，因为乘法操作是可交换的，即 scalar * point 和 point * scalar 应该产生相同的结果。

当执行 point * 3 时，调用 point 的 __mul__ 方法。当执行 4 * point 时，由于整数没有定义与 Point 实例相乘的方法，所以Python调用 point 的 __rmul__ 方法，得到相同的结果。

请注意，__rmul__ 方法通常用于使自定义对象能够与内置类型或其他自定义类型进行互操作。在实际应用中，你可能需要考虑更多的错误检查和边界情况来确保代码的健壮性。

增量赋值运算符

__iadd__

__iadd__(self, other)：加法的增量赋值操作符（例如 +=）。
在Python中，__iadd__ 方法定义了一个对象如何响应增量赋值操作符（例如 +=）。它允许对象在原地进行修改，而不是创建一个新的对象。

以下是一个示例，定义了一个 Point 类，它表示二维空间中的点，并实现了 __iadd__ 方法，以便可以将点与另一个点相加并进行原地修改：

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

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __iadd__(self, other):
        if isinstance(other, Point):
            self.x += other.x
            self.y += other.y
            return self
        return NotImplemented

# 使用 Point 类
point1 = Point(1, 2)
point2 = Point(3, 4)

# 使用 += 操作符进行增量赋值加法
point1 += point2
print(point1)  # 输出: (4, 6)

在上述代码中，Point 类定义了 __iadd__ 方法来处理 Point 实例与另一个 Point 实例相加并进行原地修改的情况。

当执行 point1 += point2 时，调用 point1 的 __iadd__ 方法。该方法将 point2 的 x 和 y 值分别加到 point1 的 x 和 y 值上，并返回修改后的 point1 对象。

请注意，__iadd__ 方法通常用于使自定义对象能够支持增量赋值操作符。在实际应用中，你可能需要考虑更多的错误检查和边界情况来确保代码的健壮性。

__isub__

__isub__(self, other)：减法的增量赋值操作符。
在Python中，__isub__ 方法定义了一个对象如何响应减法的增量赋值操作符（例如 -=）。它允许对象在原地进行修改，而不是创建一个新的对象。

以下是一个示例，定义了一个 Point 类，它表示二维空间中的点，并实现了 __isub__ 方法，以便可以将点与另一个点相减并进行原地修改：

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

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __isub__(self, other):
        if isinstance(other, Point):
            self.x -= other.x
            self.y -= other.y
            return self
        return NotImplemented

# 使用 Point 类
point1 = Point(1, 2)
point2 = Point(3, 4)

# 使用 -= 操作符进行增量赋值减法
point1 -= point2
print(point1)  # 输出: (-2, -2)

在上述代码中，Point 类定义了 __isub__ 方法来处理 Point 实例与另一个 Point 实例相减并进行原地修改的情况。

当执行 point1 -= point2 时，调用 point1 的 __isub__ 方法。该方法将 point2 的 x 和 y 值分别从 point1 的 x 和 y 值中减去，并返回修改后的 point1 对象。

请注意，__isub__ 方法通常用于使自定义对象能够支持减法的增量赋值操作符。在实际应用中，你可能需要考虑更多的错误检查和边界情况来确保代码的健壮性。

• …（与上面的算术运算符对应）

一元运算符和函数

__neg__

__neg__(self)：定义负号（-）的行为。
在Python中，__neg__ 方法定义了一个对象如何响应负号（-）操作符。它返回对象的负数形式。

以下是一个示例，定义了一个 Vector 类，它表示二维向量，并实现了 __neg__ 方法，以便可以对向量进行取负操作：

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

    def __str__(self):
        return f"({self.x}, {self.y})"

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

# 使用 Vector 类
v1 = Vector(1, 2)

# 使用负号操作符取负
v2 = -v1
print(v2)  # 输出: (-1, -2)

在上述代码中，Vector 类定义了 __neg__ 方法来处理向量对象的负号操作。

当执行 -v1 时，调用 v1 的 __neg__ 方法。该方法返回一个新的 Vector 对象，其 x 和 y 值为原始向量的相反数。

请注意，__neg__ 方法通常用于使自定义对象能够支持负号操作符。在实际应用中，你可能需要根据对象的特定需求来定义负号操作的行为。

__pos__

__pos__(self)：定义正号（+）的行为。
在Python中，__pos__ 方法定义了一个对象如何响应正号（+）操作符。它返回对象的正数形式。

以下是一个示例，定义了一个 Number 类，它表示一个数字，并实现了 __pos__ 方法，以便可以对数字进行取正操作：

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

    def __str__(self):
        return str(self.value)

    def __pos__(self):
        return Number(abs(self.value))

# 使用 Number 类
num = Number(-5)

# 使用正号操作符取正
pos_num = +num
print(pos_num)  # 输出: 5

在上述代码中，Number 类定义了 __pos__ 方法来处理数字对象的正号操作。

当执行 +num 时，调用 num 的 __pos__ 方法。该方法返回一个新的 Number 对象，其值为原始数字的绝对值。

请注意，__pos__ 方法通常用于使自定义对象能够支持正号操作符。在实际应用中，你可能需要根据对象的特定需求来定义正号操作的行为。

__abs__

__abs__(self)：定义内建函数 abs() 的行为。
在Python中，__abs__ 方法定义了一个对象在应用内建函数 abs() 时的行为。它返回对象的绝对值。

以下是一个示例，定义了一个 ComplexNumber 类，它表示一个复数，并实现了 __abs__ 方法，以便可以对复数对象应用 abs() 函数：

class ComplexNumber:
    def __init__(self, real=0, imag=0):
        self.real = real
        self.imag = imag

    def __str__(self):
        return f"{self.real} + {self.imag}i"

    def __abs__(self):
        return (self.real ** 2 + self.imag ** 2) ** 0.5

# 使用 ComplexNumber 类
c = ComplexNumber(3, 4)

# 应用 abs() 函数获取复数的绝对值
abs_value = abs(c)
print(abs_value)  # 输出: 5.0

在上述代码中，ComplexNumber 类定义了 __abs__ 方法来处理复数对象的绝对值。

当应用 abs() 函数到复数对象 c 时，调用 c 的 __abs__ 方法。该方法返回复数的模（即绝对值），通过计算实部和虚部的平方和的平方根得到。

请注意，__abs__ 方法通常用于使自定义对象能够支持 abs() 函数。在实际应用中，你可能需要根据对象的特定需求来定义 abs() 函数的行为。

__invert__

__invert__(self)：定义按位取反操作符的行为。
在Python中，__invert__ 方法定义了一个对象在应用按位取反操作符（~）时的行为。它返回对象按位取反后的结果。

以下是一个示例，定义了一个 BinaryNumber 类，它表示一个二进制数，并实现了 __invert__ 方法，以便可以对二进制数对象应用按位取反操作：

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

    def __str__(self):
        return bin(self.value)[2:]

    def __invert__(self):
        return BinaryNumber(~self.value)

# 使用 BinaryNumber 类
binary = BinaryNumber(10)

# 使用按位取反操作符取反
inverted_binary = ~binary
print(inverted_binary)  # 输出: -11

在上述代码中，BinaryNumber 类定义了 __invert__ 方法来处理二进制数对象的按位取反操作。

当应用按位取反操作符 ~ 到二进制数对象 binary 时，调用 binary 的 __invert__ 方法。该方法返回一个新的 BinaryNumber 对象，其值为原始二进制数按位取反后的结果。

请注意，__invert__ 方法通常用于使自定义对象能够支持按位取反操作符。在实际应用中，你可能需要根据对象的特定需求来定义按位取反操作的行为。

类型转换

__int__

__int__(self)：定义 int() 转换的行为。
在Python中，__int__ 方法定义了一个对象在应用 int() 函数进行转换时的行为。它返回对象的整数表示。

以下是一个示例，定义了一个 Fraction 类，它表示一个分数，并实现了 __int__ 方法，以便可以将分数对象转换为整数：

class Fraction:
    def __init__(self, numerator, denominator):
        self.numerator = numerator
        self.denominator = denominator

    def __str__(self):
        return f"{self.numerator}/{self.denominator}"

    def __int__(self):
        return self.numerator // self.denominator

# 使用 Fraction 类
fraction = Fraction(5, 2)

# 使用 int() 函数将分数转换为整数
integer = int(fraction)
print(integer)  # 输出: 2

在上述代码中，Fraction 类定义了 __int__ 方法来处理分数对象的整数转换。

当应用 int() 函数到分数对象 fraction 时，调用 fraction 的 __int__ 方法。该方法返回分数的整数部分，通过对分子除以分母进行整除运算得到。

请注意，__int__ 方法通常用于使自定义对象能够支持 int() 函数的转换。在实际应用中，你可能需要根据对象的特定需求来定义转换的行为。

__float__

__float__(self)：定义 float() 转换的行为。
在Python中，__float__ 方法定义了一个对象在应用 float() 函数进行转换时的行为。它返回对象的浮点数表示。

以下是一个示例，定义了一个 Fraction 类，它表示一个分数，并实现了 __float__ 方法，以便可以将分数对象转换为浮点数：

class Fraction:
    def __init__(self, numerator, denominator):
        self.numerator = numerator
        self.denominator = denominator

    def __str__(self):
        return f"{self.numerator}/{self.denominator}"

    def __float__(self):
        return self.numerator / self.denominator

# 使用 Fraction 类
fraction = Fraction(3, 2)

# 使用 float() 函数将分数转换为浮点数
floating_point = float(fraction)
print(floating_point)  # 输出: 1.5

在上述代码中，Fraction 类定义了 __float__ 方法来处理分数对象的浮点数转换。

当应用 float() 函数到分数对象 fraction 时，调用 fraction 的 __float__ 方法。该方法返回分数的浮点数表示，通过将分子除以分母得到。

请注意，__float__ 方法通常用于使自定义对象能够支持 float() 函数的转换。在实际应用中，你可能需要根据对象的特定需求来定义转换的行为。

__complex__

__complex__(self)：定义 complex() 转换的行为。
在Python中，__complex__ 方法定义了一个对象在应用 complex() 函数进行转换时的行为。它返回对象的复数表示。

以下是一个示例，定义了一个 Point 类，它表示一个二维平面上的点，并实现了 __complex__ 方法，以便可以将点对象转换为复数：

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

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __complex__(self):
        return complex(self.x, self.y)

# 使用 Point 类
point = Point(3, 4)

# 使用 complex() 函数将点转换为复数
complex_number = complex(point)
print(complex_number)  # 输出: (3+4j)

在上述代码中，Point 类定义了 __complex__ 方法来处理点对象的复数转换。

当应用 complex() 函数到点对象 point 时，调用 point 的 __complex__ 方法。该方法返回一个复数对象，其实部为点的 x 坐标，虚部为点的 y 坐标。

请注意，__complex__ 方法通常用于使自定义对象能够支持 complex() 函数的转换。在实际应用中，你可能需要根据对象的特定需求来定义转换的行为。

__bool__

__bool__(self)：定义 bool() 转换的行为。
在Python中，__bool__ 方法定义了一个对象在应用 bool() 函数进行转换时的行为。它返回对象的布尔值表示。

以下是一个示例，定义了一个 Person 类，它表示一个人，并实现了 __bool__ 方法，以便可以将人对象转换为布尔值：

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

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

    def __bool__(self):
        return self.age >= 18

# 使用 Person 类
person1 = Person("Alice", 25)
person2 = Person("Bob", 15)

# 使用 bool() 函数将人对象转换为布尔值
is_adult1 = bool(person1)
is_adult2 = bool(person2)

print(is_adult1)  # 输出: True
print(is_adult2)  # 输出: False

在上述代码中，Person 类定义了 __bool__ 方法来处理人对象的布尔值转换。

当应用 bool() 函数到人对象 person1 和 person2 时，分别调用它们的 __bool__ 方法。该方法根据人的年龄是否大于等于 18 来返回布尔值。

请注意，__bool__ 方法通常用于使自定义对象能够支持 bool() 函数的转换。在实际应用中，你可能需要根据对象的特定需求来定义转换的行为。

上下文管理器

__enter__

__enter__(self)：进入上下文管理器的时候执行。
__enter__ 方法是在进入上下文管理器（例如使用 with 语句）时执行的方法。它通常用于执行一些初始化操作或者返回一个对象，以便在进入上下文管理器后可以被使用。

以下是一个示例，定义了一个 FileHandler 类，它表示一个文件处理器，并实现了 __enter__ 方法，以便在进入上下文管理器时打开文件并返回文件对象：

class FileHandler:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_value, traceback):
        if self.file:
            self.file.close()

# 使用 FileHandler 类作为上下文管理器
with FileHandler("example.txt", "w") as file:
    file.write("Hello, this is a file created using a context manager.")

在上述代码中，FileHandler 类定义了 __enter__ 方法来在进入上下文管理器时打开文件并返回文件对象。

当使用 with 语句和 FileHandler 类时，__enter__ 方法被调用，并返回了一个文件对象，然后可以在 with 语句块中使用该文件对象进行写入操作。在退出 with 语句块时，__exit__ 方法会被调用以确保文件被正确关闭。

请注意，__enter__ 方法通常用于执行一些初始化操作或者返回一个对象，以便在进入上下文管理器后可以被使用。

__exit__

__exit__(self, exc_type, exc_value, traceback)：退出上下文管理器的时候执行。
当退出上下文管理器时，__exit__ 方法会被执行。这个方法通常用于执行一些清理操作，比如关闭文件、释放资源等。

以下是一个示例，定义了一个 FileHandler 类，它表示一个文件处理器，并实现了 __exit__ 方法，以便在退出上下文管理器时关闭文件：

class FileHandler:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_value, traceback):
        if self.file:
            self.file.close()

# 使用 FileHandler 类作为上下文管理器
with FileHandler("example.txt", "w") as file:
    file.write("Hello, this is a file created using a context manager.")
    # 当退出 with 语句块时，__exit__ 方法会被调用，关闭文件

在上述代码中，FileHandler 类定义了 __exit__ 方法来在退出上下文管理器时关闭文件。

当使用 with 语句和 FileHandler 类时，__enter__ 方法被调用以打开文件，并返回文件对象。然后在 with 语句块中可以使用该文件对象进行写入操作。当退出 with 语句块时，__exit__ 方法会被调用以确保文件被正确关闭。

请注意，__exit__ 方法通常用于执行一些清理操作，比如关闭文件、释放资源等。

对象调用

__call__

__call__(self, [...])：允许一个类的实例表现得像函数。
__call__ 方法允许一个类的实例表现得像函数，也就是可以像调用函数一样调用这个实例。在这个方法中，你可以定义实例被调用时的行为，包括接受参数并返回结果。

以下是一个示例，定义了一个 Multiplier 类，它实现了 __call__ 方法，使其实例可以像函数一样进行调用：

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, x):
        return self.factor * x

# 创建一个 Multiplier 的实例
multiply_by_5 = Multiplier(5)

# 调用实例，实际上会调用 __call__ 方法
result = multiply_by_5(10)
print(result)  # 输出 50

在上述代码中，Multiplier 类实现了 __call__ 方法，使其实例可以像函数一样进行调用。在 __call__ 方法中，我们定义了对传入参数进行乘法运算的行为。

当创建了 Multiplier 的实例 multiply_by_5 后，我们可以像调用函数一样调用它，并传入参数 10。实际上，这会调用 __call__ 方法，并返回计算结果。

属性访问

__getattr__

__getattr__(self, name)：定义当获取不存在的属性时的行为。
__getattr__ 方法定义了当试图访问一个不存在的属性时的行为。这允许你在类中动态地处理属性的访问，比如在属性不存在时返回一个默认值或者执行一些特定的逻辑。

以下是一个示例，定义了一个 DynamicAttributes 类，它实现了 __getattr__ 方法，以便在访问不存在的属性时返回一个默认值：

class DynamicAttributes:
    def __getattr__(self, name):
        print(f"Accessing non-existent attribute: {name}")
        return f"Default value for {name}"

# 创建 DynamicAttributes 的实例
obj = DynamicAttributes()

# 访问不存在的属性
print(obj.undefined_attr)

在上述代码中，DynamicAttributes 类实现了 __getattr__ 方法，当试图访问不存在的属性时，它会打印一条消息并返回一个默认值。

当创建了 DynamicAttributes 的实例 obj 后，我们尝试访问一个名为 undefined_attr 的属性，这个属性并不存在。实际上，这会触发 __getattr__ 方法，并返回默认值。

__setattr__

__setattr__(self, name, value)：定义当设置属性时的行为。
__setattr__ 方法定义了当设置属性时的行为。这允许你在类中动态地处理属性的设置，比如在设置属性时执行一些特定的逻辑。

以下是一个示例，定义了一个 RestrictedAttributes 类，它实现了 __setattr__ 方法，以便在设置属性时执行一些限制逻辑：

class RestrictedAttributes:
    def __init__(self):
        self._allowed_attributes = ["name", "age"]

    def __setattr__(self, name, value):
        if name not in self._allowed_attributes:
            raise AttributeError(f"Setting attribute '{name}' is not allowed")
        super().__setattr__(name, value)

# 创建 RestrictedAttributes 的实例
obj = RestrictedAttributes()

# 设置允许的属性
obj.name = "Alice"
obj.age = 30
print(obj.name, obj.age)  # 输出 Alice 30

# 尝试设置不允许的属性
try:
    obj.gender = "female"  # 这里会触发 AttributeError
except AttributeError as e:
    print(e)

在上述代码中，RestrictedAttributes 类实现了 __setattr__ 方法，当试图设置属性时，它会执行限制逻辑，只允许设置预先定义的属性。如果试图设置不允许的属性，它会触发 AttributeError 异常。

当创建了 RestrictedAttributes 的实例 obj 后，我们设置了允许的属性 name 和 age，并成功获取它们的值。然后尝试设置不允许的属性 gender，这会触发 AttributeError 异常。

__delattr__

__delattr__(self, name)：定义当删除属性时的行为。
__delattr__ 方法定义了当删除属性时的行为。这允许你在类中动态地处理属性的删除，比如在删除属性时执行一些特定的逻辑。

以下是一个示例，定义了一个 ProtectedAttributes 类，它实现了 __delattr__ 方法，以便在删除属性时执行一些保护逻辑：

class ProtectedAttributes:
    def __init__(self):
        self._protected_attributes = ["name", "age"]

    def __delattr__(self, name):
        if name in self._protected_attributes:
            raise AttributeError(f"Deleting attribute '{name}' is not allowed")
        super().__delattr__(name)

# 创建 ProtectedAttributes 的实例
obj = ProtectedAttributes()

# 设置允许的属性
obj.name = "Alice"
obj.age = 30
print(obj.name, obj.age)  # 输出 Alice 30

# 尝试删除不允许的属性
try:
    del obj.name  # 这里会触发 AttributeError
except AttributeError as e:
    print(e)

在上述代码中，ProtectedAttributes 类实现了 __delattr__ 方法，当试图删除属性时，它会执行保护逻辑，阻止删除预先定义的属性。如果试图删除不允许的属性，它会触发 AttributeError 异常。

当创建了 ProtectedAttributes 的实例 obj 后，我们设置了允许的属性 name 和 age，并成功获取它们的值。然后尝试删除不允许的属性 name，这会触发 AttributeError 异常。

__getattribute__

__getattribute__(self, name)：定义当获取任何属性时的行为。
__getattribute__ 方法定义了当获取任何属性时的行为。与__getattr__不同，__getattribute__会在每次访问属性时都被调用，而不仅仅是在属性不存在时。

以下是一个示例，定义了一个 LoggingAttributes 类，它实现了 __getattribute__ 方法，以便在获取属性时记录日志：

class LoggingAttributes:
    def __getattribute__(self, name):
        print(f"Getting attribute '{name}'")
        return super().__getattribute__(name)

# 创建 LoggingAttributes 的实例
obj = LoggingAttributes()

# 获取属性
print(obj.name)  # 这会触发 __getattribute__ 方法，并打印日志

在上述代码中，LoggingAttributes 类实现了 __getattribute__ 方法，当试图获取属性时，它会记录日志并返回属性的值。

当创建了 LoggingAttributes 的实例 obj 后，我们尝试获取属性 name，这会触发 __getattribute__ 方法，并打印日志。

描述符

__get__

__get__(self, instance, owner)：定义获取描述符的行为。
__get__ 方法定义了获取描述符的行为。描述符是一个包含 __get__、__set__ 和 __delete__ 方法中的至少一个的对象，它可以被用作另一个类的属性，提供对这个属性的定制化访问。

以下是一个示例，定义了一个描述符类 Temperature，它实现了 __get__ 方法，以便在获取属性时执行一些定制化的行为：

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    def __get__(self, instance, owner):
        fahrenheit = self.celsius * 9 / 5 + 32
        return fahrenheit

class WeatherReport:
    temperature = Temperature(25)

# 创建 WeatherReport 的实例
report = WeatherReport()

# 获取描述符属性
print(report.temperature)  # 这会触发 Temperature 类的 __get__ 方法，并返回摄氏温度对应的华氏温度

在上述代码中，Temperature 类实现了 __get__ 方法，当试图获取描述符属性时，它会执行定制化的行为，并返回对应的温度值。然后，我们将 Temperature 描述符作为 WeatherReport 类的属性，创建了 WeatherReport 的实例 report，并获取了描述符属性 temperature，这会触发 Temperature 类的 __get__ 方法，并返回摄氏温度对应的华氏温度。

__set__

__set__(self, instance, value)：定义设置描述符的行为。
__set__ 方法定义了设置描述符的行为。描述符是一个包含 __get__、__set__ 和 __delete__ 方法中的至少一个的对象，它可以被用作另一个类的属性，提供对这个属性的定制化访问。

以下是一个示例，定义了一个描述符类 Temperature，它实现了 __set__ 方法，以便在设置属性时执行一些定制化的行为：

class Temperature:
    def __init__(self):
        self._celsius = 0

    def __get__(self, instance, owner):
        return self._celsius

    def __set__(self, instance, value):
        if value < -273.15:
            raise ValueError("Temperature cannot be less than -273.15°C (absolute zero)")
        self._celsius = value

class WeatherReport:
    temperature = Temperature()

# 创建 WeatherReport 的实例
report = WeatherReport()

# 设置描述符属性
report.temperature = 25  # 这会触发 Temperature 类的 __set__ 方法
print(report.temperature)  # 输出 25

在上述代码中，Temperature 类实现了 __set__ 方法，当试图设置描述符属性时，它会执行定制化的行为，检查温度值是否合法，并进行设置。然后，我们将 Temperature 描述符作为 WeatherReport 类的属性，创建了 WeatherReport 的实例 report，并设置了描述符属性 temperature，这会触发 Temperature 类的 __set__ 方法。

__delete__

__delete__(self, instance)：定义删除描述符的行为。
__delete__ 方法定义了删除描述符的行为。描述符是一个包含 __get__、__set__ 和 __delete__ 方法中的至少一个的对象，它可以被用作另一个类的属性，提供对这个属性的定制化访问。

以下是一个示例，定义了一个描述符类 Temperature，它实现了 __delete__ 方法，以便在删除属性时执行一些定制化的行为：

class Temperature:
    def __init__(self):
        self._celsius = 0

    def __get__(self, instance, owner):
        return self._celsius

    def __set__(self, instance, value):
        if value < -273.15:
            raise ValueError("Temperature cannot be less than -273.15°C (absolute zero)")
        self._celsius = value

    def __delete__(self, instance):
        print("Deleting temperature")
        del self._celsius

class WeatherReport:
    temperature = Temperature()

# 创建 WeatherReport 的实例
report = WeatherReport()

# 设置描述符属性
report.temperature = 25
print(report.temperature)  # 输出 25

# 删除描述符属性
del report.temperature  # 这会触发 Temperature 类的 __delete__ 方法

在上述代码中，Temperature 类实现了 __delete__ 方法，当试图删除描述符属性时，它会执行定制化的行为，并在这个示例中打印一条消息。然后，我们将 Temperature 描述符作为 WeatherReport 类的属性，创建了 WeatherReport 的实例 report，并设置了描述符属性 temperature，然后删除了描述符属性，这会触发 Temperature 类的 __delete__ 方法。

类的元信息

__class__

__class__：对象的类。
__class__ 是一个特殊属性，它返回对象所属的类。

以下是一个示例代码，演示了如何使用 __class__ 属性获取对象所属的类：

class MyClass:
    pass

# 创建 MyClass 的实例
obj = MyClass()

# 使用 __class__ 获取对象所属的类
print(obj.__class__)  # 输出 <class '__main__.MyClass'>

在上述示例中，我们定义了一个简单的类 MyClass，然后创建了 MyClass 的实例 obj。接着，我们使用 __class__ 属性获取了 obj 所属的类，并打印出了这个类的信息。

__dict__

__dict__：对象的属性字典。
__dict__ 是一个特殊属性，它返回一个包含对象的属性的字典。

以下是一个示例代码，演示了如何使用 __dict__ 属性获取对象的属性字典：

class MyClass:
    def __init__(self):
        self.a = 1
        self.b = 2

# 创建 MyClass 的实例
obj = MyClass()

# 使用 __dict__ 获取对象的属性字典
print(obj.__dict__)  # 输出 {'a': 1, 'b': 2}

在上述示例中，我们定义了一个简单的类 MyClass，它有两个属性 a 和 b。然后，我们创建了 MyClass 的实例 obj。接着，我们使用 __dict__ 属性获取了 obj 的属性字典，并打印出了这个属性字典的内容。

__slots__

__slots__：优化，限制对象可以拥有的属性。
__slots__ 是一个特殊属性，它可以用来限制对象可以拥有的属性，从而优化内存空间的使用。

以下是一个示例代码，演示了如何使用 __slots__ 属性来限制对象可以拥有的属性：

class MyClass:
    __slots__ = ['a', 'b']

    def __init__(self):
        self.a = 1
        self.b = 2

# 创建 MyClass 的实例
obj = MyClass()

# 尝试创建一个不在 __slots__ 中的属性
obj.c = 3  # 这会引发 AttributeError: 'MyClass' object has no attribute 'c'

在上述示例中，我们定义了一个简单的类 MyClass，并在类中使用 __slots__ 属性来限制对象可以拥有的属性，只允许 a 和 b 这两个属性。然后，我们创建了 MyClass 的实例 obj，并在初始化方法中设置了 a 和 b 两个属性。接着，我们尝试给 obj 添加一个不在 __slots__ 中的属性 c，这会引发 AttributeError，因为我们限制了对象只能拥有 a 和 b 这两个属性。

其他

__hash__

__hash__(self)：定义对象的哈希值，用于字典等。
__hash__ 方法用于定义对象的哈希值，这在创建自定义类型的对象，并希望将其用作字典的键或集合的元素时非常有用。

以下是一个示例代码，演示了如何使用 __hash__ 方法定义对象的哈希值：

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

    def __hash__(self):
        return hash((self.x, self.y))

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

# 创建 Point 的实例
p1 = Point(1, 2)
p2 = Point(1, 2)

# 使用 Point 对象作为字典的键
point_dict = {p1: "Point 1", p2: "Point 2"}

# 打印字典
print(point_dict)  # 输出 {<__main__.Point object at 0x7f5a4c0a8c10>: 'Point 2'}

在上述示例中，我们定义了一个 Point 类，它表示二维平面上的点，然后我们实现了 __hash__ 方法，该方法返回了一个由 x 和 y 组成的元组的哈希值。接着，我们创建了两个 Point 的实例 p1 和 p2，它们的坐标相同。然后，我们将这两个实例作为字典的键，并打印出了字典的内容。由于我们定义了 __hash__ 方法，所以这两个实例会被认为是相同的键，因此字典中只会保留一个键值对。

__eq__

__eq__(self, other)：定义等于操作符的行为。
__eq__ 方法用于定义对象之间的相等性，可以在自定义类中重写该方法来定义等于操作符的行为。

以下是一个示例代码，演示了如何使用 __eq__ 方法来定义对象的相等性：

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

# 创建 Point 的实例
p1 = Point(1, 2)
p2 = Point(1, 2)
p3 = Point(3, 4)

# 比较 Point 对象的相等性
print(p1 == p2)  # 输出 True
print(p1 == p3)  # 输出 False

在上述示例中，我们定义了一个 Point 类，它表示二维平面上的点，然后我们实现了 __eq__ 方法，该方法定义了当两个 Point 对象相等时的逻辑。在这个例子中，我们认为两个点相等当且仅当它们的 x 和 y 坐标都相等。接着，我们创建了三个 Point 的实例 p1、p2 和 p3，并使用 == 操作符来比较它们的相等性。根据我们在 __eq__ 方法中定义的逻辑，p1 和 p2 相等，而 p1 和 p3 不相等。

__ne__

__ne__(self, other)：定义不等于操作符的行为。
在Python中，__ne__ 方法用于定义对象之间不相等的操作符行为。当我们对两个对象使用 != 操作符时，Python会调用对象的 __ne__ 方法来确定它们是否不相等。

以下是一个示例代码，演示了如何使用 __ne__ 方法来定义对象的不相等性：

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

    def __ne__(self, other):
        return not self.__eq__(other)

# 创建 Point 的实例
p1 = Point(1, 2)
p2 = Point(1, 2)
p3 = Point(3, 4)

# 比较 Point 对象的不相等性
print(p1 != p2)  # 输出 False
print(p1 != p3)  # 输出 True

在上述示例中，我们定义了一个 Point 类，然后实现了 __eq__ 方法来定义对象的相等性。接着，我们实现了 __ne__ 方法，该方法返回了 __eq__ 方法的相反结果，即当两个对象不相等时返回 True，相等时返回 False。然后，我们创建了三个 Point 的实例 p1、p2 和 p3，并使用 != 操作符来比较它们的不相等性。根据我们在 __ne__ 方法中定义的逻辑，p1 和 p2 相等，因此 p1 != p2 返回 False，而 p1 和 p3 不相等，因此 p1 != p3 返回 True。

__lt__

__lt__(self, other)：定义小于操作符的行为。
__lt__ 方法用于定义对象之间小于操作符的行为。当我们对两个对象使用 < 操作符时，Python会调用对象的 __lt__ 方法来确定它们的大小关系。

以下是一个示例代码，演示了如何使用 __lt__ 方法来定义对象的大小关系：

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

# 创建 Point 的实例
p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = Point(3, 1)

# 比较 Point 对象的大小关系
print(p1 < p2)  # 输出 True
print(p2 < p3)  # 输出 False

在上述示例中，我们定义了一个 Point 类，然后实现了 __lt__ 方法来定义对象的大小关系。在这个例子中，我们认为一个点小于另一个点当且仅当它的 x 坐标和 y 坐标都分别小于另一个点的对应坐标。接着，我们创建了三个 Point 的实例 p1、p2 和 p3，并使用 < 操作符来比较它们的大小关系。根据我们在 __lt__ 方法中定义的逻辑，p1 小于 p2，而 p2 不小于 p3。

__le__

__le__(self, other)：定义小于等于操作符的行为。
__le__ 方法用于定义对象之间小于等于操作符的行为。当我们对两个对象使用 <= 操作符时，Python会调用对象的 __le__ 方法来确定它们的大小关系。

以下是一个示例代码，演示了如何使用 __le__ 方法来定义对象的大小关系：

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

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

# 创建 Point 的实例
p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = Point(3, 1)

# 比较 Point 对象的大小关系
print(p1 <= p2)  # 输出 True
print(p2 <= p3)  # 输出 False
print(p1 <= p1)  # 输出 True

在上述示例中，我们定义了一个 Point 类，然后实现了 __le__ 方法来定义对象的大小关系。在这个例子中，我们认为一个点小于等于另一个点当且仅当它的 x 坐标和 y 坐标都分别小于或等于另一个点的对应坐标。接着，我们创建了三个 Point 的实例 p1、p2 和 p3，并使用 <= 操作符来比较它们的大小关系。根据我们在 __le__ 方法中定义的逻辑，p1 小于等于 p2，而 p2 不小于等于 p3。同时，我们还比较了一个点小于等于它自己，这显然是成立的。

__gt__

__gt__(self, other)：定义大于操作符的行为。
__gt__ 方法用于定义对象之间大于操作符的行为。当我们对两个对象使用 > 操作符时，Python会调用对象的 __gt__ 方法来确定它们的大小关系。

以下是一个示例代码，演示了如何使用 __gt__ 方法来定义对象的大小关系：

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

# 创建 Point 的实例
p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = Point(3, 1)

# 比较 Point 对象的大小关系
print(p2 > p1)  # 输出 True
print(p2 > p3)  # 输出 True
print(p1 > p3)  # 输出 False

在上述示例中，我们定义了一个 Point 类，然后实现了 __gt__ 方法来定义对象的大小关系。在这个例子中，我们认为一个点大于另一个点当且仅当它的 x 坐标和 y 坐标都分别大于另一个点的对应坐标。接着，我们创建了三个 Point 的实例 p1、p2 和 p3，并使用 > 操作符来比较它们的大小关系。根据我们在 __gt__ 方法中定义的逻辑，p2 大于 p1，p2 大于 p3，而 p1 不大于 p3。

__ge__

__ge__(self, other)：定义大于等于操作符的行为。
__ge__ 方法用于定义对象之间大于等于操作符的行为。当我们对两个对象使用 >= 操作符时，Python会调用对象的 __ge__ 方法来确定它们的大小关系。

以下是一个示例代码，演示了如何使用 __ge__ 方法来定义对象的大小关系：

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

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

# 创建 Point 的实例
p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = Point(3, 1)

# 比较 Point 对象的大小关系
print(p2 >= p1)  # 输出 True
print(p2 >= p3)  # 输出 True
print(p1 >= p3)  # 输出 False
print(p1 >= p1)  # 输出 True

在上述示例中，我们定义了一个 Point 类，然后实现了 __ge__ 方法来定义对象的大小关系。在这个例子中，我们认为一个点大于等于另一个点当且仅当它的 x 坐标和 y 坐标都分别大于或等于另一个点的对应坐标。接着，我们创建了三个 Point 的实例 p1、p2 和 p3，并使用 >= 操作符来比较它们的大小关系。根据我们在 __ge__ 方法中定义的逻辑，p2 大于等于 p1，p2 大于等于 p3，而 p1 不大于等于 p3。同时，我们还比较了一个点大于等于它自己，这显然是成立的。

这些魔法函数使得开发者可以自定义对象的行为，使得它们可以更加自然地和 Python 的语言特性和内建函数集成。例如，通过定义 __add__，你可以使得你的对象支持加法操作符 +。通过定义 __iter__ 和 __next__，你可以创建你自己的迭代器，等等。

请注意，并不是所有的特殊方法都需要被实现，它们依赖于你想要如何使用你的类。