Python 进阶：从熟练到精通的核心技能体系

一、高级函数与函数式编程

1.1 装饰器深度解析

# 带参数的装饰器
def repeat(num_times):
    def decorator_repeat(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator_repeat

# 类装饰器
class Timer:
    def __init__(self, func):
        self.func = func
        self.start_time = None
        
    def __call__(self, *args, **kwargs):
        self.start_time = time.time()
        result = self.func(*args, **kwargs)
        print(f"执行时间: {time.time() - self.start_time:.4f}秒")
        return result

# 使用 functools.lru_cache 实现缓存装饰器
from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

1.2 生成器与协程进阶

# 异步生成器
async def async_generator():
    for i in range(5):
        await asyncio.sleep(1)
        yield i

# 协程间通信
import asyncio
from collections import deque

class AsyncQueue:
    def __init__(self):
        self._queue = deque()
        self._getters = deque()
        
    async def put(self, item):
        self._queue.append(item)
        if self._getters:
            getter = self._getters.popleft()
            getter.set_result(True)
    
    async def get(self):
        while not self._queue:
            getter = asyncio.get_event_loop().create_future()
            self._getters.append(getter)
            await getter
        return self._queue.popleft()

二、元编程与魔术方法

2.1 元类编程

# 创建单例元类
class SingletonMeta(type):
    _instances = {}
    
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        return cls._instances[cls]

class Database(metaclass=SingletonMeta):
    def __init__(self):
        self.connection = self._create_connection()
    
    def _create_connection(self):
        return "Database Connection"

# 属性访问控制元类
class ReadOnlyMeta(type):
    def __new__(cls, name, bases, dct):
        new_dct = {}
        for key, value in dct.items():
            if not key.startswith('__'):
                # 将所有属性转为只读属性
                new_dct[key] = property(lambda self, v=value: v)
            else:
                new_dct[key] = value
        return super().__new__(cls, name, bases, new_dct)

2.2 描述符协议

# 类型验证描述符
class TypedAttribute:
    def __init__(self, name, expected_type):
        self.name = name
        self.expected_type = expected_type
        
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__.get(self.name)
    
    def __set__(self, instance, value):
        if not isinstance(value, self.expected_type):
            raise TypeError(f"Expected {self.expected_type}, got {type(value)}")
        instance.__dict__[self.name] = value
    
    def __delete__(self, instance):
        del instance.__dict__[self.name]

class Person:
    name = TypedAttribute("name", str)
    age = TypedAttribute("age", int)
    
    def __init__(self, name, age):
        self.name = name
        self.age = age

三、并发与并行编程

3.1 异步编程模式

# asyncio 高级用法
import asyncio
from concurrent.futures import ThreadPoolExecutor

class AsyncTaskManager:
    def __init__(self, max_workers=10):
        self.executor = ThreadPoolExecutor(max_workers=max_workers)
        self.semaphore = asyncio.Semaphore(max_workers)
    
    async def process_task_with_semaphore(self, task_func, *args):
        async with self.semaphore:
            loop = asyncio.get_event_loop()
            return await loop.run_in_executor(
                self.executor, task_func, *args
            )
    
    async def batch_process(self, tasks):
        results = []
        async_tasks = []
        
        for task in tasks:
            async_task = self.process_task_with_semaphore(
                task['func'], *task.get('args', [])
            )
            async_tasks.append(async_task)
        
        for future in asyncio.as_completed(async_tasks):
            result = await future
            results.append(result)
        
        return results

3.2 多进程数据处理

# 使用 multiprocessing 进行数据分片处理
from multiprocessing import Pool, Manager
import numpy as np

def parallel_map_reduce(data, map_func, reduce_func, chunksize=1000):
    """MapReduce 并行实现"""
    # 数据分片
    chunks = [data[i:i+chunksize] for i in range(0, len(data), chunksize)]
    
    with Pool() as pool:
        # Map 阶段
        mapped_results = pool.map(map_func, chunks)
        
        # Reduce 阶段
        final_result = reduce(reduce_func, mapped_results)
    
    return final_result

# 使用 Manager 实现进程间通信
def shared_counter_example():
    with Manager() as manager:
        counter = manager.Value('i', 0)
        lock = manager.Lock()
        
        def increment():
            with lock:
                counter.value += 1
        
        with Pool(4) as pool:
            pool.starmap(increment, [() for _ in range(1000)])
        
        print(f"Final counter value: {counter.value}")

四、内存管理与性能优化

4.1 对象内存优化

# 使用 __slots__ 减少内存占用
class Point:
    __slots__ = ('x', 'y')
    
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __repr__(self):
        return f"Point({self.x}, {self.y})"

# 使用 array 模块处理大量数值数据
import array
import random

class EfficientVector:
    def __init__(self, size):
        self._data = array.array('d', [0.0] * size)
        self.size = size
    
    def __setitem__(self, index, value):
        self._data[index] = value
    
    def __getitem__(self, index):
        return self._data[index]
    
    def dot_product(self, other):
        if self.size != other.size:
            raise ValueError("Vectors must have same size")
        return sum(a * b for a, b in zip(self._data, other._data))

4.2 性能分析工具

# 使用 cProfile 进行性能分析
import cProfile
import pstats
from io import StringIO

def profile_function(func, *args, **kwargs):
    """函数性能分析装饰器"""
    profiler = cProfile.Profile()
    profiler.enable()
    
    result = func(*args, **kwargs)
    
    profiler.disable()
    
    # 输出分析结果
    stream = StringIO()
    stats = pstats.Stats(profiler, stream=stream)
    stats.sort_stats('cumulative')
    stats.print_stats(20)  # 显示前20行
    
    print(stream.getvalue())
    return result

# 使用 memory_profiler 进行内存分析
from memory_profiler import profile

@profile
def memory_intensive_operation():
    large_list = [i**2 for i in range(1000000)]
    return sum(large_list)

五、设计模式与架构

5.1 设计模式实现

# 观察者模式
from abc import ABC, abstractmethod
from typing import List

class Observer(ABC):
    @abstractmethod
    def update(self, subject):
        pass

class Subject:
    def __init__(self):
        self._observers: List[Observer] = []
    
    def attach(self, observer: Observer):
        if observer not in self._observers:
            self._observers.append(observer)
    
    def detach(self, observer: Observer):
        try:
            self._observers.remove(observer)
        except ValueError:
            pass
    
    def notify(self):
        for observer in self._observers:
            observer.update(self)

# 策略模式
from typing import Protocol

class PaymentStrategy(Protocol):
    def pay(self, amount: float) -> bool:
        ...

class CreditCardPayment:
    def pay(self, amount: float) -> bool:
        print(f"Paid {amount} using Credit Card")
        return True

class PayPalPayment:
    def pay(self, amount: float) -> bool:
        print(f"Paid {amount} using PayPal")
        return True

class PaymentProcessor:
    def __init__(self, strategy: PaymentStrategy):
        self._strategy = strategy
    
    def set_strategy(self, strategy: PaymentStrategy):
        self._strategy = strategy
    
    def process_payment(self, amount: float) -> bool:
        return self._strategy.pay(amount)

5.2 依赖注入

from dataclasses import dataclass
from typing import Optional

class Database:
    def execute(self, query: str):
        print(f"Executing query: {query}")

class Service:
    def __init__(self, db: Database):
        self.db = db
    
    def do_something(self):
        self.db.execute("SELECT * FROM users")

@dataclass
class Container:
    db: Optional[Database] = None
    service: Optional[Service] = None
    
    def wire(self):
        if self.db is None:
            self.db = Database()
        if self.service is None:
            self.service = Service(self.db)
        
        return self

六、高级数据类型与算法

6.1 自定义数据结构

# LRU Cache 实现
from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity: int):
        self.cache = OrderedDict()
        self.capacity = capacity
    
    def get(self, key):
        if key not in self.cache:
            return -1
        
        self.cache.move_to_end(key)
        return self.cache[key]
    
    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

# 使用 heapq 实现优先队列
import heapq

class PriorityQueue:
    def __init__(self):
        self._heap = []
        self._index = 0
    
    def push(self, item, priority):
        heapq.heappush(self._heap, (priority, self._index, item))
        self._index += 1
    
    def pop(self):
        if self._heap:
            return heapq.heappop(self._heap)[-1]
        raise IndexError("pop from empty queue")

七、测试与调试

7.1 高级测试技术

# 使用 pytest 进行参数化测试
import pytest
from hypothesis import given, strategies as st

# 常规参数化
@pytest.mark.parametrize("input,expected", [
    (1, 2),
    (2, 4),
    (3, 6),
])
def test_double(input, expected):
    assert input * 2 == expected

# 基于属性的测试
@given(st.integers(), st.integers())
def test_addition_commutative(a, b):
    assert a + b == b + a

# 使用 unittest.mock 进行高级Mock
from unittest.mock import Mock, patch, MagicMock

class DatabaseTest:
    @patch('module.Database')
    def test_service_calls_db(self, mock_db):
        service = Service(mock_db)
        service.do_something()
        
        mock_db.execute.assert_called_once_with("SELECT * FROM users")

八、打包与分发

8.1 现代打包配置

# pyproject.toml 示例
"""
[build-system]
requires = ["setuptools>=61.0", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "my-package"
version = "1.0.0"
authors = [
    {name = "Your Name", email = "your.email@example.com"}
]
description = "An amazing Python package"
readme = "README.md"
requires-python = ">=3.8"
classifiers = [
    "Programming Language :: Python :: 3",
    "License :: OSI Approved :: MIT License",
    "Operating System :: OS Independent",
]

[project.optional-dependencies]
dev = ["pytest>=6.0", "black", "flake8"]
all = ["numpy", "pandas", "requests"]

[project.urls]
Homepage = "https://github.com/username/my-package"
Bug-Tracker = "https://github.com/username/my-package/issues"

[tool.black]
line-length = 88
target-version = ['py38']
"""

九、性能调优最佳实践

1. 选择合适的算法和数据结构
2. 使用内置函数和库函数
3. 避免不必要的对象创建
4. 合理使用缓存和记忆化
5. 优化I/O操作（使用缓冲、异步）
6. 使用C扩展或Cython优化关键代码
7. 使用生成器代替列表处理大数据
8. 使用local变量加速访问

十、持续学习资源

1. 书籍推荐：

   • 《Fluent Python》
   • 《Python Cookbook》
   • 《Effective Python》

2. 进阶主题：

   • CPython 源码分析
   • Python 字节码解析
   • GIL 工作机制
   • 垃圾回收机制

3. 实战项目：

   • 实现一个简单的 Web 框架
   • 开发一个异步爬虫引擎
   • 创建一个ORM库
   • 实现一个RPC框架

通过掌握这些进阶技能，你将能够编写更高效、更优雅、更可维护的 Python 代码，真正从 Python 使用者成长为 Python 专家。