1
class Dog:
2
    kind = "dog"  # 类变量：所有实例共享
3

4
    def __init__(self, name):
5
        self.name = name  # 实例变量：每个实例独立
6

7
d1 = Dog("旺财")
8
d2 = Dog("小白")
9

10
print(d1.kind)    # dog - 通过实例查找
11
print(d2.kind)    # dog
12
print(Dog.kind)   # dog - 通过类访问
13

14
d1.kind = "big dog"  # 创建实例变量，不影响类
15
print(d1.kind)    # big dog (实例变量)
16
print(d2.kind)    # dog (类变量)
17
print(Dog.kind)   # dog (类变量不变)

1
# 可变对象作为类变量的危险
2
class Registry:
3
    items = []  # 所有实例共享同一个列表！
4

5
r1 = Registry()
6
r2 = Registry()
7

8
r1.items.append("item1")
9
print(r2.items)  # ['item1'] - 意外共享！
10

11
# 正确做法：使用实例变量
12
class RegistryFixed:
13
    def __init__(self):
14
        self.items = []  # 每个实例独立列表
15

16
    def add(self, item):
17
        self.items.append(item)
18

19
r1 = RegistryFixed()
20
r2 = RegistryFixed()
21

22
r1.items.append("item1")
23
print(r2.items)  # [] - 独立列表

1
class Circle:
2
    def __init__(self, radius):
3
        self._radius = radius  # 私有属性
4

5
    @property
6
    def radius(self):
7
        return self._radius
8

9
    @radius.setter
10
    def radius(self, value):
11
        if value < 0:
12
            raise ValueError("半径不能为负数")
13
        self._radius = value
14

15
    @property
16
    def area(self):
17
        return 3.14159 * self._radius ** 2
18

19
c = Circle(5)
20
print(c.radius)  # 5
21
print(c.area)    # 78.53975
22
c.radius = 10
23
print(c.area)    # 314.159

1
class A:
2
    def method(self):
3
        return "A"
4

5
class B(A):
6
    def method(self):
7
        return "B"
8

9
class C(A):
10
    def method(self):
11
        return "C"
12

13
class D(B, C):
14
    pass
15

16
d = D()
17
print(d.method())  # "B" - 按 MRO 顺序优先使用 B
18

19
# 查看 MRO
20
print(D.__mro__)
21
# (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)

1
class Base:
2
    def __init__(self):
3
        print("Base init")
4

5
class Child(Base):
6
    def __init__(self):
7
        super().__init__()  # 调用父类
8
        print("Child init")
9

10
# super() 沿着 MRO 顺序查找
11
class A:
12
    def method(self):
13
        print("A")
14

15
class B(A):
16
    def method(self):
17
        super().method()
18
        print("B")
19

20
class C(A):
21
    def method(self):
22
        super().method()
23
        print("C")
24

25
class D(B, C):
26
    def method(self):
27
        super().method()
28
        print("D")
29

30
D().method()
31
# 输出: A C B D
32
# MRO: D -> B -> C -> A

1
# 菱形继承
2
class Base:
3
    def method(self):
4
        print("Base")
5

6
class Left(Base):
7
    pass
8

9
class Right(Base):
10
    def method(self):
11
        print("Right")
12

13
class Child(Left, Right):
14
    pass
15

16
Child().method()  # 无输出！Left 优先于 Right
17

18
# Python 3 使用 C3 线性化算法
19
# MRO: Child -> Left -> Right -> Base -> object
20

21
# 明确调用
22
class Child(Left, Right):
23
    def method(self):
24
        super().method()  # 调用 Left，然后 Right，然后 Base

1
# 方式1: __new__ 方法
2
class Singleton:
3
    _instance = None
4

5
    def __new__(cls):
6
        if cls._instance is None:
7
            cls._instance = super().__new__(cls)
8
        return cls._instance
9

10
# 方式2: 装饰器
11
def singleton(cls):
12
    instances = {}
13

14
    def get_instance(*args, **kwargs):
15
        if cls not in instances:
16
            instances[cls] = cls(*args, **kwargs)
17
        return instances[cls]
18

19
    return get_instance
20

21
@singleton
22
class Database:
23
    pass
24

25
# 方式3: 元类
26
class SingletonMeta(type):
27
    _instances = {}
28

29
    def __call__(cls, *args, **kwargs):
30
        if cls not in cls._instances:
31
            cls._instances[cls] = super().__call__(*args, **kwargs)
32
        return cls._instances[cls]
33

34
class Database(metaclass=SingletonMeta):
35
    pass
36

37
# 方式4: 模块级单例（最简单）
38
# mysingleton.py
39
class _MySingleton:
40
    pass
41
singleton = _MySingleton()

1
# 简单工厂
2
class Dog:
3
    def speak(self): return "汪汪"
4

5
class Cat:
6
    def speak(self): return "喵喵"
7

8
class Factory:
9
    @staticmethod
10
    def create(animal_type):
11
        animals = {"dog": Dog, "cat": Cat}
12
        return animals[animal_type]()
13

14
factory = Factory()
15
animal = factory.create("dog")
16
print(animal.speak())  # 汪汪
17

18
# 工厂方法模式
19
class Animal:
20
    def speak(self): raise NotImplementedError
21

22
class AnimalFactory:
23
    def create(self): raise NotImplementedError
24

25
class DogFactory(AnimalFactory):
26
    def create(self): return Dog()
27

28
# 抽象工厂
29
class AbstractFactory:
30
    def create_product_a(self): pass
31
    def create_product_b(self): pass

1
class Subject:
2
    def __init__(self):
3
        self._observers = []
4

5
    def attach(self, observer):
6
        self._observers.append(observer)
7

8
    def detach(self, observer):
9
        self._observers.remove(observer)
10

11
    def notify(self, message):
12
        for observer in self._observers:
13
            observer.update(message)
14

15
class Observer:
16
    def update(self, message):
17
        print(f"收到通知: {message}")
18

19
subject = Subject()
20
observer = Observer()
21
subject.attach(observer)
22
subject.notify("Hello")  # 收到通知: Hello

1
class SortStrategy:
2
    def sort(self, data): raise NotImplementedError
3

4
class QuickSort(SortStrategy):
5
    def sort(self, data):
6
        return sorted(data)
7

8
class MergeSort(SortStrategy):
9
    def sort(self, data):
10
        return sorted(data, reverse=True)
11

12
class Context:
13
    def __init__(self, strategy):
14
        self.strategy = strategy
15

16
    def execute(self, data):
17
        return self.strategy.sort(data)
18

19
context = Context(QuickSort())
20
print(context.execute([3, 1, 2]))  # [1, 2, 3]

1
# 组合优于继承
2
class Component:
3
    def operation(self): return "原始"
4

5
class Decorator(Component):
6
    def __init__(self, wrapped):
7
        self._wrapped = wrapped
8

9
    def operation(self):
10
        return f"装饰({self._wrapped.operation()})"
11

12
component = Component()
13
decorated = Decorator(component)
14
print(decorated.operation())  # 装饰(原始)

1
class TreeNode:
2
    def __init__(self, value, left=None, right=None):
3
        self.value = value
4
        self.left = left
5
        self.right = right
6

7
class Tree:
8
    def __init__(self, root):
9
        self.root = root
10

11
    def __iter__(self):
12
        # 中序遍历
13
        def inorder(node):
14
            if node is None:
15
                return
16
            yield from inorder(node.left)
17
            yield node.value
18
            yield from inorder(node.right)
19

20
        yield from inorder(self.root)
21

22
# 使用
23
root = TreeNode(1, TreeNode(2), TreeNode(3))
24
tree = Tree(root)
25
for value in tree:
26
    print(value)  # 2, 1, 3

1
class Vector:
2
    def __init__(self, x, y):
3
        self.x = x
4
        self.y = y
5

6
    # 字符串表示
7
    def __repr__(self): return f"Vector({self.x}, {self.y})"
8
    def __str__(self): return f"({self.x}, {self.y})"
9

10
    # 比较运算符
11
    def __eq__(self, other): return self.x == other.x and self.y == other.y
12
    def __lt__(self, other): return self.x < other.x or (self.x == other.x and self.y < other.y)
13

14
    # 算术运算符
15
    def __add__(self, other): return Vector(self.x + other.x, self.y + other.y)
16
    def __sub__(self, other): return Vector(self.x - other.x, self.y - other.y)
17
    def __mul__(self, scalar): return Vector(self.x * scalar, self.y * scalar)
18

19
    # 可调用
20
    def __call__(self): return f"Vector({self.x}, {self.y})"
21

22
    # 长度
23
    def __len__(self): return 2
24

25
    # 索引访问
26
    def __getitem__(self, index):
27
        if index == 0: return self.x
28
        if index == 1: return self.y
29
        raise IndexError

1
class CustomList:
2
    def __init__(self, items):
3
        self.items = items
4

5
    def __len__(self): return len(self.items)
6
    def __getitem__(self, i): return self.items[i]
7
    def __setitem__(self, i, v): self.items[i] = v
8
    def __contains__(self, v): return v in self.items
9
    def __iter__(self): return iter(self.items)
10
    def __add__(self, other): return CustomList(self.items + other.items)

1
from abc import ABC, abstractmethod
2

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

7
    @abstractmethod
8
    def perimeter(self): pass
9

10
    def display(self):
11
        print(f"Area: {self.area()}")
12

13
class Rectangle(Shape):
14
    def __init__(self, width, height):
15
        self.width = width
16
        self.height = height
17

18
    def area(self): return self.width * self.height
19
    def perimeter(self): return 2 * (self.width + self.height)
20

21
# 不能实例化抽象类
22
# shape = Shape()  # TypeError
23

24
rect = Rectangle(5, 3)
25
rect.display()  # Area: 15

1
from typing import Protocol
2

3
class Drawable(Protocol):
4
    def draw(self) -> None: ...
5

6
class Circle:
7
    def draw(self) -> None:
8
        print("Drawing circle")
9

10
def render(d: Drawable) -> None:
11
    d.draw()
12

13
render(Circle())  # 有效，Circle 实现了 draw 方法