1. Python函数基础：从入门到精通
Python作为一门优雅而强大的编程语言，其函数机制是其核心特性之一。函数不仅是代码复用的基本单元，更是构建复杂程序的基石。让我们从最基础的部分开始，逐步深入理解Python函数的方方面面。
1.1 函数定义与调用基础
在Python中，函数定义使用def关键字，后跟函数名和圆括号内的参数列表。函数体以冒号开始，并且需要缩进。下面是一个最简单的函数示例：
python复制def greet(name):
"""打招呼函数"""
print(f"Hello, {name}!")
这个函数名为greet，接受一个参数name。函数体内使用f-string格式化输出问候语。调用这个函数非常简单：
python复制greet("Alice") # 输出: Hello, Alice!
注意：Python函数命名应遵循小写字母加下划线的命名规范（snake_case），这与变量命名规则一致。
1.2 函数参数详解
Python函数的参数系统非常灵活，支持多种参数传递方式：
1.2.1 位置参数
最基本的参数传递方式，按照定义时的顺序传递：
python复制def power(base, exponent):
return base ** exponent
result = power(2, 3) # 8
1.2.2 默认参数
可以为参数指定默认值，调用时可省略：
python复制def greet(name, greeting="Hello"):
return f"{greeting}, {name}!"
print(greet("Alice")) # Hello, Alice!
print(greet("Bob", "Hi")) # Hi, Bob!
重要规则：默认参数必须放在非默认参数之后，否则会引发语法错误。
1.2.3 关键字参数
调用时通过参数名指定值，顺序可以任意：
python复制def create_user(name, age, city):
return {"name": name, "age": age, "city": city}
user = create_user(city="Beijing", name="Alice", age=25)
1.2.4 可变参数
使用*args接收任意数量的位置参数：
python复制def sum_all(*args):
return sum(args)
print(sum_all(1, 2, 3)) # 6
print(sum_all(1, 2, 3, 4, 5)) # 15
使用**kwargs接收任意数量的关键字参数：
python复制def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
print_info(name="Alice", age=25, city="Shanghai")
1.3 函数返回值
Python函数可以返回任意类型的值，包括多个值（实际上是返回元组）：
python复制def divide(a, b):
quotient = a // b
remainder = a % b
return quotient, remainder
q, r = divide(10, 3) # q=3, r=1
如果函数没有return语句，或者return后面没有值，则返回None：
python复制def say_hello():
print("Hello!")
result = say_hello() # 输出: Hello!
print(result) # None
2. 函数进阶特性
2.1 变量作用域与LEGB规则
Python中有四种作用域，查找顺序遵循LEGB规则：
- Local（局部） - 当前函数内部
- Enclosing（嵌套） - 外层函数
- Global（全局） - 模块级别
- Built-in（内置） - Python内置名称
python复制x = "global" # 全局变量
def outer():
x = "outer" # 嵌套作用域
def inner():
x = "inner" # 局部变量
print(x) # inner
inner()
print(x) # outer
outer()
print(x) # global
2.2 匿名函数(lambda)
lambda用于创建简单的匿名函数：
python复制square = lambda x: x ** 2
print(square(5)) # 25
# 常用于高阶函数
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))
限制：lambda只能包含单个表达式，不能包含语句或复杂的逻辑。
2.3 高阶函数
函数可以作为参数传递或作为返回值：
python复制# 函数作为参数
def apply_operation(func, x, y):
return func(x, y)
def add(a, b):
return a + b
result = apply_operation(add, 3, 4) # 7
# 函数作为返回值
def make_multiplier(factor):
def multiplier(x):
return x * factor
return multiplier
double = make_multiplier(2)
print(double(5)) # 10
3. 装饰器：Python的强大工具
3.1 装饰器基础
装饰器是修改函数行为的工具，遵循开放-封闭原则：
python复制def timer(func):
import time
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f"{func.__name__} 执行时间: {end - start:.4f}秒")
return result
return wrapper
@timer
def slow_function():
time.sleep(1)
slow_function() # 会打印执行时间
3.2 带参数的装饰器
装饰器本身也可以接受参数：
python复制def repeat(times):
def decorator(func):
def wrapper(*args, **kwargs):
for _ in range(times):
result = func(*args, **kwargs)
return result
return wrapper
return decorator
@repeat(3)
def say_hello():
print("Hello!")
say_hello() # 打印三次 Hello!
3.3 类装饰器
类也可以作为装饰器使用：
python复制class CountCalls:
def __init__(self, func):
self.func = func
self.count = 0
def __call__(self, *args, **kwargs):
self.count += 1
print(f"{self.func.__name__} 被调用了 {self.count} 次")
return self.func(*args, **kwargs)
@CountCalls
def greet(name):
print(f"Hello, {name}!")
greet("Alice") # 被调用了 1 次
greet("Bob") # 被调用了 2 次
4. 类型注解与静态检查
4.1 基本类型注解
Python 3.5+支持类型注解：
python复制def greet(name: str, age: int) -> str:
return f"Hello, {name}! You are {age} years old."
result: str = greet("Bob", 30)
4.2 复杂类型注解
使用typing模块处理复杂类型：
python复制from typing import List, Dict, Optional
def process_data(data: List[Dict[str, Any]]) -> Optional[List[Dict]]:
"""处理数据列表"""
if not data:
return None
return [item for item in data if item.get('valid')]
4.3 使用mypy进行类型检查
安装mypy：
bash复制pip install mypy
检查代码：
bash复制mypy your_script.py
5. 函数最佳实践
5.1 文档字符串
良好的文档字符串应包括：
python复制def calculate_area(length: float, width: float) -> float:
"""
计算矩形面积
Args:
length: 长度，单位米
width: 宽度，单位米
Returns:
面积，单位平方米
Raises:
ValueError: 如果长度或宽度为负
Example:
>>> calculate_area(3, 4)
12.0
"""
if length < 0 or width < 0:
raise ValueError("长度和宽度必须为正数")
return length * width
5.2 单一职责原则
每个函数应该只做一件事：
python复制# 不好的做法
def process_user_data(data):
# 验证数据
# 清洗数据
# 保存数据
# 发送通知
pass
# 好的做法
def validate_user_data(data):
pass
def clean_user_data(data):
pass
def save_user_data(data):
pass
def notify_admin(user):
pass
5.3 错误处理
合理使用异常处理：
python复制def divide(a: float, b: float) -> float:
try:
return a / b
except ZeroDivisionError:
print("除数不能为零")
return float('nan')
except TypeError:
print("参数类型错误")
raise
6. 常见问题与解决方案
6.1 默认参数陷阱
默认参数在函数定义时求值，可能导致意外行为：
python复制# 错误示例
def append_to(element, lst=[]):
lst.append(element)
return lst
print(append_to(1)) # [1]
print(append_to(2)) # [1, 2] 不是预期的[2]
# 正确做法
def append_to(element, lst=None):
if lst is None:
lst = []
lst.append(element)
return lst
6.2 变量作用域混淆
避免意外修改全局变量：
python复制count = 0
def increment():
global count # 必须声明global
count += 1
increment()
print(count) # 1
6.3 装饰器保留元数据
使用functools.wraps保留原函数信息：
python复制from functools import wraps
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
"""包装函数文档"""
return func(*args, **kwargs)
return wrapper
@decorator
def original():
"""原始函数文档"""
pass
print(original.__name__) # original
print(original.__doc__) # 原始函数文档
7. 实际应用案例
7.1 缓存装饰器实现
python复制from functools import wraps
def cache(func):
cached_results = {}
@wraps(func)
def wrapper(*args):
if args in cached_results:
print(f"使用缓存结果: {args}")
return cached_results[args]
result = func(*args)
cached_results[args] = result
return result
return wrapper
@cache
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(10)) # 55
7.2 API请求重试机制
python复制import requests
from time import sleep
from functools import wraps
def retry(max_retries=3, delay=1):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
for attempt in range(max_retries):
try:
return func(*args, **kwargs)
except requests.RequestException as e:
if attempt == max_retries - 1:
raise
print(f"请求失败 ({e})，{delay}秒后重试...")
sleep(delay)
return wrapper
return decorator
@retry(max_retries=5, delay=2)
def fetch_data(url):
response = requests.get(url, timeout=5)
response.raise_for_status()
return response.json()
7.3 权限验证装饰器
python复制def requires_permission(permission):
def decorator(func):
@wraps(func)
def wrapper(user, *args, **kwargs):
if permission not in user.get('permissions', []):
raise PermissionError(f"需要 {permission} 权限")
return func(user, *args, **kwargs)
return wrapper
return decorator
@requires_permission('admin')
def delete_user(user, target_user):
print(f"删除用户: {target_user}")
admin_user = {'name': 'admin', 'permissions': ['admin', 'user']}
delete_user(admin_user, 'test_user')
8. 性能优化技巧
8.1 使用lru_cache缓存结果
python复制from functools import lru_cache
@lru_cache(maxsize=128)
def expensive_calculation(n):
print(f"计算 {n}...")
return n * n # 假设这是耗时计算
print(expensive_calculation(5)) # 计算 5... 25
print(expensive_calculation(5)) # 直接返回25，不重新计算
8.2 避免不必要的函数调用
python复制# 不好的做法
def process_data(data):
for item in data:
result = expensive_function(item)
# ...
# 好的做法
def process_data(data):
processed = [expensive_function(item) for item in data]
# ...
8.3 使用生成器处理大数据
python复制def read_large_file(file_path):
with open(file_path, 'r') as f:
for line in f:
yield line.strip()
# 逐行处理，不占用大量内存
for line in read_large_file('huge_file.txt'):
process_line(line)
9. 调试与测试技巧
9.1 使用pdb调试
python复制import pdb
def complex_function(a, b):
pdb.set_trace() # 设置断点
result = a * b
return result
complex_function(3, 4)
9.2 单元测试示例
python复制import unittest
def add(a, b):
return a + b
class TestAddFunction(unittest.TestCase):
def test_add_integers(self):
self.assertEqual(add(1, 2), 3)
def test_add_floats(self):
self.assertAlmostEqual(add(1.1, 2.2), 3.3, places=1)
def test_add_strings(self):
self.assertEqual(add('a', 'b'), 'ab')
if __name__ == '__main__':
unittest.main()
9.3 使用装饰器记录执行日志
python复制def log_execution(func):
@wraps(func)
def wrapper(*args, **kwargs):
print(f"开始执行 {func.__name__}，参数: {args}, {kwargs}")
try:
result = func(*args, **kwargs)
print(f"{func.__name__} 执行成功，结果: {result}")
return result
except Exception as e:
print(f"{func.__name__} 执行失败: {str(e)}")
raise
return wrapper
@log_execution
def risky_operation(x, y):
return x / y
risky_operation(10, 2)
10. Python函数式编程
10.1 map/filter/reduce
python复制from functools import reduce
numbers = [1, 2, 3, 4, 5]
# map: 对每个元素应用函数
squared = list(map(lambda x: x**2, numbers))
# filter: 过滤元素
evens = list(filter(lambda x: x % 2 == 0, numbers))
# reduce: 累积计算
total = reduce(lambda x, y: x + y, numbers)
10.2 偏函数(partial)
python复制from functools import partial
def power(base, exponent):
return base ** exponent
square = partial(power, exponent=2)
cube = partial(power, exponent=3)
print(square(5)) # 25
print(cube(3)) # 27
10.3 闭包应用
python复制def make_counter(start=0):
count = start
def counter():
nonlocal count
count += 1
return count
return counter
c1 = make_counter()
print(c1()) # 1
print(c1()) # 2
c2 = make_counter(10)
print(c2()) # 11
11. 函数设计模式
11.1 策略模式
python复制def strategy_add(a, b):
return a + b
def strategy_multiply(a, b):
return a * b
class Calculator:
def __init__(self, strategy=strategy_add):
self.strategy = strategy
def calculate(self, a, b):
return self.strategy(a, b)
calc = Calculator()
print(calc.calculate(3, 4)) # 7
calc.strategy = strategy_multiply
print(calc.calculate(3, 4)) # 12
11.2 工厂模式
python复制def create_animal(animal_type):
def create_dog(name):
return {"type": "dog", "name": name, "sound": "woof"}
def create_cat(name):
return {"type": "cat", "name": name, "sound": "meow"}
factories = {
"dog": create_dog,
"cat": create_cat
}
return factories[animal_type]
dog_factory = create_animal("dog")
my_dog = dog_factory("Buddy")
print(my_dog) # {'type': 'dog', 'name': 'Buddy', 'sound': 'woof'}
11.3 观察者模式
python复制class EventManager:
def __init__(self):
self._subscribers = []
def subscribe(self, func):
self._subscribers.append(func)
def unsubscribe(self, func):
self._subscribers.remove(func)
def notify(self, *args, **kwargs):
for subscriber in self._subscribers:
subscriber(*args, **kwargs)
def logger(message):
print(f"日志: {message}")
def alert(message):
print(f"警报: {message}")
event_manager = EventManager()
event_manager.subscribe(logger)
event_manager.subscribe(alert)
event_manager.notify("系统启动")
12. 异步函数(asyncio)
12.1 基本异步函数
python复制import asyncio
async def fetch_data():
print("开始获取数据")
await asyncio.sleep(2) # 模拟IO操作
print("数据获取完成")
return {"data": 123}
async def main():
task = asyncio.create_task(fetch_data())
print("执行其他任务...")
data = await task
print(f"获取到的数据: {data}")
asyncio.run(main())
12.2 异步装饰器
python复制def async_timer(func):
async def wrapper(*args, **kwargs):
import time
start = time.time()
result = await func(*args, **kwargs)
end = time.time()
print(f"{func.__name__} 执行时间: {end - start:.4f}秒")
return result
return wrapper
@async_timer
async def slow_operation():
await asyncio.sleep(1)
return "完成"
asyncio.run(slow_operation())
12.3 并发执行多个任务
python复制async def task(name, delay):
print(f"任务 {name} 开始")
await asyncio.sleep(delay)
print(f"任务 {name} 完成")
return name
async def main():
results = await asyncio.gather(
task("A", 2),
task("B", 1),
task("C", 3)
)
print(f"所有任务完成: {results}")
asyncio.run(main())
13. 函数性能分析
13.1 使用timeit测量执行时间
python复制import timeit
def test_function():
return sum(range(1000000))
time = timeit.timeit(test_function, number=100)
print(f"平均执行时间: {time/100:.6f}秒")
13.2 使用cProfile分析性能
python复制import cProfile
def slow_function():
total = 0
for i in range(10000):
for j in range(10000):
total += i * j
return total
cProfile.run('slow_function()')
13.3 优化技巧
python复制# 不好的做法：频繁创建临时列表
def process_data(data):
results = []
for item in data:
results.append(expensive_operation(item))
return results
# 好的做法：使用生成器表达式
def process_data(data):
return list(expensive_operation(item) for item in data)
# 更好的做法：惰性求值
def process_data(data):
return (expensive_operation(item) for item in data)
14. 函数安全注意事项
14.1 输入验证
python复制def safe_divide(a: float, b: float) -> float:
if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
raise TypeError("参数必须是数字")
if b == 0:
raise ValueError("除数不能为零")
return a / b
14.2 防止代码注入
python复制import ast
def safe_eval(expression: str):
try:
return ast.literal_eval(expression)
except (ValueError, SyntaxError):
raise ValueError("非法表达式")
result = safe_eval("[1, 2, 3]") # 安全
# result = safe_eval("__import__('os').system('rm -rf /')") # 会被阻止
14.3 资源清理
python复制def process_file(file_path):
try:
with open(file_path, 'r') as f:
data = f.read()
# 处理数据
except IOError as e:
print(f"文件处理错误: {e}")
finally:
# 确保资源被清理
pass
15. 函数版本兼容性
15.1 Python 2/3兼容
python复制try:
# Python 3
from functools import lru_cache
except ImportError:
# Python 2 回退方案
def lru_cache(maxsize=128):
def decorator(func):
cache = {}
def wrapper(*args):
if args in cache:
return cache[args]
result = func(*args)
if len(cache) >= maxsize:
cache.popitem()
cache[args] = result
return result
return wrapper
return decorator
15.2 类型注解兼容
python复制try:
from typing import Literal
except ImportError:
# Python <3.8 的替代方案
from typing import Any
def Literal(*args) -> Any:
return Any
15.3 异步兼容
python复制import sys
if sys.version_info >= (3, 7):
from asyncio import run as async_run
else:
def async_run(coro):
loop = asyncio.get_event_loop()
return loop.run_until_complete(coro)
16. 函数调试技巧
16.1 打印调试信息
python复制def debug(func):
@wraps(func)
def wrapper(*args, **kwargs):
print(f"调用 {func.__name__}，参数: args={args}, kwargs={kwargs}")
result = func(*args, **kwargs)
print(f"{func.__name__} 返回: {result}")
return result
return wrapper
@debug
def add(a, b):
return a + b
add(3, 4)
16.2 使用inspect模块
python复制import inspect
def get_function_info(func):
print(f"函数名: {func.__name__}")
print(f"参数: {inspect.signature(func)}")
print(f"文档: {func.__doc__}")
print(f"定义文件: {inspect.getfile(func)}")
def example(a: int, b: float = 1.0) -> float:
"""示例函数"""
return a * b
get_function_info(example)
16.3 性能热点分析
python复制import cProfile
import pstats
from io import StringIO
def profile(func):
@wraps(func)
def wrapper(*args, **kwargs):
pr = cProfile.Profile()
pr.enable()
result = func(*args, **kwargs)
pr.disable()
s = StringIO()
ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
ps.print_stats()
print(s.getvalue())
return result
return wrapper
@profile
def slow_function():
total = 0
for i in range(10000):
for j in range(10000):
total += i * j
return total
slow_function()
17. 函数与面向对象编程
17.1 类方法装饰器
python复制class MyClass:
@classmethod
def class_method(cls):
print(f"调用类方法，类: {cls.__name__}")
@staticmethod
def static_method():
print("调用静态方法")
MyClass.class_method()
MyClass.static_method()
17.2 属性装饰器
python复制class Circle:
def __init__(self, radius):
self._radius = radius
@property
def radius(self):
return self._radius
@radius.setter
def radius(self, value):
if value < 0:
raise ValueError("半径不能为负")
self._radius = value
@property
def area(self):
return 3.14159 * self._radius ** 2
c = Circle(5)
print(c.area) # 78.53975
c.radius = 10
print(c.area) # 314.159
17.3 函数式与面向对象结合
python复制class Processor:
def __init__(self, data):
self.data = data
def apply(self, *funcs):
for func in funcs:
self.data = func(self.data)
return self.data
def double(x):
return x * 2
def square(x):
return x ** 2
p = Processor(5)
result = p.apply(double, square)
print(result) # (5*2)^2 = 100
18. 函数与元编程
18.1 动态创建函数
python复制def create_function(name, doc):
def new_function(*args, **kwargs):
print(f"执行 {name}，参数: {args}, {kwargs}")
return sum(args) + sum(kwargs.values())
new_function.__name__ = name
new_function.__doc__ = doc
return new_function
dynamic_func = create_function("dynamic_add", "动态创建的函数")
print(dynamic_func(1, 2, 3, x=4, y=5)) # 15
18.2 函数签名检查
python复制from inspect import signature
def validate_args(func, *args, **kwargs):
sig = signature(func)
bound_args = sig.bind(*args, **kwargs)
bound_args.apply_defaults()
return bound_args.arguments
def example(a, b=2, *, c=3):
pass
args = validate_args(example, 1, c=4)
print(args) # {'a': 1, 'b': 2, 'c': 4}
18.3 函数装饰器工厂
python复制def enforce_types(**type_hints):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
bound_args = signature(func).bind(*args, **kwargs).arguments
for name, value in bound_args.items():
if name in type_hints and not isinstance(value, type_hints[name]):
raise TypeError(f"{name} 必须是 {type_hints[name]} 类型")
return func(*args, **kwargs)
return wrapper
return decorator
@enforce_types(a=int, b=str)
def typed_function(a, b):
return f"{a} {b}"
print(typed_function(1, "hello")) # 正常
# typed_function("1", "hello") # 抛出 TypeError
19. 函数与并发编程
19.1 多线程函数
python复制import threading
def worker(num):
print(f"Worker {num} 开始")
# 执行任务
print(f"Worker {num} 结束")
threads = []
for i in range(5):
t = threading.Thread(target=worker, args=(i,))
threads.append(t)
t.start()
for t in threads:
t.join()
19.2 多进程函数
python复制import multiprocessing
def cpu_bound_task(n):
return sum(i * i for i in range(n))
if __name__ == '__main__':
with multiprocessing.Pool() as pool:
results = pool.map(cpu_bound_task, [10**6, 10**7, 10**8])
print(results)
19.3 协程函数
python复制import asyncio
async def fetch_url(url):
print(f"开始获取 {url}")
await asyncio.sleep(1) # 模拟网络请求
print(f"完成获取 {url}")
return f"{url} 的内容"
async def main():
urls = ["url1", "url2", "url3"]
tasks = [fetch_url(url) for url in urls]
results = await asyncio.gather(*tasks)
print(results)
asyncio.run(main())
20. 函数与数据结构
20.1 递归处理嵌套结构
python复制def flatten(nested_list):
"""展平嵌套列表"""
result = []
for item in nested_list:
if isinstance(item, list):
result.extend(flatten(item))
else:
result.append(item)
return result
nested = [1, [2, [3, 4], 5], 6]
print(flatten(nested)) # [1, 2, 3, 4, 5, 6]
20.2 高阶函数处理数据
python复制from functools import partial
def process_data(data, *, multiplier=1, filter_func=None):
if filter_func:
data = filter(filter_func, data)
return [x * multiplier for x in data]
numbers = [1, 2, 3, 4, 5, 6]
# 创建特定处理函数
double_evens = partial(process_data, multiplier=2, filter_func=lambda x: x % 2 == 0)
print(double_evens(numbers)) # [4, 8, 12]
20.3 生成器处理大数据流
python复制def read_large_dataset(file_path):
with open(file_path, 'r') as f:
for line in f:
yield line.strip()
def process_pipeline(data_gen):
for item in data_gen:
# 多个处理步骤
item = item.lower()
item = item.replace(",", "")
if len(item) > 5:
yield item
# 惰性处理大数据
data_gen = read_large_dataset("huge_file.txt")
processed_gen = process_pipeline(data_gen)
for item in processed_gen:
print(item)
21. 函数与算法实现
21.1 排序算法实现
python复制def quicksort(arr):
"""快速排序实现"""
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quicksort(left) + middle + quicksort(right)
print(quicksort([3,6,8,10,1,2,1])) # [1, 1, 2, 3, 6, 8, 10]
21.2 搜索算法实现
python复制def binary_search(arr, target):
"""二分查找实现"""
low, high = 0, len(arr) - 1
while low <= high:
mid = (low + high) // 2
if arr[mid] < target:
low = mid + 1
elif arr[mid] > target:
high = mid - 1
else:
return mid
return -1
sorted_arr = [1, 3, 5, 7, 9]
print(binary_search(sorted_arr, 5)) # 2
print(binary_search(sorted_arr, 6)) # -1
21.3 图算法实现
python复制from collections import deque
def bfs(graph, start):
"""广度优先搜索"""
visited = set()
queue = deque([start])
visited.add(start)
while queue:
vertex = queue.popleft()
print(vertex, end=" ")
for neighbor in graph[vertex]:
if neighbor not in visited:
visited.add(neighbor)
queue.append(neighbor)
graph = {
'A': ['B', 'C'],
'B': ['A', 'D', 'E'],
'C': ['A', 'F'],
'D': ['B'],
'E': ['B', 'F'],
'F': ['C', 'E']
}
bfs(graph, 'A') # A B C D E F
22. 函数与设计模式
22.1 装饰器模式
python复制def bold(func):
def wrapper():
return "<b>" + func() + "</b>"
return wrapper
def italic(func):
def wrapper():
return "<i>" + func() + "</i>"
return wrapper
@bold
@italic
def say_hello():
return "Hello"
print(say_hello()) # <b><i>Hello</i></b>
22.2 策略模式
python复制def strategy_add(a, b):
return a + b
def strategy_multiply(a, b):
return a * b
class Context:
def __init__(self, strategy=strategy_add):
self.strategy = strategy
def execute(self, a, b):
return self.strategy(a, b)
context = Context()
print(context.execute(3, 4)) # 7
context.strategy = strategy_multiply
print(context.execute(3, 4)) # 12
22.3 观察者模式
python复制class Event:
def __init__(self):
self._observers = []
def subscribe(self, observer):
self._observers.append(observer)
def notify(self, *args, **kwargs):
for observer in self._observers:
observer(*args, **kwargs)
def logger(message):
print(f"日志: {message}")
def alert(message):
print(f"警报: {message}")
event = Event()
event.subscribe(logger)
event.subscribe(alert)
event.notify("系统启动")
23. 函数与测试驱动开发
23.1 单元测试示例
python复制import