Python类的特殊用法

Python类的特殊用法

重写_repr_()方法

重写_repr_()方法可以让对象打印出自我描述的信息，代码如下：

class Apple:
    def __init__(self, color, weight):
        self.color = color
        self.weight = weight
  
    # 重写 __repr__ 方法，自定义对象打印格式
    def __repr__(self):
        return f"Apple[color={self.color}, weight={self.weight}]"

# 创建实例并打印
a = Apple("红色", 5.68)
print(a)

输出结果就会是：
Apple[color=红色, weight=5.68]
如果没重写 __repr__，默认会打印类似 <__main__.Apple object at 0x00000123456789> 的内存地址信息，而重写后能直观展示对象的属性值，调试和查看信息更方便。

_del_方法

该方法用于回收对象类似与JVM中大GC，执行该方法有个要求执行时必须引用计数器为0，不然它不会立刻执行。

_dir_方法

例如执行print(dir(对象))就会打印出我们为该对象定义的属性和方法，当然还有系统内置的一堆属性和方法，包括上面的_repr_和_del_

_dict_方法

可以用来查看对象内部存储的所有属性名和属性值组成的字典，也可以通过该方法直接修改，代码例子如下:

class Item:
    def __init__(self, name, price):
        self.name = name
        self.price = price

# 创建Item实例
im = Item('鼠标', 28.9)

# 打印实例的__dict__属性（存储所有实例属性的字典）
print(im.__dict__)  # ①

# 通过__dict__访问name属性
print(im.__dict__['name'])

# 通过__dict__访问price属性
print(im.__dict__['price'])

# 通过__dict__修改name属性值
im.__dict__['name'] = '键盘'

# 通过__dict__修改price属性值
im.__dict__['price'] = 32.8

# 验证修改结果
print(im.name)   # 输出：键盘
print(im.price)  # 输出：32.8

输出结果为：

{'name': '鼠标', 'price': 28.9}
鼠标
28.9
键盘
32.8

getattr、__setattr__等

这几个方法是 Python 中 **“属性操作拦截器”—— 当你访问、赋值、删除对象属性时，Python 会自动调用这些方法，让你能拦截并自定义属性操作的逻辑

反射相关方法

hasattr(obj, name)：检查属性 / 方法是否存在。

getattr(object, name[, default])：获取属性 / 方法的值。

setattr(obj, name, value)：设置属性 / 方法的值，甚至能把方法变成属性。

序列相关方法

len(self)：返回序列中元素的个数。
getitem(self, key)：获取指定索引对应的元素，key 需为整数或 slice 对象，否则引发 KeyError 异常。
contains(self, item)：判断序列是否包含指定元素。
setitem(self, key, value)：设置指定索引对应的元素，key 需为整数或 slice 对象，否则引发 KeyError 异常。
delitem(self, key)：删除指定索引对应的元素。

生成器

进阶版迭代器，当你需要时它才在内存中生成，例子代码:

# 无限斐波那契生成器（永远不会耗尽，除非手动停止）
def infinite_fib():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# 遍历 10 个元素后停止（避免无限循环）
fib_inf = infinite_fib()
for _ in range(10):
    print(next(fib_inf), end=' ')  # 输出：0 1 1 2 3 5 8 13 21 34

自定义运算符方法

运算符重写的核心是：在自定义类中定义对应的 “魔法方法”（如 __add__ 对应 +、__eq__ 对应 ==），让自定义实例支持 Python 内置运算符。最佳实践就是在自己要操作的类下面直接重写—— 这样逻辑闭环、代码可读性强，符合 “类的封装特性”。代码例子如下:

class Money:
    def __init__(self, amount):
        self.amount = amount  # 实例属性：金额

    # 重写 + 运算符（对应 __add__）
    def __add__(self, other):
        # 先判断 other 是否是 Money 实例（避免和其他类型运算报错）
        if isinstance(other, Money):
            return Money(self.amount + other.amount)  # 返回新的 Money 实例（不修改原实例）
        else:
            raise TypeError("只能和 Money 实例相加")

    # 重写 - 运算符（对应 __sub__）
    def __sub__(self, other):
        if isinstance(other, Money):
            return Money(self.amount - other.amount)
        else:
            raise TypeError("只能和 Money 实例相减")

    # 重写 == 运算符（对应 __eq__）
    def __eq__(self, other):
        if isinstance(other, Money):
            return self.amount == other.amount  # 比较金额是否相等
        return False  # 非 Money 实例直接返回不相等

    # 重写 len() 函数（对应 __len__，这里自定义逻辑：金额的位数）
    def __len__(self):
        return len(str(abs(self.amount)))  # 绝对值转字符串，取长度

    # 可选：重写 __str__，方便打印实例
    def __str__(self):
        return f"￥{self.amount}"


# 测试运算符重写效果
if __name__ == "__main__":
    m1 = Money(100)
    m2 = Money(200)

    # 测试 + 运算
    m3 = m1 + m2
    print(m3)  # 输出：￥300（调用 __add__）

    # 测试 - 运算
    m4 = m2 - m1
    print(m4)  # 输出：￥100（调用 __sub__）

    # 测试 == 运算
    print(m1 == m2)  # 输出：False（调用 __eq__）
    print(m1 == Money(100))  # 输出：True

    # 测试 len() 函数
    print(len(m1))  # 输出：3（100 是 3 位数，调用 __len__）
    print(len(Money(-50)))  # 输出：2（绝对值 50 是 2 位数）