魔术方法全景

def simulate_instantiation(cls, *args, **kwargs):
    # 第一步：请 __new__ 造出空壳（毛坯对象）
    obj = cls.__new__(cls, *args, **kwargs)

    # 第二步：只有当这个壳确实是 cls（或其子类）的实例时，才会进行装修
    if isinstance(obj, cls):
        obj.__init__(*args, **kwargs)

    # 第三步：交出成品
    return obj


class Employee:
    def __init__(self, name, level):
        self.name = name
        self.level = level

    def report(self):
        print(f"我是 {self.name}，职级 L{self.level}")


emp = simulate_instantiation(Employee, "阿明", 7)
emp.report()  # 我是 阿明，职级 L7

class AppConfig:
    _sole = None

    def __new__(cls):
        if cls._sole is None:
            cls._sole = super().__new__(cls)
        return cls._sole


cfg_a = AppConfig()
cfg_b = AppConfig()
print(cfg_a is cfg_b)  # True —— 无论要多少次，给的都是同一个对象

class TileFactory:
    """游戏里的地砖工厂：同一种地砖只生产一次，之后反复复用"""

    _pool = {}

    def __new__(cls, tile_id):
        if tile_id not in cls._pool:
            cls._pool[tile_id] = super().__new__(cls)
        return cls._pool[tile_id]


grass_a = TileFactory("grass")
grass_b = TileFactory("grass")
water = TileFactory("water")

print(grass_a is grass_b)  # True —— 草地砖是同一块
print(grass_a is water)    # False —— 水地砖另造了一块

class ScoreInt:
    """百分制分数：传入负数时，不报错，直接退回一个普通的 0"""

    def __new__(cls, value):
        if value < 0:
            return 0  # 注意：这是 int 类型的 0，不是 ScoreInt 的实例
        return super().__new__(cls)

    def __init__(self, value):
        print("ScoreInt.__init__ 执行了")
        self.value = value


good = ScoreInt(88)
print(type(good), good.value)  # <class 'ScoreInt'> 88

bad = ScoreInt(-5)
print(type(bad), bad)          # <class 'int'> 0，且上面那行 __init__ 的打印没出现！

print(callable(len))          # True，内置函数
print(callable(dict))         # True，类本身也是可调用的（调用它就是造实例）
print(callable([1, 2]))       # False，列表不能调用
print(callable(lambda x: x))  # True，lambda 表达式

class Calibrator:
    """仪器校准器：给每次读数加上一个固定偏移量"""

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

    def __call__(self, reading):
        return reading + self.offset


fix = Calibrator(-2)
print(callable(fix))  # True —— 从此实例也" callable "了
print(fix(100))       # 98
print(fix(50))        # 48

class Resizer:
    """图片缩放器：出厂时定好缩放比例"""

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

    def __call__(self, pixel):
        return round(pixel * self.ratio)


shrink = Resizer(0.5)
enlarge = Resizer(2)

print(shrink(1920))   # 960
print(enlarge(1920))  # 3840

class AuditTrail:
    def __init__(self, tag):
        self.tag = tag
        self.entries = 0

    def __call__(self, message):
        self.entries += 1
        print(f"[{self.tag}] 第{self.entries}条：{message}")


audit = AuditTrail("支付")
audit("订单已创建")    # [支付] 第1条：订单已创建
audit("扣款成功")      # [支付] 第2条：扣款成功

class Movie:
    def __init__(self, title, minutes):
        self.title = title
        self.minutes = minutes

    def __str__(self):
        """给普通用户看：说人话"""
        return f"《{self.title}》片长 {self.minutes} 分钟"

    def __repr__(self):
        """给开发者看：最好能直接复制粘贴来重建对象"""
        return f"Movie({self.title!r}, {self.minutes})"


film = Movie("星际漫游", 148)
print(film)        # 《星际漫游》片长 148 分钟 —— 走的是 __str__
print(str(film))   # 同上
print(repr(film))  # Movie('星际漫游', 148) —— 走的是 __repr__
# 在交互式解释器里直接敲变量名回车，显示的也是 __repr__ 的结果

class Staff:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def __eq__(self, other):
        if not isinstance(other, Staff):
            return NotImplemented  # 告诉 Python："比不了"，让它另想办法
        return self.salary == other.salary

    def __lt__(self, other):
        if not isinstance(other, Staff):
            return NotImplemented
        return self.salary < other.salary

    def __le__(self, other):
        return self < other or self == other

    def __gt__(self, other):
        return not self <= other

    def __ge__(self, other):
        return not self < other

    def __ne__(self, other):
        return not self == other

    def __repr__(self):
        return f"Staff({self.name!r}, {self.salary})"


lao_wang = Staff("老王", 12000)
xiao_li = Staff("小李", 9500)

print(lao_wang == xiao_li)  # False —— 薪资不同
print(lao_wang > xiao_li)   # True
print(lao_wang <= xiao_li)  # False

# 比较方法就位后，sorted 也能直接用了
team = [xiao_li, lao_wang]
print(sorted(team))  # [Staff('小李', 9500), Staff('老王', 12000)]

from functools import total_ordering


@total_ordering
class Staff:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def __eq__(self, other):
        if not isinstance(other, Staff):
            return NotImplemented
        return self.salary == other.salary

    def __lt__(self, other):
        if not isinstance(other, Staff):
            return NotImplemented
        return self.salary < other.salary

    def __repr__(self):
        return f"Staff({self.name!r}, {self.salary})"

class Move:
    """机器人在平面上的位移（横向 dx，纵向 dy）"""

    def __init__(self, dx, dy):
        self.dx = dx
        self.dy = dy

    def __add__(self, other):
        """+：位移叠加"""
        if isinstance(other, Move):
            return Move(self.dx + other.dx, self.dy + other.dy)
        return NotImplemented  # 交给 Python 去试 other 的 __radd__

    def __sub__(self, other):
        """-：位移相减"""
        if isinstance(other, Move):
            return Move(self.dx - other.dx, self.dy - other.dy)
        return NotImplemented

    def __mul__(self, factor):
        """*：位移 × 倍数"""
        if isinstance(factor, (int, float)):
            return Move(self.dx * factor, self.dy * factor)
        return NotImplemented

    def __rmul__(self, factor):
        """右乘：倍数 × 位移（3 * m 时，int 不知道怎么乘 Move，就反过来找这里）"""
        return self * factor  # 直接复用 __mul__

    def __truediv__(self, factor):
        """/：位移 ÷ 倍数"""
        if isinstance(factor, (int, float)):
            return Move(self.dx / factor, self.dy / factor)
        return NotImplemented

    def __neg__(self):
        """取反：-m，方向调转 180 度"""
        return Move(-self.dx, -self.dy)

    def __abs__(self):
        """abs(m)：位移的直线距离"""
        return (self.dx ** 2 + self.dy ** 2) ** 0.5

    def __repr__(self):
        return f"Move({self.dx}, {self.dy})"


step_a = Move(1, 2)
step_b = Move(3, 4)

print(step_a + step_b)   # Move(4, 6)
print(step_b - step_a)   # Move(2, 2)
print(step_a * 3)        # Move(3, 6)
print(2 * step_a)        # Move(2, 4) —— int 不会乘 Move，触发的是 __rmul__
print(-step_a)           # Move(-1, -2)
print(abs(step_a))       # 2.23606797749979

class Playlist:
    """播放列表：对外的用法和列表几乎一模一样"""

    def __init__(self):
        self._tracks = []

    def add(self, track):
        self._tracks.append(track)

    def __len__(self):
        """len(playlist)"""
        return len(self._tracks)

    def __getitem__(self, index):
        """playlist[index]，天然支持切片"""
        return self._tracks[index]

    def __setitem__(self, index, track):
        """playlist[index] = track"""
        self._tracks[index] = track

    def __delitem__(self, index):
        """del playlist[index]"""
        del self._tracks[index]

    def __contains__(self, track):
        """track in playlist"""
        return track in self._tracks

    def __iter__(self):
        """for track in playlist"""
        return iter(self._tracks)

    def __repr__(self):
        return f"Playlist({self._tracks!r})"


my_list = Playlist()
my_list.add("晴天")
my_list.add("海阔天空")
my_list.add("夜曲")

print(len(my_list))          # 3
print(my_list[0])            # 晴天
print(my_list[1:])           # ['海阔天空', '夜曲'] —— 切片也没问题
print("夜曲" in my_list)     # True

for track in my_list:
    print(track)
# 晴天
# 海阔天空
# 夜曲

class Percent:
    """百分比数值，比如 85.5 表示 85.5%"""

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

    def __int__(self):
        """int(p)：抹掉小数取整"""
        return int(self.value)

    def __float__(self):
        """float(p)：转成浮点数"""
        return float(self.value)

    def __bool__(self):
        """bool(p)：0% 视为 False，其余为 True"""
        return self.value != 0

    def __repr__(self):
        return f"Percent({self.value})"


p = Percent(85.5)
print(int(p))    # 85
print(float(p))  # 85.5
print(bool(p))   # True

print(bool(Percent(0)))  # False

class Session:
    def __init__(self):
        # 注意：这里必须借道 object.__setattr__，否则会陷入无限递归
        object.__setattr__(self, "_store", {})

    def __getattr__(self, name):
        if name in self._store:
            return self._store[name]
        raise AttributeError(f"'{type(self).__name__}' 身上没有 '{name}' 这个属性")

    def __setattr__(self, name, value):
        if name.startswith("_"):
            # 下划线开头的内部属性走正常通道，绕开拦截，避免递归
            object.__setattr__(self, name, value)
        else:
            self._store[name] = value

    def __delattr__(self, name):
        if name in self._store:
            del self._store[name]
        else:
            raise AttributeError(f"'{type(self).__name__}' 身上没有 '{name}' 这个属性")

    def __repr__(self):
        return f"Session({self._store!r})"


sess = Session()
sess.user = "阿明"     # 触发 __setattr__，存入 _store
sess.vip = True
print(sess.user)       # 阿明 —— 触发 __getattr__
del sess.vip           # 触发 __delattr__
print(sess)            # Session({'user': '阿明'})

class Tracer:
    def __init__(self):
        self.present = 100

    def __getattribute__(self, name):
        # 总闸门：无论访问什么属性，都会先到这里报到
        print(f"有代码正在读取属性: {name}")
        # 必须借道 object.__getattribute__，否则自己访问自己，递归到死
        return object.__getattribute__(self, name)

    def __getattr__(self, name):
        # 能走到这里，说明 __getattribute__ 没找到，来问我要个说法
        return f"'{name}' 不存在，给个默认值顶一下"


t = Tracer()
print(t.present)   # 先打印访问日志，再输出 100
print(t.ghost)     # 先触发 __getattribute__（找不到），再落入 __getattr__

class FileHandle:
    def __init__(self, path):
        self.path = path
        print(f"打开文件: {path}")

    def __del__(self):
        print(f"关闭文件: {self.path}")


fh = FileHandle("report.csv")
del fh  # 关闭文件: report.csv

bus_a = EventBus()
bus_b = EventBus()
print(bus_a is bus_b)  # 应该输出 True

odo = Odometer(1000)
print(odo())      # 1001
odo()             # 1002
print(odo.get())  # 1002
odo.reset()
print(odo.get())  # 1000

class Bell:
    def __call__(self):
        print("叮 —— 基础铃声")

class Alarm(Bell):
    def __call__(self):
        print("嘀嘀！警报铃声")
        super().__call__()

alarm = Alarm()
alarm()

f1 = Frequency(1, 2)  # 每 2 秒 1 次
f2 = Frequency(1, 3)  # 每 3 秒 1 次

print(f1 + f2)    # 5/6 —— 两路事件合并后的频率
print(f1 - f2)    # 1/6
print(f1 * f2)    # 1/6
print(f1 / f2)    # 3/2
print(f1 == f2)   # False
print(f1 > f2)    # True
print(float(f1))  # 0.5
print(str(f1))    # 1/2
print(repr(f1))   # Frequency(1, 2)