Python函数进阶：从基础到高阶实战技巧

1. Python函数进阶完全指南

在Python编程中，函数是最基础也是最重要的构建块之一。但很多开发者停留在简单的def和return使用上，实际上Python函数系统远比表面看起来要强大得多。我见过太多项目因为对函数特性的理解不足，导致代码重复、维护困难甚至性能问题。今天我们就来彻底拆解Python函数的进阶用法，这些知识来自我十年Python开发中积累的实战经验，特别是那些官方文档不会告诉你的"坑"和技巧。

2. 函数定义的高级特性

2.1 类型注解与函数签名

Python 3.5引入的类型提示(Type Hints)彻底改变了我们编写函数的方式。来看一个电商系统中的实际案例：

python复制from typing import List, Dict, Optional

def calculate_order_total(
    items: List[Dict[str, Union[int, float]]],
    discount: Optional[float] = None,
    tax_rate: float = 0.1
) -> float:
    """
    计算订单总金额
    :param items: 商品列表，每个商品是包含'price'和'quantity'的字典
    :param discount: 可选折扣率(0-1)
    :param tax_rate: 税率(默认0.1)
    :return: 含税总金额
    """
    subtotal = sum(item['price'] * item['quantity'] for item in items)
    if discount:
        subtotal *= (1 - discount)
    return subtotal * (1 + tax_rate)

注意：类型注解不会影响运行时行为，但可以被mypy等工具检查。我在大型项目中强制使用类型检查后，接口相关的bug减少了约40%。

2.2 灵活的参数处理

Python的函数参数系统可能是所有语言中最灵活的：

python复制# 参数解包实战案例
def connect_to_database(host, port, username, password, **kwargs):
    print(f"Connecting to {username}@{host}:{port}")
    # kwargs可以接收额外的连接参数如timeout, ssl等
    
# 调用方式
params = {
    'host': 'db.example.com',
    'port': 5432,
    'username': 'admin',
    'password': 'secret',
    'timeout': 30,
    'ssl': True
}
connect_to_database(**params)

我经常用这种模式来处理API请求参数，特别是在开发Django REST框架时，可以优雅地处理前端可能发送的各种可选参数。

3. 函数式编程技巧

3.1 Lambda与高阶函数

虽然lambda在Python中有所限制(只能是一个表达式)，但在数据处理中仍然非常有用：

python复制# 数据清洗管道示例
raw_data = [
    {'name': 'Alice', 'age': '25', 'score': '88.5'},
    {'name': 'Bob', 'age': '30', 'score': '92'},
    {'name': 'Charlie', 'age': None, 'score': '75.5'}
]

processed = list(map(
    lambda x: {
        'name': x['name'].strip(),
        'age': int(x['age']) if x['age'] else 0,
        'score': float(x['score'])
    },
    filter(lambda x: x['name'] and x['score'], raw_data)
))

实际经验：在PySpark等大数据处理框架中，这种函数式风格特别有用，但要注意Python的lambda性能不如列表推导式，在性能关键路径要谨慎使用。

3.2 闭包与装饰器实战

装饰器是Python最强大的特性之一，来看一个生产环境中的缓存装饰器实现：

python复制import time
from functools import wraps

def cache_result(ttl=300):
    """缓存装饰器，带过期时间"""
    def decorator(func):
        cache = {}
        
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 生成缓存键时要考虑所有参数
            cache_key = (args, frozenset(kwargs.items()))
            
            if cache_key in cache:
                result, timestamp = cache[cache_key]
                if time.time() - timestamp < ttl:
                    return result
            
            result = func(*args, **kwargs)
            cache[cache_key] = (result, time.time())
            return result
        
        return wrapper
    return decorator

# 使用示例
@cache_result(ttl=60)
def query_user_profile(user_id):
    """模拟数据库查询"""
    print(f"Querying database for user {user_id}...")
    time.sleep(1)  # 模拟IO延迟
    return {"user_id": user_id, "name": f"User{user_id}"}

这个装饰器在我的一个Web应用中减少了约70%的数据库查询。关键点：

1. 使用functools.wraps保留原函数元信息
2. 正确处理了位置参数和关键字参数
3. 实现了TTL过期机制

4. 生成器与协程

4.1 生成器的高级用法

生成器不仅能节省内存，还能创建复杂的数据处理管道：

python复制def parse_log_file(file_path):
    """解析大型日志文件的生成器"""
    with open(file_path, 'r') as f:
        for line in f:
            if line.startswith('ERROR'):
                yield process_error_line(line)
            elif line.startswith('WARN'):
                yield process_warn_line(line)

def filter_errors(gen, min_severity=3):
    """过滤低严重级别的错误"""
    for item in gen:
        if item.get('severity', 0) >= min_severity:
            yield item

def count_by_type(gen):
    """按类型统计错误"""
    counts = {}
    for item in gen:
        counts[item['type']] = counts.get(item['type'], 0) + 1
    return counts

# 构建处理管道
log_gen = parse_log_file('app.log')
filtered_gen = filter_errors(log_gen, min_severity=2)
result = count_by_type(filtered_gen)

这种处理方式在分析GB级别的日志文件时，内存占用可以控制在MB级别，而传统方法可能需要几十倍的内存。

4.2 协程与异步函数

Python 3.5+的async/await语法让协程编程变得简单：

python复制import aiohttp
import asyncio

async def fetch_url(session, url, retry=3):
    """带重试机制的异步请求"""
    for attempt in range(retry):
        try:
            async with session.get(url, timeout=10) as response:
                if response.status == 200:
                    return await response.text()
                await asyncio.sleep(2 ** attempt)  # 指数退避
        except (aiohttp.ClientError, asyncio.TimeoutError) as e:
            print(f"Attempt {attempt + 1} failed: {str(e)}")
            if attempt == retry - 1:
                raise
            await asyncio.sleep(2 ** attempt)
    return None

async def scrape_websites(urls):
    """并发抓取多个网站"""
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        return await asyncio.gather(*tasks, return_exceptions=True)

# 使用示例
urls = ['https://example.com', 'https://example.org', 'https://example.net']
results = asyncio.run(scrape_websites(urls))

在我的爬虫项目中，这种模式比同步版本快5-10倍。关键点：

1. 使用aiohttp代替requests
2. 实现了指数退避的重试机制
3. 使用asyncio.gather并发执行

5. 函数性能优化

5.1 避免常见性能陷阱

python复制# 不推荐的写法
def process_items(items):
    result = []
    for item in items:
        processed = expensive_operation(item)
        result.append(processed)
    return result

# 优化后的版本
def process_items(items):
    return [expensive_operation(item) for item in items]

看起来差别不大，但在我的性能测试中，列表推导式比显式循环快约20%。更大的性能提升来自减少不必要的函数调用和属性查找：

python复制# 优化前
class Processor:
    def process(self, data):
        results = []
        for item in data:
            results.append(self._transform(item))
        return results
    
    def _transform(self, item):
        return item * 2 + 10

# 优化后
class Processor:
    def process(self, data):
        transform = self._transform  # 本地缓存方法查找
        return [transform(item) for item in data]
    
    def _transform(self, item):
        return item * 2 + 10

这个简单的优化在我的一个数值计算项目中带来了15%的性能提升。

5.2 使用functools优化

python复制from functools import lru_cache, partial

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

# 使用partial创建专用函数
def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
cube = partial(power, exponent=3)

lru_cache特别适合递归函数和纯函数，在我的一个图形算法中，它把执行时间从分钟级降到了秒级。

6. 动态函数编程

6.1 运行时创建函数

python复制def create_validation_function(fields):
    """动态创建数据验证函数"""
    def validator(data):
        errors = {}
        for field in fields:
            if field['required'] and field['name'] not in data:
                errors[field['name']] = "This field is required"
            elif field['name'] in data:
                value = data[field['name']]
                if 'min_length' in field and len(value) < field['min_length']:
                    errors[field['name']] = f"Minimum length is {field['min_length']}"
                # 可以添加更多验证规则...
        return errors if errors else None
    
    return validator

# 使用示例
user_validator = create_validation_function([
    {'name': 'username', 'required': True, 'min_length': 3},
    {'name': 'email', 'required': True},
    {'name': 'age', 'required': False}
])

print(user_validator({'username': 'ab', 'email': 'test@example.com'}))
# 输出: {'username': 'Minimum length is 3'}

这种模式在Web表单验证中非常有用，可以根据配置文件动态生成验证逻辑。

6.2 函数元编程

python复制class ApiClient:
    def __getattr__(self, name):
        if name.startswith('get_'):
            resource = name[4:]
            
            def wrapper(**kwargs):
                return self._make_request('GET', resource, kwargs)
            
            return wrapper
        raise AttributeError(f"No such method: {name}")
    
    def _make_request(self, method, resource, params):
        print(f"Making {method} request to /{resource} with {params}")
        # 实际实现会发送HTTP请求...

# 使用示例
client = ApiClient()
client.get_users(active=True)  # 动态创建的方法
client.get_products(category='books')

这种技巧在编写API客户端库时特别有用，可以大大减少样板代码。

7. 函数调试与测试

7.1 高级调试技巧

python复制import inspect

def debug_function(func):
    """打印函数调用细节的装饰器"""
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        print(f"Positional args: {args}")
        print(f"Keyword args: {kwargs}")
        
        frame = inspect.currentframe()
        try:
            # 获取调用栈信息
            caller = frame.f_back
            print(f"Called from {caller.f_code.co_filename}:{caller.f_lineno}")
            
            result = func(*args, **kwargs)
            print(f"Returned: {result}")
            return result
        finally:
            del frame  # 避免循环引用
    
    return wrapper

这个装饰器在我调试复杂的调用链时非常有用，特别是当问题出现在生产环境但难以复现时。

7.2 函数测试策略

对于复杂的函数，我通常采用分层测试策略：

python复制import pytest

def test_function_contract():
    """测试函数接口契约"""
    with pytest.raises(TypeError):
        your_function(invalid_arg=True)

def test_function_logic():
    """测试核心逻辑"""
    assert your_function(normal_arg=42) == expected_result

def test_function_edge_cases():
    """测试边界条件"""
    assert your_function(empty_arg=[]) == edge_case_result

def test_function_performance(benchmark):
    """性能测试"""
    benchmark(your_function, large_input=big_data)

在实际项目中，我会为关键函数维护这四类测试，确保代码质量。

8. 函数设计模式

8.1 策略模式实现

python复制class PaymentProcessor:
    def __init__(self, strategy=None):
        self._strategies = {
            'credit_card': self._process_credit_card,
            'paypal': self._process_paypal,
            'bank_transfer': self._process_bank_transfer
        }
        self.strategy = strategy or 'credit_card'
    
    def process_payment(self, amount):
        return self._strategies[self.strategy](amount)
    
    def _process_credit_card(self, amount):
        print(f"Processing ${amount} via Credit Card")
        return True
    
    def _process_paypal(self, amount):
        print(f"Processing ${amount} via PayPal")
        return True
    
    def _process_bank_transfer(self, amount):
        print(f"Processing ${amount} via Bank Transfer")
        return True

# 使用示例
processor = PaymentProcessor(strategy='paypal')
processor.process_payment(100)

这种模式在我的电商项目中非常有用，可以灵活添加新的支付方式而不影响现有代码。

8.2 回调与事件驱动

python复制class EventSystem:
    def __init__(self):
        self._handlers = {}
    
    def register(self, event_name, handler):
        """注册事件处理函数"""
        if event_name not in self._handlers:
            self._handlers[event_name] = []
        self._handlers[event_name].append(handler)
    
    def trigger(self, event_name, *args, **kwargs):
        """触发事件"""
        for handler in self._handlers.get(event_name, []):
            try:
                handler(*args, **kwargs)
            except Exception as e:
                print(f"Error in handler for {event_name}: {str(e)}")

# 使用示例
def log_user_login(user):
    print(f"User {user} logged in")

def update_last_login(user):
    print(f"Updating last login time for {user}")

system = EventSystem()
system.register('user_login', log_user_login)
system.register('user_login', update_last_login)

system.trigger('user_login', 'alice')

这种事件驱动架构在我的Web应用中实现了很好的解耦，各个模块只需要关心自己感兴趣的事件。

9. 函数与类的交互

9.1 方法绑定机制

理解Python的方法绑定机制对编写高效代码很重要：

python复制class MyClass:
    def method(self, x):
        return x * 2

obj = MyClass()
print(obj.method(5))  # 正常调用: 10

# 方法实际上是部分绑定的函数
unbound_method = MyClass.method
print(unbound_method(obj, 5))  # 需要显式传递self: 10

# 也可以从实例获取绑定方法
bound_method = obj.method
print(bound_method(5))  # self已经绑定: 10

这种灵活性在实现某些设计模式时非常有用，比如在实现命令模式时，可以把方法作为回调传递。

9.2 描述符协议

函数本质上也是实现了__get__方法的描述符：

python复制class FunctionDescriptor:
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return lambda: f"Bound to {obj}"
    
    def __call__(self):
        return "Unbound call"

class MyClass:
    func = FunctionDescriptor()

obj = MyClass()
print(obj.func())  # 输出: Bound to <__main__.MyClass object at ...>
print(MyClass.func())  # 输出: Unbound call

理解这一点对实现高级装饰器和属性管理非常关键。

10. 函数与元类

10.1 使用元类控制函数行为

python复制class FunctionLoggerMeta(type):
    def __new__(cls, name, bases, namespace):
        for attr_name, attr_value in namespace.items():
            if callable(attr_value):
                namespace[attr_name] = cls.log_function(attr_value)
        return super().__new__(cls, name, bases, namespace)
    
    @staticmethod
    def log_function(func):
        def wrapper(*args, **kwargs):
            print(f"Calling {func.__name__} with {args}, {kwargs}")
            result = func(*args, **kwargs)
            print(f"{func.__name__} returned {result}")
            return result
        return wrapper

class MyClass(metaclass=FunctionLoggerMeta):
    def method1(self, x):
        return x * 2
    
    def method2(self, a, b):
        return a + b

# 使用示例
obj = MyClass()
obj.method1(5)  # 会自动打印调用和返回信息
obj.method2(3, 4)

这种技术在开发框架和库时特别有用，可以实现AOP(面向切面编程)风格的横切关注点。

10.2 动态方法注入

python复制def inject_method(name, func):
    def decorator(cls):
        setattr(cls, name, func)
        return cls
    return decorator

def new_method(self, x):
    return x ** 2

@inject_method('square', new_method)
class MyClass:
    pass

# 使用示例
obj = MyClass()
print(obj.square(5))  # 输出: 25

我在测试中经常用这种技术来动态修改类行为，而不用创建子类。

11. 函数与并发

11.1 多线程中的函数安全

python复制from threading import Lock

class Counter:
    def __init__(self):
        self._value = 0
        self._lock = Lock()
    
    def increment(self):
        with self._lock:
            self._value += 1
            return self._value
    
    def decrement(self):
        with self._lock:
            self._value -= 1
            return self._value

# 使用示例
counter = Counter()

def worker():
    for _ in range(100000):
        counter.increment()

threads = [threading.Thread(target=worker) for _ in range(10)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(counter._value)  # 应该是1000000

在我的经验中，忘记加锁是多线程程序中最常见的错误之一，特别是在处理共享状态时。

11.2 多进程中的函数使用

python复制from multiprocessing import Pool

def process_item(item):
    """CPU密集型任务"""
    return item ** 2

def parallel_processing(items, processes=4):
    with Pool(processes) as pool:
        results = pool.map(process_item, items)
    return results

# 使用示例
data = list(range(1000000))
results = parallel_processing(data)

对于CPU密集型任务，多进程比多线程更有效，因为Python有GIL限制。在我的一个数据处理项目中，这种模式把运行时间从小时级降到了分钟级。

12. 函数与C扩展

12.1 使用ctypes调用C函数

python复制import ctypes

# 加载C库
libc = ctypes.CDLL(None)  # 加载标准C库

# 调用C函数
libc.printf(b"Hello from C\n")

# 更复杂的例子：调用数学库
libm = ctypes.CDLL('libm.so.6')  # Linux
sin = libm.sin
sin.argtypes = [ctypes.c_double]
sin.restype = ctypes.c_double

print(sin(3.1415926 / 2))  # 应该接近1.0

这种技术在需要优化性能关键部分时非常有用，但要注意类型转换的开销。

12.2 使用Cython加速函数

python复制# cython_example.pyx
def compute_pi(int n_terms):
    cdef double pi = 0.0
    cdef int k
    for k in range(n_terms):
        pi += (-1)**k / (2*k + 1)
    return 4 * pi

编译后，这个函数可以比纯Python版本快50-100倍。在我的科学计算项目中，Cython是性能优化的首选工具。

13. 函数与JIT编译

13.1 使用Numba加速数值计算

python复制from numba import jit
import numpy as np

@jit(nopython=True)
def monte_carlo_pi(n_samples):
    inside = 0
    for _ in range(n_samples):
        x, y = np.random.random(), np.random.random()
        if x**2 + y**2 <= 1:
            inside += 1
    return 4 * inside / n_samples

# 使用示例
print(monte_carlo_pi(1000000))

Numba特别适合数值计算，在我的量化金融项目中，它经常能带来100倍以上的性能提升。

13.2 使用PyPy的JIT

虽然PyPy不需要修改代码就能加速Python执行，但有些编码模式能让它发挥更好：

python复制# 适合PyPy的编码风格
def process_data(data):
    result = 0
    for item in data:
        result += expensive_computation(item)
    return result

# 不适合PyPy的例子(使用太多Python特性)
def process_data_slow(data):
    return sum(map(expensive_computation, data))

在我的Web爬虫基准测试中，PyPy通常能提供3-5倍的性能提升。

14. 函数与网络编程

14.1 回调风格的网络编程

python复制import socket

def handle_connection(conn, addr):
    print(f"Connection from {addr}")
    with conn:
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data.upper())

def start_server(host='localhost', port=9999):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((host, port))
        s.listen()
        print(f"Listening on {host}:{port}")
        while True:
            conn, addr = s.accept()
            handle_connection(conn, addr)

# 使用线程池处理多个连接
from concurrent.futures import ThreadPoolExecutor

def threaded_server(host='localhost', port=9999, max_workers=10):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind((host, port))
        s.listen()
        print(f"Listening on {host}:{port}")
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            while True:
                conn, addr = s.accept()
                executor.submit(handle_connection, conn, addr)

这种模式在我的多个网络服务中表现良好，比异步IO更简单直观。

14.2 使用生成器实现协议解析

python复制def read_message(conn):
    """从连接中读取完整消息的生成器"""
    buffer = b''
    while True:
        data = conn.recv(1024)
        if not data:
            break
        buffer += data
        while b'\n' in buffer:
            message, buffer = buffer.split(b'\n', 1)
            yield message.decode('utf-8')

# 使用示例
def handle_client(conn):
    for message in read_message(conn):
        print(f"Received: {message}")
        # 处理消息...

这种生成器模式让协议处理代码更加清晰，我在自定义协议实现中经常使用。

15. 函数与数据库交互

15.1 使用高阶函数实现DAO模式

python复制import sqlite3
from contextlib import contextmanager

@contextmanager
def db_connection(db_path):
    conn = sqlite3.connect(db_path)
    try:
        yield conn
    finally:
        conn.close()

def with_db(db_path):
    """数据库操作装饰器"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            with db_connection(db_path) as conn:
                return func(conn, *args, **kwargs)
        return wrapper
    return decorator

@with_db('example.db')
def get_user(conn, user_id):
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM users WHERE id = ?', (user_id,))
    return cursor.fetchone()

@with_db('example.db')
def create_user(conn, username, email):
    cursor = conn.cursor()
    cursor.execute(
        'INSERT INTO users (username, email) VALUES (?, ?)',
        (username, email)
    )
    conn.commit()
    return cursor.lastrowid

这种模式在我的Web应用中确保了数据库连接的正确管理，减少了资源泄漏。

15.2 使用生成器实现流式查询

python复制def stream_query(conn, query, params=(), chunk_size=1000):
    """流式查询结果的生成器"""
    cursor = conn.cursor()
    cursor.execute(query, params)
    while True:
        rows = cursor.fetchmany(chunk_size)
        if not rows:
            break
        yield from rows

# 使用示例
with db_connection('large.db') as conn:
    for row in stream_query(conn, 'SELECT * FROM big_table'):
        process_row(row)  # 处理每一行，内存友好

在处理GB级别的数据库表时，这种方法可以保持内存使用稳定。

16. 函数与Web开发

16.1 中间件模式实现

python复制def logging_middleware(next_handler):
    def middleware(request):
        print(f"Received request: {request['path']}")
        response = next_handler(request)
        print(f"Returning response: {response['status']}")
        return response
    return middleware

def auth_middleware(next_handler):
    def middleware(request):
        if 'Authorization' not in request['headers']:
            return {'status': 401, 'body': 'Unauthorized'}
        return next_handler(request)
    return middleware

@logging_middleware
@auth_middleware
def handle_request(request):
    return {'status': 200, 'body': 'Hello, World!'}

# 使用示例
request = {
    'path': '/api/data',
    'headers': {'Authorization': 'Bearer token123'}
}
response = handle_request(request)

这种中间件链模式在Web框架中非常常见，提供了很好的灵活性和可组合性。

16.2 路由系统实现

python复制class Router:
    def __init__(self):
        self.routes = {}
    
    def route(self, path):
        def decorator(func):
            self.routes[path] = func
            return func
        return decorator
    
    def handle_request(self, path, *args, **kwargs):
        handler = self.routes.get(path)
        if handler:
            return handler(*args, **kwargs)
        raise ValueError(f"No route for {path}")

router = Router()

@router.route('/home')
def home():
    return "Welcome home!"

@router.route('/about')
def about():
    return "About us"

# 使用示例
print(router.handle_request('/home'))  # 输出: Welcome home!

这个简单的路由系统可以扩展成完整的Web框架，我在多个内部项目中使用了类似的实现。

17. 函数与GUI编程

17.1 事件回调管理

python复制import tkinter as tk

class App:
    def __init__(self):
        self.root = tk.Tk()
        self.button_clicks = 0
        
        self.label = tk.Label(self.root, text="Click the button!")
        self.label.pack()
        
        self.button = tk.Button(
            self.root,
            text="Click me",
            command=self.on_button_click
        )
        self.button.pack()
    
    def on_button_click(self):
        self.button_clicks += 1
        self.label.config(text=f"Clicked {self.button_clicks} times")
    
    def run(self):
        self.root.mainloop()

# 使用示例
app = App()
app.run()

在GUI编程中，函数作为事件回调是最常见的模式之一。我的经验是保持回调函数简短，将复杂逻辑移到其他方法中。

17.2 使用闭包创建动态UI

python复制def create_tab_controller(tab_names):
    """动态创建标签页控制器"""
    tabs = {}
    current_tab = None
    
    def select_tab(name):
        nonlocal current_tab
        if current_tab:
            tabs[current_tab].pack_forget()
        tabs[name].pack()
        current_tab = name
    
    root = tk.Tk()
    for name in tab_names:
        frame = tk.Frame(root)
        tk.Label(frame, text=f"This is {name} tab").pack()
        tabs[name] = frame
    
    button_frame = tk.Frame(root)
    button_frame.pack()
    for name in tab_names:
        tk.Button(
            button_frame,
            text=name,
            command=lambda n=name: select_tab(n)
        ).pack(side=tk.LEFT)
    
    select_tab(tab_names[0])
    return root

# 使用示例
app = create_tab_controller(['Home', 'Settings', 'Help'])
app.mainloop()

这种闭包模式在创建动态UI时非常有用，可以避免定义大量类似的回调函数。

18. 函数与测试开发

18.1 参数化测试函数

python复制import pytest

def add(a, b):
    return a + b

@pytest.mark.parametrize("a,b,expected", [
    (1, 2, 3),
    (0, 0, 0),
    (-1, 1, 0),
    (1.5, 2.5, 4.0)
])
def test_add(a, b, expected):
    assert add(a, b) == expected

参数化测试是我在测试驱动开发中最常用的技术之一，可以大大减少重复代码。

18.2 使用fixture管理测试资源

python复制import pytest
import tempfile
import os

@pytest.fixture
def temp_db():
    """创建临时数据库的fixture"""
    db_path = tempfile.mktemp()
    conn = sqlite3.connect(db_path)
    yield conn
    conn.close()
    os.unlink(db_path)

def test_db_operations(temp_db):
    cursor = temp_db.cursor()
    cursor.execute("CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)")
    cursor.execute("INSERT INTO test (name) VALUES ('test')")
    temp_db.commit()
    
    cursor.execute("SELECT * FROM test")
    assert cursor.fetchone() == (1, 'test')

fixture是pytest最强大的特性之一，我在测试中用它管理数据库连接、临时文件、模拟服务等各种资源。

19. 函数与科学计算

19.1 使用函数向量化

python复制import numpy as np

def slow_sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 向量化版本
fast_sigmoid = np.vectorize(slow_sigmoid)

# 更高效的实现
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 使用示例
x = np.linspace(-10, 10, 1000)
%timeit slow_sigmoid(x)  # 可能很慢
%timeit fast_sigmoid(x)  # 快一些
%timeit sigmoid(x)  # 最快

在我的机器学习项目中，正确的向量化操作经常能带来1000倍以上的性能提升。

19.2 使用函数实现数值积分

python复制def trapezoidal_rule(f, a, b, n=1000):
    """梯形法数值积分"""
    h = (b - a) / n
    x = np.linspace(a, b, n+1)
    y = f(x)
    return h * (0.5*y[0] + 0.5*y[-1] + np.sum(y[1:-1]))

# 使用示例
result = trapezoidal_rule(np.sin, 0, np.pi/2)
print(result)  # 应该接近1.0

这种高阶函数模式在科学计算中非常常见，可以轻松实现各种数值算法。

20. 函数与机器学习

20.1 自定义损失函数

python复制import tensorflow as tf

def focal_loss(y_true, y_pred, gamma=2.0, alpha=0.25):
    """Focal loss for class imbalance"""
    y_pred = tf.clip_by_value(y_pred, 1e-7, 1 - 1e-7)
    cross_entropy = -y_true * tf.math.log(y_pred)
    loss = alpha * tf.pow(1 - y_pred, gamma) * cross_entropy
    return tf.reduce_mean(loss)

# 使用示例
model.compile(optimizer='adam', loss=focal_loss)

在我的图像分类项目中，自定义损失函数经常能显著提升模型在特定任务上的表现。

20.2 使用函数实现数据增强

python复制def random_rotate(image, max_angle=30):
    """随机旋转图像"""
    angle = np.random.uniform(-max_angle, max_angle)
    return rotate(image, angle, reshape=False)

def random_flip(image):
    """随机翻转图像"""
    if np.random.rand() > 0.5:
        image = np.fliplr(image)
    return image

def augment_image(image):
    """应用一系列随机变换"""
    image = random_rotate(image)
    image = random_flip(image)
    return image

# 使用示例
dataset = dataset.map(augment_image)

这种函数式数据增强管道在我的计算机视觉项目中大大提高了模型的泛化能力。

21. 函数与性能分析

21.1 使用装饰器进行性能分析

python复制import time
from functools import wraps

def profile(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} took {end - start:.6f} seconds")
        return result
    return wrapper

@profile
def expensive_operation(n):
    return sum(i * i for i in range(n))

# 使用示例
expensive_operation(10**6)

这种简单的性能分析装饰器在我的优化工作中非常有用，帮助我快速定位性能瓶颈。

21.2 使用cProfile分析函数调用

python复制import cProfile

def recursive_fib(n):
    if n <= 1:
        return n
    return recursive_fib(n-1) + recursive_fib(n-2)

# 使用示例
profiler = cProfile.Profile()
profiler.enable()
recursive_fib(30)
profiler.disable()
profiler.print_stats(sort='time')

对于更复杂的性能分析，cProfile提供了详细的函数调用统计信息，是我优化Python代码的首选工具。

22. 函数与调试技巧

22.1 使用闭包实现调试跟踪

python复制def trace(func):
    """调试跟踪装饰器"""
    depth = 0
    
    def wrapper(*args, **kwargs):
        nonlocal depth
        indent = '  ' * depth
        print(f"{indent}--> {func.__name__