在Python中，函数是组织代码、实现特定功能的基本单元。通过定义和调用函数，可以提高代码的复用性和可维护性。以下是关于Python函数定义及其调用的详细说明：
- 定义函数：使用def关键字定义函数，后跟函数名和括号。括号内可包含参数，用于接收调用时传入的数据。函数体以冒号开始，并缩进。
def greet(name): """向指定的人打招呼""" print(f"Hello, {name}!")- 调用函数：定义函数后，通过函数名加括号来调用。括号内传入实际参数，与定义时的参数相对应。
greet("Alice") # 输出: Hello, Alice!- 参数传递：函数参数分为形参和实参。形参在定义时声明，实参在调用时传入。Python支持位置参数、关键字参数等多种传递方式。
def add(a, b): """返回两个数的和""" return a + bresult = add(3, 5) # 位置参数传递print(result) # 输出: 8result = add(b=2, a=4) # 关键字参数传递print(result) # 输出: 6- 返回值：使用return语句返回函数执行结果。若无返回值，函数默认返回None。
def multiply(x, y): """返回两个数的乘积""" return x * yproduct = multiply(4, 5)print(product) # 输出: 20- 局部变量与全局变量：函数内部定义的变量为局部变量，仅在函数内有效。函数外部定义的变量为全局变量，可在整个模块中访问。
global_var = "I am global"def show_vars(): local_var = "I am local" print(global_var) # 访问全局变量 print(local_var) # 访问局部变量show_vars()# print(local_var) # 报错: local_var未定义- 函数文档字符串：通过三引号在函数定义时添加文档字符串，用于说明函数功能、参数及返回值。
def calculate_area(length, width): """ 计算矩形面积 参数: length (float): 矩形的长度 width (float): 矩形的宽度 返回: float: 矩形的面积 """ return length * width- 默认参数值：定义函数时，可为参数指定默认值。调用时若未传入该参数，则使用默认值。
def power(base, exponent=2): """计算base的exponent次方，exponent默认为2""" return base exponentprint(power(3)) # 输出: 9 (使用默认exponent=2)print(power(3, 4)) # 输出: 81- 可变参数：使用*args接收任意数量的位置参数，kwargs接收任意数量的关键字参数。
def print_args(*args, kwargs): """打印所有传入的位置参数和关键字参数""" print("位置参数:", args) print("关键字参数:", kwargs)print_args(1, 2, 3, name="Alice", age=25)# 输出:# 位置参数: (1, 2, 3)# 关键字参数: {'name': 'Alice', 'age': 25}- Lambda函数：使用lambda关键字定义匿名函数，适用于简单操作。
square = lambda x: x 2print(square(5)) # 输出: 25- 函数作为参数传递：函数可像其他对象一样作为参数传递给另一个函数。
def apply_operation(x, y, operation): """对x和y应用指定的操作""" return operation(x, y)result = apply_operation(4, 5, lambda a, b: a + b)print(result) # 输出: 9- 闭包：内部函数引用外部函数的变量，即使外部函数已执行完毕，这些变量仍存在于内存中。
def outer_function(x): """外部函数""" def inner_function(y): """内部函数，引用外部函数的变量x""" return x + y return inner_functionclosure = outer_function(10)print(closure(5)) # 输出: 15- 装饰器：用于修改或增强函数功能，通过@符号应用于函数定义之上。
def my_decorator(func): """装饰器函数""" def wrapper(): print("函数执行前") func() print("函数执行后") return wrapper@my_decoratordef say_hello(): """被装饰的函数""" print("Hello!")say_hello()# 输出:# 函数执行前# Hello!# 函数执行后- 生成器函数：使用yield语句定义生成器函数，可逐个产生值，节省内存。
def count_up_to(max): """生成从1到max的整数""" count = 1 while count <= max: yield count count += 1counter = count_up_to(5)for number in counter: print(number)# 输出:# 1# 2# 3# 4# 5- 递归函数：函数直接或间接调用自身，需注意设置终止条件以避免无限递归。
def factorial(n): """计算n的阶乘""" if n == 1: return 1 else: return n * factorial(n - 1)print(factorial(5)) # 输出: 120- 函数属性：函数可拥有自定义属性，用于存储额外信息。
def my_function(): """带有属性的函数""" print("函数执行")my_function.description = "这是一个示例函数"print(my_function.description) # 输出: 这是一个示例函数- 函数注解：Python 3.0+支持为函数参数和返回值添加类型注解，提高代码可读性。
def greet(name: str) -> str: """向指定的人打招呼""" return f"Hello, {name}!"print(greet("Bob")) # 输出: Hello, Bob!- __name__属性：用于判断当前模块是主程序还是被导入的模块。
if __name__ == "__main__": # 仅当直接运行此脚本时执行 print("这是主程序")else: print("这是被导入的模块")- 模块导入：通过import语句导入其他模块中的函数，实现代码复用。
# 假设math_utils.py中定义了add函数from math_utils import addresult = add(7, 8)print(result) # 输出: 15- *和在导入中的应用：导入模块所有内容或特定函数时使用。
from math import * # 导入math模块所有内容from math import sqrt, pow # 导入特定函数from .submodule import function # 从当前包的子模块导入from ..sibling_package import module # 从上级包的同级包导入def heavy_computation(): """需要时才导入耗时模块""" import numpy as np # 使用numpy进行计算 return np.array([1, 2, 3])- 函数别名：为函数指定别名，简化调用或避免命名冲突。
from math import sqrt as square_rootprint(square_root(16)) # 输出: 4.0- 函数缓存：使用functools.lru_cache装饰器缓存函数结果，提高重复调用效率。
from functools import lru_cache@lru_cache(maxsize=32)def expensive_function(x): """耗时的计算函数""" # 模拟耗时操作 return x * xprint(expensive_function(4)) # 第一次计算print(expensive_function(4)) # 直接从缓存获取- 偏函数：使用functools.partial固定部分参数，生成新函数。
from functools import partialdef power(base, exponent): """计算base的exponent次方""" return base exponentsquare = partial(power, exponent=2)print(square(5)) # 输出: 25 (相当于power(5, 2))def curry(func): """函数柯里化装饰器""" def wrapped(*args, kwargs): if len(args) + len(kwargs) >= func.__code__.co_argcount: return func(*args, kwargs) return lambda *a, kw: wrapped(*(args + a), {kwargs, kw}) return wrapped@currydef add(a, b, c): """三个数相加""" return a + b + cprint(add(1)(2)(3)) # 输出: 6print(add(1, 2)(3)) # 输出: 6- 上下文管理器：通过实现__enter__和__exit__方法，使函数支持with语句。
class Timer: """计时器上下文管理器""" def __enter__(self): import time self.start_time = time.time() return self def __exit__(self, *args): import time self.end_time = time.time() print(f"耗时: {self.end_time - self.start_time:.4f}秒")def timed_function(): """被计时的函数""" import time time.sleep(1)with Timer(): timed_function()# 输出类似: 耗时: 1.0001秒- 函数式编程工具：Python提供map、filter、reduce等函数式编程工具。
numbers = [1, 2, 3, 4]squared = list(map(lambda x: x 2, numbers))print(squared) # 输出: [1, 4, 9, 16]even_numbers = list(filter(lambda x: x % 2 == 0, numbers))print(even_numbers) # 输出: [2, 4]from functools import reducesum_all = reduce(lambda x, y: x + y, numbers)print(sum_all) # 输出: 10- 类型提示：Python 3.5+支持更详细的类型提示，提高代码可维护性。
from typing import List, Tupledef process_items(items: List[str]) -> Tuple[int, int]: """处理字符串列表，返回统计结果""" count = len(items) total_length = sum(len(item) for item in items) return count, total_lengthprint(process_items(["apple", "banana", "cherry"]))# 输出: (3, 18)- 函数重载：Python本身不支持函数重载，但可通过可变参数或singledispatch实现类似功能。
from functools import singledispatch@singledispatchdef process_data(data): """默认数据处理""" print(f"处理默认类型: {type(data)}")@process_data.register(str)def _(data: str): """处理字符串""" print(f"处理字符串: {data.upper()}")@process_data.register(int)def _(data: int): """处理整数""" print(f"处理整数: {data * 2}")process_data("hello") # 输出: 处理字符串: HELLOprocess_data(10) # 输出: 处理整数: 20process_data([1, 2, 3]) # 输出: 处理默认类型: <class 'list'>- 函数内省：通过inspect模块获取函数详细信息。
import inspectdef example_function(a: int, b: str = "default") -> bool: """示例函数""" return True# 获取函数签名sig = inspect.signature(example_function)print(sig) # 输出: (a: int, b: str = 'default') -> bool# 获取参数信息for name, param in sig.parameters.items(): print(f"参数名: {name}, 类型: {param.annotation}, 默认值: {param.default}")- 函数性能分析：使用timeit模块测量函数执行时间。
import timeitdef slow_function(): """慢速函数""" return sum(range(10000))def fast_function(): """快速函数""" return 10000 * 9999 // 2# 测量执行时间slow_time = timeit.timeit(slow_function, number=1000)fast_time = timeit.timeit(fast_function, number=1000)print(f"慢速函数: {slow_time:.6f}秒")print(f"快速函数: {fast_time:.6f}秒")- 函数测试：使用unittest或pytest编写函数测试用例。
import unittestdef add(a, b): """加法函数""" return a + bclass TestAddFunction(unittest.TestCase): """测试加法函数""" def test_add_positive_numbers(self): self.assertEqual(add(3, 5), 8) def test_add_negative_numbers(self): self.assertEqual(add(-1, -1), -2) def test_add_mixed_numbers(self): self.assertEqual(add(-2, 3), 1)if __name__ == "__main__": unittest.main()- 函数文档生成：使用pydoc或Sphinx自动生成函数文档。
# 在命令行执行以下命令生成文档# python -m pydoc -w your_module- 函数国际化：使用gettext模块实现函数文档和消息的国际化。
import gettext# 设置翻译es = gettext.translation('messages', localedir='locales', languages=['es'])es.install()_ = es.gettextdef greet(name): """向指定的人打招呼""" print(_("Hello, %(name)s!") % {'name': name})greet("Carlos") # 如果有西班牙语翻译，会输出西班牙语问候- 函数安全：注意函数参数验证和异常处理，确保函数健壮性。
def divide(a, b): """除法函数，包含参数验证和异常处理""" if not isinstance(a, (int, float)) or not isinstance(b, (int, float)): raise TypeError("参数必须是数字") if b == 0: raise ValueError("除数不能为零") return a / btry: print(divide(10, 2)) print(divide("10", 2)) # 会引发TypeErrorexcept Exception as e: print(f"错误: {e}")- 函数并发执行：使用concurrent.futures实现函数的多线程/多进程执行。
from concurrent.futures import ThreadPoolExecutorimport timedef task(name, duration): """模拟耗时任务""" print(f"任务{name}开始") time.sleep(duration) print(f"任务{name}完成") return f"{name}结果"with ThreadPoolExecutor(max_workers=3) as executor: # 提交多个任务 futures = [executor.submit(task, f"任务{i}", i) for i in range(1, 4)] # 获取结果 for future in futures: print(future.result())- 函数序列化：使用pickle或cloudpickle序列化函数，用于分布式计算。
import pickledef multiply(x, y): """乘法函数""" return x * y# 序列化函数serialized = pickle.dumps(multiply)# 反序列化并调用deserialized = pickle.loads(serialized)print(deserialized(6, 7)) # 输出: 42- 函数版本控制：通过参数或环境变量实现函数行为的不同版本。
def process_data(data, version=1): """根据版本处理数据""" if version == 1: return [x * 2 for x in data] elif version == 2: return [x 2 for x in data] else: raise ValueError("不支持的版本")print(process_data([1, 2, 3], version=1)) # 输出: [2, 4, 6]print(process_data([1, 2, 3], version=2)) # 输出: [1, 4, 9]import timefrom functools import wrapsdef monitor(func): """监控函数执行时间和调用次数""" @wraps(func) def wrapper(*args, kwargs): wrapper.call_count += 1 start_time = time.perf_counter() result = func(*args, kwargs) end_time = time.perf_counter() wrapper.total_time += end_time - start_time print(f"{func.__name__} 执行时间: {end_time - start_time:.6f}秒") return result wrapper.call_count = 0 wrapper.total_time = 0 return wrapper@monitordef example_function(n): """示例函数""" time.sleep(n) return "完成"print(example_function(0.5))print(example_function(0.2))print(f"总调用次数: {example_function.call_count}")print(f"总执行时间: {example_function.total_time:.6f}秒")def original_function(): """原始函数""" return "原始实现"def new_implementation(): """新实现""" return "新实现"# 替换函数实现original_function.__code__ = new_implementation.__code__print(original_function()) # 输出: 新实现- 函数内存分析：使用memory_profiler分析函数内存使用情况。
# 需要先安装: pip install memory_profilerfrom memory_profiler import profile@profiledef memory_intensive_function(): """内存密集型函数""" data = [x for x in range(1000000)] return sum(data)memory_intensive_function()- 函数依赖管理：使用pipreqs或pipdeptree管理函数依赖。
# 生成项目依赖文件pipreqs /path/to/project# 查看依赖树pipdeptree# 使用FastAPI创建简单的函数服务from fastapi import FastAPIapp = FastAPI()@app.get("/add")def add_endpoint(a: int, b: int): """加法API端点""" return {"result": a + b}# 运行: uvicorn main:app --reload# 需要先安装: pip install numbafrom numba import jitimport numpy as np@jit(nopython=True)def numba_optimized_function(arr): """使用numba优化的函数""" result = 0.0 for item in arr: result += np.sqrt(item) return resultarr = np.arange(1000000)print(numba_optimized_function(arr))- 函数可视化：使用pycallgraph生成函数调用关系图。
# 需要先安装: pip install pycallgraphfrom pycallgraph import PyCallGraphfrom pycallgraph.output import GraphvizOutputdef func_a(): """函数A""" print("A")def func_b(): """函数B""" print("B") func_a()with PyCallGraph(output=GraphvizOutput()): func_b()import pdbdef problematic_function(x): """有问题需要调试的函数""" result = x * 2 pdb.set_trace() # 设置断点 return result / 0 # 故意制造错误problematic_function(5)- 函数日志记录：使用logging模块记录函数执行日志。
import logginglogging.basicConfig(level=logging.INFO)logger = logging.getLogger(__name__)def process_data(data): """处理数据的函数""" logger.info(f"开始处理数据，长度: {len(data)}") try: result = [x * 2 for x in data] logger.info("数据处理成功") return result except Exception as e: logger.error(f"数据处理失败: {e}") raiseprocess_data([1, 2, 3])- 函数配置管理：使用配置文件或环境变量管理函数行为。
import osfrom configparser import ConfigParserconfig = ConfigParser()config.read('config.ini')def get_config_value(section, option, default=None): """从配置文件或环境变量获取值""" try: return config.get(section, option) except: return os.getenv(f"{section.upper()}_{option.upper()}", default)# 配置文件示例 (config.ini)# [settings]# timeout = 30print(get_config_value('settings', 'timeout', 10))- 函数国际化字符串提取：使用babel提取函数中的可翻译字符串。
# 需要先安装: pip install Babelfrom babel.messages.extract import extract_from_dir# 提取项目中的可翻译字符串# python -m babel extract -F babel.cfg -o messages.pot .- 函数安全审计：使用bandit等工具审计函数安全性。
# 安装: pip install bandit# 运行审计: bandit -r your_module.py- 函数性能基准测试：使用pytest-benchmark进行基准测试。
# 需要安装: pip install pytest-benchmarkdef test_function_performance(benchmark): """测试函数性能""" result = benchmark(lambda: sum(range(10000))) assert result == 49995000def calculate_statistics(data: list) -> dict: """ 计算数据集的基本统计信息 参数: data (list): 包含数字的列表。如果为空列表，返回所有统计值为None。 返回: dict: 包含以下统计信息的字典: - count: 数据点数量 - mean: 平均值 - median: 中位数 - min: 最小值 - max: 最大值 - std: 标准差 (如果count < 2，则为None) 异常: TypeError: 如果输入不是列表或包含非数字元素 示例: >>> calculate_statistics([1, 2, 3, 4, 5]) {'count': 5, 'mean': 3.0, 'median': 3, 'min': 1, 'max': 5, 'std': 1.5811388300841898} """ if not isinstance(data, list): raise TypeError("输入必须是列表") if not data: return { 'count': 0, 'mean': None, 'median': None, 'min': None, 'max': None, 'std': None } try: sorted_data = sorted(data) count = len(sorted_data) mean = sum(sorted_data) / count median = sorted_data[count // 2] if count % 2 else (sorted_data[count // 2 - 1] + sorted_data[count // 2]) / 2 min_val = sorted_data[0] max_val = sorted_data[-1] if count < 2: std = None else: variance = sum((x - mean) 2 for x in sorted_data) / (count - 1) std = variance 0.5 return { 'count': count, 'mean': mean, 'median': median, 'min': min_val, 'max': max_val, 'std': std } except TypeError: raise TypeError("列表必须只包含数字")- 函数最佳实践总结：
函数应保持单一职责，只做一件事
函数名应清晰表达其功能
参数数量不宜过多（一般不超过5-7个）
合理使用默认参数简化调用
编写完整的文档字符串
添加适当的类型提示
处理可能的异常情况
编写单元测试确保函数正确性
考虑性能敏感函数的优化
保持函数相对独立，减少副作用
通过合理使用这些函数定义和调用的技术，可以编写出更高效、更易维护的Python代码。函数是Python编程的核心概念之一，熟练掌握其各种用法对提升编程能力至关重要。
