61.你知道哪些Python魔术方法

# 定义一个演示对象生命周期的类
class LifecycleDemo:
    # 构造函数，在创建对象时自动调用
    def __init__(self, name):
        # 初始化对象属性
        self.name = name
        # 打印对象创建信息
        print(f"对象 {self.name} 已创建")

    # 析构函数，在对象即将被垃圾回收时调用
    def __del__(self):
        # 打印对象销毁信息
        print(f"对象 {self.name} 即将被销毁")

    # 定义对象的非正式字符串表示，主要用于用户友好的输出
    def __str__(self):
        # 返回用户友好的字符串表示
        return f"LifecycleDemo对象: {self.name}"

    # 定义对象的官方字符串表示，通常用于调试和开发
    def __repr__(self):
        # 返回可以重新创建对象的字符串
        return f"LifecycleDemo('{self.name}')"

# 创建对象
obj = LifecycleDemo("测试对象")
# 打印对象（调用__str__方法）
print(obj)
# 使用repr()函数（调用__repr__方法）
print(repr(obj))
# 对象超出作用域时，__del__方法会被调用

# 定义一个支持比较操作的类
class ComparableDemo:
    # 构造函数
    def __init__(self, value):
        # 初始化值
        self.value = value

    # 定义相等性比较，处理 == 运算符
    def __eq__(self, other):
        # 检查是否为同一类型
        if isinstance(other, ComparableDemo):
            # 比较值是否相等
            return self.value == other.value
        return False

    # 定义小于比较，处理 < 运算符
    def __lt__(self, other):
        # 检查是否为同一类型
        if isinstance(other, ComparableDemo):
            # 比较值的大小
            return self.value < other.value
        return NotImplemented

    # 定义小于等于比较，处理 <= 运算符
    def __le__(self, other):
        # 检查是否为同一类型
        if isinstance(other, ComparableDemo):
            # 比较值的大小
            return self.value <= other.value
        return NotImplemented

    # 定义大于比较，处理 > 运算符
    def __gt__(self, other):
        # 检查是否为同一类型
        if isinstance(other, ComparableDemo):
            # 比较值的大小
            return self.value > other.value
        return NotImplemented

    # 定义大于等于比较，处理 >= 运算符
    def __ge__(self, other):
        # 检查是否为同一类型
        if isinstance(other, ComparableDemo):
            # 比较值的大小
            return self.value >= other.value
        return NotImplemented

    # 定义不等于比较，处理 != 运算符
    def __ne__(self, other):
        # 使用__eq__方法的结果
        return not self.__eq__(other)

    # 定义字符串表示
    def __str__(self):
        return f"ComparableDemo({self.value})"

# 创建对象
obj1 = ComparableDemo(10)
obj2 = ComparableDemo(20)
obj3 = ComparableDemo(10)
# 测试相等性
print(f"{obj1} == {obj2}: {obj1 == obj2}")
print(f"{obj1} == {obj3}: {obj1 == obj3}")
# 测试大小比较
print(f"{obj1} < {obj2}: {obj1 < obj2}")
print(f"{obj1} > {obj2}: {obj1 > obj2}")
print(f"{obj1} <= {obj3}: {obj1 <= obj3}")
print(f"{obj1} >= {obj3}: {obj1 >= obj3}")

# 定义一个支持算术操作的类
class ArithmeticDemo:
    # 构造函数
    def __init__(self, value):
        # 初始化值
        self.value = value

    # 定义加法操作，处理 + 运算符
    def __add__(self, other):
        # 检查是否为同一类型
        if isinstance(other, ArithmeticDemo):
            # 返回新的对象，值为两个对象值之和
            return ArithmeticDemo(self.value + other.value)
        return NotImplemented

    # 定义减法操作，处理 - 运算符
    def __sub__(self, other):
        # 检查是否为同一类型
        if isinstance(other, ArithmeticDemo):
            # 返回新的对象，值为两个对象值之差
            return ArithmeticDemo(self.value - other.value)
        return NotImplemented

    # 定义乘法操作，处理 * 运算符
    def __mul__(self, other):
        # 检查是否为同一类型
        if isinstance(other, ArithmeticDemo):
            # 返回新的对象，值为两个对象值之积
            return ArithmeticDemo(self.value * other.value)
        return NotImplemented

    # 定义除法操作，处理 / 运算符
    def __truediv__(self, other):
        # 检查是否为同一类型
        if isinstance(other, ArithmeticDemo):
            # 返回新的对象，值为两个对象值之商
            return ArithmeticDemo(self.value / other.value)
        return NotImplemented

    # 定义取模操作，处理 % 运算符
    def __mod__(self, other):
        # 检查是否为同一类型
        if isinstance(other, ArithmeticDemo):
            # 返回新的对象，值为两个对象值取模的结果
            return ArithmeticDemo(self.value % other.value)
        return NotImplemented

    # 定义幂运算，处理 ** 运算符
    def __pow__(self, other):
        # 检查是否为同一类型
        if isinstance(other, ArithmeticDemo):
            # 返回新的对象，值为两个对象值的幂
            return ArithmeticDemo(self.value ** other.value)
        return NotImplemented

    # 定义字符串表示
    def __str__(self):
        return f"ArithmeticDemo({self.value})"

# 创建对象
a = ArithmeticDemo(10)
b = ArithmeticDemo(3)
# 测试各种算术运算
print(f"{a} + {b} = {a + b}")
print(f"{a} - {b} = {a - b}")
print(f"{a} * {b} = {a * b}")
print(f"{a} / {b} = {a / b}")
print(f"{a} % {b} = {a % b}")
print(f"{a} ** {b} = {a ** b}")

# 定义一个二维向量类
class Vector2D:
    # 构造函数，初始化向量的x和y分量
    def __init__(self, x, y):
        # 初始化向量的x分量
        self.x = x
        # 初始化向量的y分量
        self.y = y

    # 定义加法操作，使两个Vector2D对象可以相加
    def __add__(self, other):
        # 检查是否为同一类型
        if isinstance(other, Vector2D):
            # 返回一个新的Vector2D对象，其x和y分量分别是两个向量对应分量之和
            return Vector2D(self.x + other.x, self.y + other.y)
        return NotImplemented

    # 定义减法操作，使两个Vector2D对象可以相减
    def __sub__(self, other):
        # 检查是否为同一类型
        if isinstance(other, Vector2D):
            # 返回一个新的Vector2D对象，其x和y分量分别是两个向量对应分量之差
            return Vector2D(self.x - other.x, self.y - other.y)
        return NotImplemented

    # 定义标量乘法操作，使向量可以与标量相乘
    def __mul__(self, scalar):
        # 检查标量是否为数字类型
        if isinstance(scalar, (int, float)):
            # 返回一个新的Vector2D对象，其x和y分量都乘以标量
            return Vector2D(self.x * scalar, self.y * scalar)
        return NotImplemented

    # 定义标量乘法操作（右乘）
    def __rmul__(self, scalar):
        # 调用左乘方法
        return self.__mul__(scalar)

    # 定义相等性比较
    def __eq__(self, other):
        # 检查是否为同一类型
        if isinstance(other, Vector2D):
            # 比较两个向量的x和y分量是否都相等
            return self.x == other.x and self.y == other.y
        return False

    # 定义对象的官方字符串表示
    def __repr__(self):
        # 返回一个字符串，可以用于重新创建该Vector2D对象
        return f"Vector2D({self.x}, {self.y})"

    # 定义对象的非正式字符串表示
    def __str__(self):
        # 返回用户友好的字符串表示
        return f"({self.x}, {self.y})"

    # 定义向量的模长
    def magnitude(self):
        # 计算向量的模长
        return (self.x ** 2 + self.y ** 2) ** 0.5

# 创建向量
v1 = Vector2D(2, 3)
v2 = Vector2D(5, 7)
# 测试向量运算
print(f"向量1: {v1}")
print(f"向量2: {v2}")
print(f"向量加法: {v1} + {v2} = {v1 + v2}")
print(f"向量减法: {v1} - {v2} = {v1 - v2}")
print(f"标量乘法: {v1} * 2 = {v1 * 2}")
print(f"标量乘法: 3 * {v1} = {3 * v1}")
print(f"向量1的模长: {v1.magnitude():.2f}")

# 定义一个复数类
class Complex:
    # 构造函数，初始化复数的实部和虚部
    def __init__(self, real, imag):
        # 初始化复数的实部
        self.real = real
        # 初始化复数的虚部
        self.imag = imag

    # 定义加法操作
    def __add__(self, other):
        # 检查是否为同一类型
        if isinstance(other, Complex):
            # 返回新的复数，实部和虚部分别相加
            return Complex(self.real + other.real, self.imag + other.imag)
        return NotImplemented

    # 定义减法操作
    def __sub__(self, other):
        # 检查是否为同一类型
        if isinstance(other, Complex):
            # 返回新的复数，实部和虚部分别相减
            return Complex(self.real - other.real, self.imag - other.imag)
        return NotImplemented

    # 定义乘法操作
    def __mul__(self, other):
        # 检查是否为同一类型
        if isinstance(other, Complex):
            # 复数乘法公式：(a+bi)(c+di) = (ac-bd) + (ad+bc)i
            real_part = self.real * other.real - self.imag * other.imag
            imag_part = self.real * other.imag + self.imag * other.real
            return Complex(real_part, imag_part)
        return NotImplemented

    # 定义相等性比较
    def __eq__(self, other):
        # 检查是否为同一类型
        if isinstance(other, Complex):
            # 比较实部和虚部是否都相等
            return self.real == other.real and self.imag == other.imag
        return False

    # 定义对象的字符串表示
    def __str__(self):
        # 根据虚部的正负号决定显示格式
        if self.imag >= 0:
            return f"{self.real}+{self.imag}i"
        else:
            return f"{self.real}{self.imag}i"

    # 定义对象的官方字符串表示
    def __repr__(self):
        return f"Complex({self.real}, {self.imag})"

    # 定义复数的模长
    def magnitude(self):
        # 计算复数的模长
        return (self.real ** 2 + self.imag ** 2) ** 0.5

# 创建复数
c1 = Complex(1, 2)
c2 = Complex(3, 4)
# 测试复数运算
print(f"复数1: {c1}")
print(f"复数2: {c2}")
print(f"复数加法: {c1} + {c2} = {c1 + c2}")
print(f"复数减法: {c1} - {c2} = {c1 - c2}")
print(f"复数乘法: {c1} * {c2} = {c1 * c2}")
print(f"复数1的模长: {c1.magnitude():.2f}")

# 定义一个自定义资源管理类
class CustomResource:
    # 构造函数
    def __init__(self, name):
        # 初始化资源名称
        self.name = name
        # 初始化资源状态
        self.is_acquired = False

    # 进入上下文时调用
    def __enter__(self):
        # 获取资源
        self.acquire()
        # 返回自身，作为'as'关键字后的变量
        return self

    # 退出上下文时调用
    def __exit__(self, exc_type, exc_val, exc_tb):
        # 释放资源
        self.release()
        # 如果返回True，表示已经处理了异常，不会向外传播
        # 如果返回False或None，异常会继续传播
        return False

    # 获取资源的方法
    def acquire(self):
        # 检查资源是否已被获取
        if self.is_acquired:
            # 如果已被获取，抛出异常
            raise RuntimeError(f"资源 {self.name} 已被获取")
        # 获取资源
        self.is_acquired = True
        # 打印资源获取信息
        print(f"资源 {self.name} 已被获取")

    # 释放资源的方法
    def release(self):
        # 检查资源是否已被获取
        if not self.is_acquired:
            # 如果未被获取，抛出异常
            raise RuntimeError(f"资源 {self.name} 未被获取")
        # 释放资源
        self.is_acquired = False
        # 打印资源释放信息
        print(f"资源 {self.name} 已被释放")

    # 使用资源的方法
    def use(self):
        # 检查资源是否已被获取
        if not self.is_acquired:
            # 如果未被获取，抛出异常
            raise RuntimeError(f"资源 {self.name} 未被获取")
        # 打印资源使用信息
        print(f"正在使用资源 {self.name}")

# 使用with语句管理资源
with CustomResource("数据库连接") as resource:
    # 在资源被获取和释放之间执行的代码
    resource.use()
    print("执行数据库操作")

# 预期输出:
# 资源 数据库连接 已被获取
# 正在使用资源 数据库连接
# 执行数据库操作
# 资源 数据库连接 已被释放

# 定义一个文件管理器类
class FileManager:
    # 构造函数
    def __init__(self, filename, mode='r'):
        # 初始化文件名
        self.filename = filename
        # 初始化文件模式
        self.mode = mode
        # 初始化文件对象
        self.file = None

    # 进入上下文时调用
    def __enter__(self):
        # 打开文件
        self.file = open(self.filename, self.mode)
        # 打印文件打开信息
        print(f"文件 {self.filename} 已打开")
        # 返回文件对象
        return self.file

    # 退出上下文时调用
    def __exit__(self, exc_type, exc_val, exc_tb):
        # 检查文件是否已打开
        if self.file:
            # 关闭文件
            self.file.close()
            # 打印文件关闭信息
            print(f"文件 {self.filename} 已关闭")
        # 如果发生异常，打印异常信息
        if exc_type:
            print(f"发生异常: {exc_type.__name__}: {exc_val}")
        # 返回False，让异常继续传播
        return False

# 使用with语句管理文件
try:
    with FileManager("test.txt", "w") as f:
        # 写入文件
        f.write("Hello, World!")
        print("文件写入完成")
except FileNotFoundError as e:
    print(f"文件操作失败: {e}")

# 定义一个自定义列表类
class CustomList:
    # 构造函数，初始化一个空列表来存储元素
    def __init__(self):
        # 初始化内部列表
        self.items = []

    # 定义列表的长度，使len()函数可以作用于CustomList对象
    def __len__(self):
        # 返回内部列表的长度
        return len(self.items)

    # 定义获取元素的方法，使CustomList对象支持索引访问
    def __getitem__(self, idx):
        # 返回指定索引的元素
        return self.items[idx]

    # 定义设置元素的方法，使CustomList对象支持索引赋值
    def __setitem__(self, idx, value):
        # 设置指定索引的元素
        self.items[idx] = value

    # 定义删除元素的方法，使CustomList对象支持del操作
    def __delitem__(self, idx):
        # 删除指定索引的元素
        del self.items[idx]

    # 定义成员测试的行为，处理 in 运算符
    def __contains__(self, item):
        # 检查元素是否在列表中
        return item in self.items

    # 定义迭代行为
    def __iter__(self):
        # 返回内部列表的迭代器
        return iter(self.items)

    # 添加元素的方法
    def append(self, item):
        # 添加元素到列表末尾
        self.items.append(item)

    # 插入元素的方法
    def insert(self, idx, item):
        # 在指定位置插入元素
        self.items.insert(idx, item)

    # 删除元素的方法
    def remove(self, item):
        # 删除指定元素
        self.items.remove(item)

    # 定义对象的官方字符串表示
    def __repr__(self):
        # 返回列表的字符串表示
        return f"CustomList({self.items})"

    # 定义对象的非正式字符串表示
    def __str__(self):
        # 返回列表的字符串表示
        return str(self.items)

# 创建自定义列表
cl = CustomList()
# 添加元素
cl.append(1)
cl.append(2)
cl.append(3)
# 测试列表操作
print(f"列表长度: {len(cl)}")
print(f"索引0的元素: {cl[0]}")
print(f"索引1的元素: {cl[1]}")
# 修改元素
cl[1] = 10
print(f"修改后的列表: {cl}")
# 测试成员测试
print(f"1 在列表中: {1 in cl}")
print(f"5 在列表中: {5 in cl}")
# 测试迭代
print("列表元素:")
for item in cl:
    print(f"  {item}")
# 删除元素
del cl[0]
print(f"删除第一个元素后: {cl}")

# 定义一个自定义字典类
class CustomDict:
    # 构造函数，初始化一个空字典
    def __init__(self):
        # 初始化内部字典
        self.data = {}

    # 定义获取元素的方法，使CustomDict对象支持键访问
    def __getitem__(self, key):
        # 返回指定键的值
        return self.data[key]

    # 定义设置元素的方法，使CustomDict对象支持键赋值
    def __setitem__(self, key, value):
        # 设置指定键的值
        self.data[key] = value

    # 定义删除元素的方法，使CustomDict对象支持del操作
    def __delitem__(self, key):
        # 删除指定键
        del self.data[key]

    # 定义成员测试的行为，处理 in 运算符
    def __contains__(self, key):
        # 检查键是否在字典中
        return key in self.data

    # 定义字典的长度
    def __len__(self):
        # 返回字典的长度
        return len(self.data)

    # 定义迭代行为
    def __iter__(self):
        # 返回字典键的迭代器
        return iter(self.data)

    # 定义对象的官方字符串表示
    def __repr__(self):
        # 返回字典的字符串表示
        return f"CustomDict({self.data})"

    # 定义对象的非正式字符串表示
    def __str__(self):
        # 返回字典的字符串表示
        return str(self.data)

    # 获取所有键
    def keys(self):
        # 返回字典的所有键
        return self.data.keys()

    # 获取所有值
    def values(self):
        # 返回字典的所有值
        return self.data.values()

    # 获取所有键值对
    def items(self):
        # 返回字典的所有键值对
        return self.data.items()

# 创建自定义字典
cd = CustomDict()
# 添加键值对
cd["name"] = "Alice"
cd["age"] = 30
cd["city"] = "New York"
# 测试字典操作
print(f"字典长度: {len(cd)}")
print(f"name的值: {cd['name']}")
print(f"age的值: {cd['age']}")
# 测试成员测试
print(f"'name' 在字典中: {'name' in cd}")
print(f"'salary' 在字典中: {'salary' in cd}")
# 测试迭代
print("字典键值对:")
for key, value in cd.items():
    print(f"  {key}: {value}")
# 删除键
del cd["city"]
print(f"删除'city'后: {cd}")

# 定义一个可调用对象类
class CallableDemo:
    # 构造函数
    def __init__(self, multiplier):
        # 初始化乘数
        self.multiplier = multiplier

    # 使对象可以像函数一样被调用
    def __call__(self, value):
        # 返回乘数乘以值的结果
        return self.multiplier * value

    # 定义字符串表示
    def __str__(self):
        return f"CallableDemo(multiplier={self.multiplier})"

# 测试可调用对象
print("--- 可调用对象演示 ---")
# 创建可调用对象
multiplier = CallableDemo(5)
# 像函数一样调用对象
result1 = multiplier(10)
result2 = multiplier(20)
print(f"multiplier(10) = {result1}")
print(f"multiplier(20) = {result2}")

# 定义一个属性访问控制类
class AttributeDemo:
    # 构造函数
    def __init__(self):
        # 初始化私有属性
        self._private_data = {}

    # 定义属性访问方法
    def __getattr__(self, name):
        # 当访问不存在的属性时调用
        print(f"访问不存在的属性: {name}")
        # 返回默认值
        return None

    # 定义属性设置方法
    def __setattr__(self, name, value):
        # 当设置属性时调用
        print(f"设置属性: {name} = {value}")
        # 调用父类的__setattr__方法
        super().__setattr__(name, value)

    # 定义属性删除方法
    def __delattr__(self, name):
        # 当删除属性时调用
        print(f"删除属性: {name}")
        # 调用父类的__delattr__方法
        super().__delattr__(name)

    # 定义属性存在检查方法
    def __hasattr__(self, name):
        # 检查属性是否存在
        return hasattr(self, name)

# 测试属性访问控制
print("--- 属性访问控制演示 ---")
# 创建对象
obj = AttributeDemo()
# 设置属性
obj.name = "Alice"
obj.age = 30
# 访问属性
print(f"name: {obj.name}")
print(f"age: {obj.age}")
# 访问不存在的属性
print(f"salary: {obj.salary}")
# 删除属性
del obj.age