目录
一、概述
1、定义
魔法方法(Magic Methods/Special Methods，也称特殊方法或双下划线方法)是Python中一类具有特殊命名规则的方法，它们的名称通常以双下划线(`__`)开头和结尾。
魔法方法用于在特定情况下自动被Python解释器调用，而不需要显式地调用它们，它们提供了一种机制，让你可以定义自定义类时具有与内置类型相似的行为。
2、作用
魔法方法允许开发者重载Python中的一些内置操作或函数的行为，从而为自定义的类添加特殊的功能。
二、应用场景
1、构造和析构
1-1、__init__(self, [args...])：在创建对象时初始化属性。
1-2、__new__(cls, [args...])：在创建对象时控制实例的创建过程(通常与元类一起使用)。
1-3、__del__(self)：在对象被销毁前执行清理操作，如关闭文件或释放资源。
2、操作符重载
2-1、__add__(self, other)、__sub__(self, other)、__mul__(self, other)等：自定义对象之间的算术运算。
2-2、__eq__(self, other)、__ne__(self, other)、__lt__(self, other)等：定义对象之间的比较操作。
3、字符串和表示
3-1、__str__(self)：定义对象的字符串表示，常用于print()函数。
3-2、__repr__(self)：定义对象的官方字符串表示，用于repr()函数和交互式解释器。
4、容器管理
4-1、__getitem__(self, key)、__setitem__(self, key, value)、__delitem__(self, key)：用于实现类似列表或字典的索引访问、设置和删除操作。
4-2、__len__(self)：返回对象的长度或元素个数。
5、可调用对象
5-1、__call__(self, [args...])：允许对象像函数一样被调用。
6、上下文管理
6-1、__enter__(self)、__exit__(self, exc_type, exc_val, exc_tb)：用于实现上下文管理器，如with语句中的对象。
7、属性访问和描述符
7-1、__getattr__, __setattr__, __delattr__：这些方法允许对象在访问或修改不存在的属性时执行自定义操作。
7-2、描述符(Descriptors)是实现了__get__, __set__, 和__delete__方法的对象，它们可以控制对另一个对象属性的访问。
8、迭代器和生成器
8-1、__iter__和__next__：这些方法允许对象支持迭代操作，如使用for循环遍历对象。
8-2、__aiter__, __anext__：这些是异步迭代器的魔法方法，用于支持异步迭代。
9、数值类型
9-1、__int__(self)、__float__(self)、__complex__(self)：定义对象到数值类型的转换。
9-2、__index__(self)：定义对象用于切片时的整数转换。
10、复制和序列化
10-1、__copy__和__deepcopy__：允许对象支持浅复制和深复制操作。
10-2、__getstate__和__setstate__：用于自定义对象的序列化和反序列化过程。
11、自定义元类行为
11-1、__metaclass__(Python 2)或元类本身(Python 3)：允许自定义类的创建过程，如动态创建类、修改类的定义等。
12、自定义类行为
12-1、__init__和__new__：用于初始化对象或控制对象的创建过程。
12-2、__init_subclass__：在子类被创建时调用，允许在子类中执行一些额外的操作。
13、类型检查和转换
13-1、__instancecheck__和__subclasscheck__：用于自定义isinstance()和issubclass()函数的行为。
14、自定义异常
14-1、你可以通过继承内置的Exception类来创建自定义的异常类，并定义其特定的行为。
三、学习方法
要学好Python的魔法方法，你可以遵循以下方法及步骤：
1、理解基础
首先确保你对Python的基本语法、数据类型、类和对象等概念有深入的理解，这些是理解魔法方法的基础。
2、查阅文档
仔细阅读Python官方文档中关于魔法方法的部分，文档会详细解释每个魔法方法的作用、参数和返回值。你可以通过访问Python的官方网站或使用help()函数在Python解释器中查看文档。
3、编写示例
为每个魔法方法编写简单的示例代码，以便更好地理解其用法和效果，通过实际编写和运行代码，你可以更直观地感受到魔法方法如何改变对象的行为。
4、实践应用
在实际项目中尝试使用魔法方法。如，你可以创建一个自定义的集合类，使用__getitem__、__setitem__和__delitem__方法来实现索引操作。只有通过实践应用，你才能更深入地理解魔法方法的用途和重要性。
5、阅读他人代码
阅读开源项目或他人编写的代码，特别是那些使用了魔法方法的代码，这可以帮助你学习如何在实际项目中使用魔法方法。通过分析他人代码中的魔法方法使用方式，你可以学习到一些新的技巧和最佳实践。
6、参加社区讨论
参与Python社区的讨论，与其他开发者交流关于魔法方法的使用经验和技巧，在社区中提问或回答关于魔法方法的问题，这可以帮助你更深入地理解魔法方法并发现新的应用场景。
7、持续学习
Python语言和其生态系统不断发展，新的魔法方法和功能可能会不断被引入，保持对Python社区的关注，及时学习新的魔法方法和最佳实践。
8、练习与总结
多做练习，通过编写各种使用魔法方法的代码来巩固你的理解，定期总结你学到的知识和经验，形成自己的知识体系。
9、注意兼容性
在使用魔法方法时，要注意不同Python版本之间的兼容性差异，确保你的代码在不同版本的Python中都能正常工作。
10、避免过度使用
虽然魔法方法非常强大，但过度使用可能会导致代码难以理解和维护，在编写代码时，要权衡使用魔法方法的利弊，避免滥用。
总之，学好Python的魔法方法需要不断地学习、实践和总结，只有通过不断地练习和积累经验，你才能更好地掌握这些强大的工具，并在实际项目中灵活运用它们。
四、魔法方法
77、__xor__方法
77-1、语法
__xor__(self, other, /)
Return self ^ other77-2、参数
77-2-1、self(必须)：一个对实例对象本身的引用，在类的所有方法中都会自动传递。
77-2-2、other(必须)：表示与self对象进行异或操作的另一个对象。
77-2-3、 /(可选)：这是从Python 3.8开始引入的参数注解语法，它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。
77-3、功能
用于定义当对象与另一个对象进行异或(XOR)操作时应该如何响应。
77-4、返回值
返回值通常是该类的一个新实例，它代表了self和other对象异或后的结果。
77-5、说明
无
77-6、用法
# 077、__xor__方法：
# 1、简单的整数包装器
class IntegerWrapper:
def __init__(self, value):
self.value = value
def __xor__(self, other):
if isinstance(other, IntegerWrapper):
return IntegerWrapper(self.value ^ other.value)
else:
return NotImplemented
def __repr__(self):
return f"IntegerWrapper({self.value})"
if __name__ == '__main__':
a = IntegerWrapper(5)
b = IntegerWrapper(3)
c = a ^ b
print(c.value) # 输出：6
# 2、二进制字符串的异或
class BinaryString:
def __init__(self, binary_str):
self.binary_str = binary_str
def __xor__(self, other):
if isinstance(other, BinaryString) and len(self.binary_str) == len(other.binary_str):
result = ''
for s, o in zip(self.binary_str, other.binary_str):
result += str(int(s) ^ int(o))
return BinaryString(result)
else:
return NotImplemented
def __repr__(self):
return f"BinaryString('{self.binary_str}')"
if __name__ == '__main__':
a = BinaryString('1010')
b = BinaryString('1100')
c = a ^ b
print(c.binary_str) # 输出：'0110'
# 3、颜色RGB值的异或(模拟)
class RGBColor:
def __init__(self, r, g, b):
self.r = r
self.g = g
self.b = b
def __xor__(self, other):
if isinstance(other, RGBColor):
return RGBColor(self.r ^ other.r, self.g ^ other.g, self.b ^ other.b)
else:
return NotImplemented
def __repr__(self):
return f"RGBColor({self.r}, {self.g}, {self.b})"
if __name__ == '__main__':
a = RGBColor(255, 0, 0) # 红色
b = RGBColor(0, 255, 0) # 绿色
c = a ^ b # 这实际上在RGB颜色空间中没有意义，但这里只是模拟
print(c) # 输出 RGBColor(255, 255, 0) 或类似，取决于^的具体实现
# 4、日期对象的“异或”(模拟时间差)
from datetime import datetime, timedelta
class DateWrapper:
def __init__(self, date):
self.date = date
def __xor__(self, other):
if isinstance(other, DateWrapper):
time_difference = abs((self.date - other.date).days)
return timedelta(days=time_difference) # 返回时间差，不是真正的异或结果
else:
return NotImplemented
def __repr__(self):
return f"DateWrapper({self.date})"
if __name__ == '__main__':
date1 = DateWrapper(datetime(2019, 3, 13))
date2 = DateWrapper(datetime(2024, 6, 8))
difference = date1 ^ date2
print(difference.days) # 输出 1914，表示两个日期之间的天数差
# 5、矩阵对象的元素级异或
import numpy as np
class Matrix:
def __init__(self, array):
self.array = np.array(array, dtype=int)
def __xor__(self, other):
if isinstance(other, Matrix) and self.array.shape == other.array.shape:
return Matrix(self.array ^ other.array) # 使用NumPy的异或操作
else:
return NotImplemented
def __repr__(self):
return f"Matrix({self.array})"
if __name__ == '__main__':
matrix1 = Matrix([[1, 0], [0, 1]])
matrix2 = Matrix([[1, 1], [0, 0]])
result = matrix1 ^ matrix2
print(result.array) # 输出： [[0 1] [0 1]]
# 6、集合对象的对称差集模拟
class SetWrapper:
def __init__(self, items):
self.items = set(items)
def __xor__(self, other):
if isinstance(other, SetWrapper):
return SetWrapper(self.items.symmetric_difference(other.items))
else:
return NotImplemented
def __repr__(self):
return f"SetWrapper({self.items})"
if __name__ == '__main__':
set1 = SetWrapper({1, 2, 3})
set2 = SetWrapper({2, 3, 4})
result = set1 ^ set2
print(result.items) # 输出： {1, 4}，即两个集合的对称差集
# 7、自定义数值类型的位字段异或
class BitField:
def __init__(self, value):
self.value = value & 0xFF # 确保值在0-255之间
def __xor__(self, other):
if isinstance(other, BitField):
return BitField(self.value ^ other.value)
else:
return NotImplemented
def __repr__(self):
return f"BitField({self.value:08b})" # 以8位二进制形式表示
if __name__ == '__main__':
bf1 = BitField(0b10101010)
bf2 = BitField(0b01010101)
result = bf1 ^ bf2
print(result) # 输出：BitField(11111111)
# 8、加密相关的位操作(XOR密码)
class XORCipher:
def __init__(self, key):
self.key = key.encode('utf-8') # 假设密钥是字符串，转换为字节串
def __xor__(self, data):
# 检查 data 是否为 bytes 类型
if isinstance(data, bytes):
# 循环使用密钥进行异或运算
encrypted_data = bytes([data_byte ^ self.key[i % len(self.key)] for i, data_byte in enumerate(data)])
return encrypted_data
else:
return NotImplemented
if __name__ == '__main__':
cipher = XORCipher('secret')
message = b'Hello, World!'
# 使用 ^ 运算符进行加密
encrypted = cipher ^ message
print(encrypted) # 输出：b';\x00\x0f\x1e\nXS2\x0c\x00\t\x10R'
# 解密（使用相同的密钥）
decrypted = cipher ^ encrypted
print(decrypted.decode('utf-8')) # 输出：Hello, World!
# 9、网络数据包头的位字段异或(简化版)
class PacketHeader:
def __init__(self, flags=0):
self.flags = flags
def __xor__(self, other):
if isinstance(other, PacketHeader):
return PacketHeader(self.flags ^ other.flags)
else:
return NotImplemented
def __repr__(self):
return f"PacketHeader(flags={self.flags:08b})" # 假设flags是8位的
if __name__ == '__main__':
header1 = PacketHeader(flags=0b10101010)
header2 = PacketHeader(flags=0b01010101)
result = header1 ^ header2
print(result) # 输出：PacketHeader(flags=11111111)
# 10、图像像素的RGB值异或(用于图像处理或特效)
class Pixel:
def __init__(self, r, g, b):
self.r = r
self.g = g
self.b = b
def __xor__(self, other):
if isinstance(other, Pixel):
return Pixel(self.r ^ other.r, self.g ^ other.g, self.b ^ other.b)
else:
return NotImplemented
def __repr__(self):
return f"Pixel({self.r}, {self.g}, {self.b})"
if __name__ == '__main__':
pixel1 = Pixel(255, 0, 0) # 红色
pixel2 = Pixel(0, 255, 0) # 绿色
result = pixel1 ^ pixel2
print(result) # 输出：Pixel(255, 255, 0)
# 11、状态机的状态转换(使用XOR模拟状态切换)
class StateMachine:
STATE_A = 0
STATE_B = 1
def __init__(self, initial_state):
self.state = initial_state
def __xor__(self, trigger):
if trigger == 'toggle':
self.state = self.state ^ 1 # 切换状态
else:
return NotImplemented
def __repr__(self):
return f"StateMachine(state={self.state})"
if __name__ == '__main__':
machine = StateMachine(StateMachine.STATE_A)
print(machine) # 输出：StateMachine(state=0)
machine ^ 'toggle'
print(machine) # 输出：StateMachine(state=1)，状态已切换
五、专栏导航(配套有资源下载)
| 序号 | 1 | 2 | 3 | 博文链接 |
| 01 | __abs__ | __add__ | __and__ | 魔法方法(01) |
| __bool__ | __call__ | |||
| 02 | __ceil__ | __complex__ | __contains__ | 魔法方法(02) |
| __delattr__ | __delete__ | |||
| 03 | __delitem__ | __dir__ | __divmod__ | 魔法方法(03) |
| 04 | __enter__ | __eq__ | __exit__ | 魔法方法(04) |
| 05 | __float__ | __floor__ | __floordiv__ | 魔法方法(05) |
| 06 | __format__ | __ge__ | __get__ | 魔法方法(06) |
| 07 | __getattribute__ | __getitem__ | __getnewargs__ | 魔法方法(07) |
| 08 | __getstate__ | __gt__ | __setstate__ | 魔法方法(08) |
| 09 | __iadd__ | __iand__ | __imul__ | 魔法方法(09) |
| 10 | __index__ | __init__ | __init_subclass__ | 魔法方法(10) |
| 11 | __instancecheck__ | __int__ | __invert__ | 魔法方法(11) |
| 12 | __ior__ | __isub__ | __iter__ | 魔法方法(12) |
| 13 | __xor__ | __le__ | __len__ | 魔法方法(13) |
| 14 | __length_hint__ | __lshift__ | __lt__ | 魔法方法(14) |
| 15 | __mod__ | __mul__ | __ne__ | 魔法方法(15) |
| 16 | __neg__ | __new__ | __next__ | 魔法方法(16) |
| 17 | __or__ | __pos__ | __pow__ | 魔法方法(17) |
| 18 | __prepare__ | __radd__ | __rdivmod__ | 魔法方法(18) |
| 19 | __reduce__ | __reduce_ex__ | __repr__ | 魔法方法(19) |
| 20 | __reversed__ | __rfloordiv__ | __rlshift__ | 魔法方法(20) |
| 21 | __round__ | __set__ | __set_name__ | 魔法方法(21) |
| 22 | __setattr__ | __setitem__ | __sizeof__ | 魔法方法(22) |
| 23 | __str__ | __sub__ | __subclasscheck__ | 魔法方法(23) |
| 24 | __subclasses__ | __truediv__ | __trunc__ | 魔法方法(24) |