1
class UpperStr(str):
2
    def __new__(cls, value):
3
        # 在对象创建前拦截，强制转换为大写
4
        return super().__new__(cls, value.upper())
5

6
s = UpperStr("hello")
7
print(s) # HELLO (str 是不可变的，必须在 __new__ 处理)

1
class Singleton:
2
    _instance = None
3

4
    def __new__(cls, *args, **kwargs):
5
        if cls._instance is None:
6
            # 只有第一次调用时才真正创建对象
7
            cls._instance = super().__new__(cls)
8
        return cls._instance
9

10
a = Singleton()
11
b = Singleton()
12
print(a is b)  # True

1
class Pixel:
2
    __slots__ = ('x', 'y')  # 锁定属性，禁止动态添加其他属性
3

4
    def __init__(self, x, y):
5
        self.x = x
6
        self.y = y
7

8
p = Pixel(10, 20)
9
# p.z = 30  # AttributeError: 'Pixel' object has no attribute 'z'

1
class Integer:
2
    """数据描述符：强制属性必须是整数"""
3
    def __init__(self, name):
4
        self.name = name
5

6
    def __get__(self, instance, owner):
7
        if instance is None:
8
            return self
9
        return instance.__dict__.get(self.name)
10

11
    def __set__(self, instance, value):
12
        if not isinstance(value, int):
13
            raise ValueError(f"{self.name} must be an integer")
14
        instance.__dict__[self.name] = value
15

16
class Point:
17
    x = Integer("x")  # 描述符实例作为类属性
18
    y = Integer("y")
19

20
    def __init__(self, x, y):
21
        self.x = x  # 触发 Integer.__set__
22
        self.y = y
23

24
p = Point(1, 2)
25
# p.x = "hello"  # ValueError: x must be an integer

1
class A:
2
    def say(self): print("A")
3

4
class B(A):
5
    def say(self): print("B")
6

7
class C(A):
8
    def say(self): print("C")
9

10
class D(B, C):
11
    pass
12

13
d = D()
14
d.say() # 输出 B
15
print(D.mro())
16
# [<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>]

1
class JsonSerializableMixin:
2
    def to_json(self):
3
        import json
4
        return json.dumps(self.__dict__)
5

6
class User(JsonSerializableMixin):
7
    def __init__(self, name):
8
        self.name = name
9

10
u = User("Alice")
11
print(u.to_json())  # {"name": "Alice"}

1
from abc import ABC, abstractmethod
2

3
class Shape(ABC):
4
    @abstractmethod
5
    def area(self):
6
        pass
7

8
class Circle(Shape):
9
    def __init__(self, r):
10
        self.r = r
11

12
    def area(self):
13
        return 3.14 * self.r ** 2
14

15
# s = Shape() # TypeError: Can't instantiate abstract class
16
c = Circle(5) # OK

1
from typing import Protocol
2

3
class Flyer(Protocol):
4
    def fly(self) -> None:
5
        ...
6

7
class Bird:
8
    def fly(self): print("Bird flying")
9

10
class Plane:
11
    def fly(self): print("Plane flying")
12

13
def lift_off(obj: Flyer):
14
    obj.fly()
15

16
# Bird 和 Plane 不需要显式继承 Flyer
17
lift_off(Bird())
18
lift_off(Plane())

1
class AutoDebugMeta(type):
2
    """自动给类中的所有方法添加打印调试信息的元类"""
3
    def __new__(mcs, name, bases, attrs):
4
        new_attrs = {}
5
        for key, value in attrs.items():
6
            if callable(value) and not key.startswith("__"):
7
                # 包装函数
8
                def wrapper(*args, **kwargs):
9
                    print(f"Calling {key}...")
10
                    return value(*args, **kwargs)
11
                new_attrs[key] = wrapper
12
            else:
13
                new_attrs[key] = value
14

15
        return super().__new__(mcs, name, bases, new_attrs)
16

17
class MyService(metaclass=AutoDebugMeta):
18
    def process(self):
19
        print("Processing...")
20

21
s = MyService()
22
s.process()
23
# 输出:
24
# Calling process...
25
# Processing...

1
import weakref
2

3
class Data:
4
    def __del__(self):
5
        print("Data died")
6

7
d = Data()
8
r = weakref.ref(d) # 创建弱引用
9

10
print(r()) # 获取对象: <__main__.Data object ...>
11
del d      # 删除唯一强引用，对象立即被回收，输出 "Data died"
12
print(r()) # None