Python魔法方法全解:从入门到运算符重载的完整指南

class Book:
    def __init__(self, title, price):
        self.title = title
        self.price = price

    def __str__(self):
        return f"《{self.title}》 ¥{self.price}"

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

b = Book("Python入门", 59)
print(b)          # 《Python入门》 ¥59     自动调 __str__
print(len(b))     # 11                      自动调 __len__

class Resource:
    def __init__(self, name):
        self.name = name
        print(f"{name} 被创建")

    def __del__(self):
        print(f"{self.name} 被销毁")

r = Resource("连接")
del r       # 连接 被销毁

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

    def __str__(self):
        """给终端用户看：print()、str()"""
        return f"({self.x}, {self.y})"

    def __repr__(self):
        """给开发者看：调试、交互式环境、容器里打印"""
        return f"Point({self.x}, {self.y})"

    def __format__(self, spec):
        """支持 f-string 的自定义格式"""
        if spec == "verbose":
            return f"横坐标={self.x}, 纵坐标={self.y}"
        return str(self)

p = Point(3, 4)
print(f"{p}")              # (3, 4)
print(f"{p:verbose}")      # 横坐标=3, 纵坐标=4
print([p])                 # [Point(3, 4)]   容器里用 __repr__

class Money:
    def __init__(self, amount):
        self.amount = amount

    def __eq__(self, other):
        return self.amount == other.amount

    def __lt__(self, other):
        return self.amount < other.amount

    def __le__(self, other):
        return self.amount <= other.amount

    def __gt__(self, other):
        return self.amount > other.amount

    def __ge__(self, other):
        return self.amount >= other.amount

    def __ne__(self, other):
        return self.amount != other.amount

m1, m2 = Money(100), Money(200)
print(m1 < m2)         # True
print(sorted([m2, m1]))    # 能排序了

from functools import total_ordering

@total_ordering
class Money:
    def __init__(self, amount):
        self.amount = amount

    def __eq__(self, other):
        return self.amount == other.amount

    def __lt__(self, other):
        return self.amount < other.amount

    def __repr__(self):
        return f"Money({self.amount})"

class Money:
    def __init__(self, amount):
        self.amount = amount
    def __eq__(self, other):
        return self.amount == other.amount
    def __hash__(self):
        return hash(self.amount)      # 补上就能哈希了

{Money(1), Money(2)}     # ✅

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

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

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

    def __mul__(self, n):
        return Vector(self.x * n, self.y * n)

    def __rmul__(self, n):
        return self.__mul__(n)        # 支持 n * vector

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

    def __abs__(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5

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

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)      # Vector(4, 6)
print(v2 - v1)      # Vector(2, 2)
print(v1 * 3)       # Vector(3, 6)
print(3 * v1)       # Vector(3, 6)   ← 靠 __rmul__
print(abs(v2))      # 5.0

class Playlist:
    def __init__(self):
        self._songs = []

    def add(self, song):
        self._songs.append(song)

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

    def __getitem__(self, index):
        return self._songs[index]        # 支持下标和切片

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

    def __contains__(self, item):
        return item in self._songs       # 支持 in

    def __iter__(self):
        return iter(self._songs)         # 支持 for 遍历

    def __repr__(self):
        return f"Playlist({len(self)} songs)"

pl = Playlist()
pl.add("晴天")
pl.add("稻香")

print(len(pl))          # 2
print(pl[0])            # 晴天
print("稻香" in pl)      # True
for song in pl:         # 能遍历
    print(song)

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

c = Counter()
print(c())      # 1      像函数一样调用
print(c())      # 2
print(callable(c))    # True

class Timer:
    import time

    def __enter__(self):
        self.start = time.time()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.elapsed = time.time() - self.start
        print(f"耗时 {self.elapsed:.3f} 秒")
        return False      # False = 不吞异常

with Timer() as t:
    sum(range(10_000_00))
# 耗时 0.045 秒

class DBConnection:
    def __init__(self, dsn):
        self.dsn = dsn
        self.conn = None

    def __enter__(self):
        print(f"连接数据库 {self.dsn}")
        self.conn = {"connected": True}
        return self.conn

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("关闭数据库连接")
        self.conn = None
        if exc_type:
            print(f"发生异常：{exc_val}")
        return False

with DBConnection("sqlite:///app.db") as conn:
    print(conn)