核心概念与设计原则
面向对象编程（OOP）的四大支柱在Python中体现为：
– 封装：通过__前缀实现名称修饰的私有成员
– 继承：支持多重继承的MRO（方法解析顺序）机制
– 多态：鸭子类型（Duck Typing）实现的运行时绑定
– 抽象：abc模块提供的抽象基类支持
class Animal:
def __init__(self, name):
self.__name = name # 名称修饰实现封装
@property
def name(self):
return self.__name
class Flyable:
def fly(self):
print("Flying behavior")
class Bird(Animal, Flyable): # 多重继承
def __init__(self, name, wingspan):
super().__init__(name)
self.wingspan = wingspan
def make_sound(self):
print("Chirp!")
parrot = Bird("Polly", 12)
print(parrot.name) # 通过property访问私有属性
parrot.fly() # 混合类方法调用
Python的MRO采用C3线性化算法，可通过ClassName.__mro__查看解析顺序。当出现菱形继承问题时，该算法能保证：
1. 子类优先于父类
2. 声明顺序从左到右
3. 同一类只会被访问一次
高级特性实现
魔术方法与运算符重载
Python通过特殊方法实现运算符重载，例如实现向量类：
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def __str__(self):
return f"Vector({self.x}, {self.y})"
def __eq__(self, other):
return self.x == other.x and self.y == other.y
v1 = Vector(2, 3)
v2 = Vector(4, 5)
print(v1 + v2) # 输出: Vector(6, 8)
关键魔术方法包括：
– __getitem__/__setitem__：索引操作
– __iter__/__next__：迭代协议
– __enter__/__exit__：上下文管理器
– __call__：使实例可调用
描述符协议
描述符是实现属性访问控制的核心机制：
class PositiveNumber:
def __set_name__(self, owner, name):
self.name = name
def __get__(self, obj, objtype):
return obj.__dict__.get(self.name)
def __set__(self, obj, value):
if value <= 0:
raise ValueError("Positive number required")
obj.__dict__[self.name] = value
class Account:
balance = PositiveNumber() # 描述符实例
def __init__(self, initial_balance):
self.balance = initial_balance
acc = Account(100)
try:
acc.balance = -50 # 触发ValueError
except ValueError as e:
print(e)
设计模式实践
工厂模式变体
Python中实现灵活的对象创建方式：
class DataProcessor:
@classmethod
def create_processor(cls, format):
processors = {
'json': JSONProcessor,
'csv': CSVProcessor,
'xml': XMLProcessor
}
return processors[format.lower()]()
def process(self, data):
raise NotImplementedError
class JSONProcessor(DataProcessor):
def process(self, data):
print("Processing JSON data")
processor = DataProcessor.create_processor('json')
processor.process(sample_data)
观察者模式实现
利用Python弱引用避免内存泄漏：
from weakref import WeakKeyDictionary
class Observable:
def __init__(self):
self.__observers = WeakKeyDictionary()
def add_observer(self, observer):
self.__observers[observer] = 1
def notify_observers(self, *args, **kwargs):
for observer in self.__observers:
observer.update(*args, **kwargs)
class Observer:
def update(self, *args, **kwargs):
print(f"Received update: {args}")
subject = Observable()
observer = Observer()
subject.add_observer(observer)
subject.notify_observers("Data changed")
性能优化策略
内存管理技巧
- __slots__ 优化：
class Optimized:
__slots__ = ['x', 'y'] # 替代__dict__存储
def __init__(self, x, y):
self.x = x
self.y = y
- 循环引用处理：
import gc
gc.collect() # 手动触发垃圾回收
方法调用加速
使用__dict__直接访问替代属性查找：
def fast_method_call(obj):
method = obj.__dict__['calculate']
return method()
现代Python特性
数据类简化
Python 3.7+的dataclass自动生成样板代码：
from dataclasses import dataclass, field
from typing import List
@dataclass(order=True)
class InventoryItem:
name: str
unit_price: float
quantity: int = 0
tags: List[str] = field(default_factory=list)
item = InventoryItem("Widget", 19.99, 5)
print(item) # 自动生成__repr__
类型注解体系
from typing import TypeVar, Generic, Protocol
T = TypeVar('T')
class Stack(Generic[T]):
def __init__(self):
self.items: List[T] = []
def push(self, item: T) -> None:
self.items.append(item)
def pop(self) -> T:
return self.items.pop()
class SupportsClose(Protocol):
def close(self) -> None: ...
def cleanup(resource: SupportsClose) -> None:
resource.close()
测试与调试
单元测试实践
import unittest
from unittest.mock import MagicMock
class TestProcessor(unittest.TestCase):
def setUp(self):
self.processor = DataProcessor.create_processor('json')
def test_processing(self):
mock_data = MagicMock()
self.processor.process(mock_data)
mock_data.validate.assert_called_once()
@unittest.expectedFailure
def test_failure_case(self):
self.assertEqual(1, 2)
调试技巧
- 使用
breakpoint()进入PDB调试器 - 对象检查：
import inspect
print(inspect.getmembers(some_object))
行业最佳实践
- 组合优于继承：优先使用组合和Mixin
- 单一职责原则：保持类功能聚焦
- 防御性编程：使用类型提示和
assert - 文档规范：遵循PEP 257文档字符串标准
- 性能关键路径：考虑使用
__slots__和C扩展
class LoggableMixin:
def log(self, message):
print(f"[LOG] {message}")
class DatabaseConnection(LoggableMixin):
def connect(self):
self.log("Connecting to database")
# 连接逻辑...