当前位置：首页 > news >正文

python中函数的用法总结（二阶段）

news 来源：原创 2025/5/13 12:36:57

话接上回，继续讲下函数的用法

10. 函数的注解（Function Annotations）

Python 3 引入了函数注解，允许你在函数定义时给参数和返回值添加注解。注解并不影响函数的实际行为，它们更多地用于代码的可读性、文档生成以及静态分析工具。

示例：函数参数和返回值注解

def add(x: int, y: int) -> int:return x + yprint(add(3, 4))  # 输出 7

在这个示例中，x: int 和 y: int 表示参数 x 和 y 预期是整数类型，-> int 表示该函数的返回值预期是一个整数类型。

注解也可以使用其他数据类型，如 str、float、List、Dict 等。你可以使用 typing 模块中的类型提示进行更复杂的注解。

示例：更复杂的注解

from typing import List, Dictdef process_data(data: List[int]) -> Dict[str, int]:return {"sum": sum(data), "count": len(data)}result = process_data([1, 2, 3, 4])
print(result)  # 输出 {'sum': 10, 'count': 4}

11. 函数与闭包（Closures）

闭包是指一个函数在其定义时捕获了外部作用域中的变量。闭包使得一个函数可以“记住”并访问其外部函数的变量，即使外部函数已经返回。

示例：闭包

def outer(x):def inner(y):return x + yreturn innerclosure = outer(10)  # 闭包，x 被“记住”
print(closure(5))  # 输出 15

在这个例子中，inner 函数是一个闭包，因为它使用了 outer 函数的参数 x，即使 outer 已经返回，inner 仍然可以访问 x。

12. Python 的内置函数

Python 提供了大量的内置函数，可以简化很多常见操作。以下是一些常见的内置函数：

len()：返回对象（如字符串、列表、字典等）的长度。
max()、min()：返回序列中的最大值和最小值。
sum()：返回序列中所有元素的和。
sorted()：返回一个排序后的序列副本。
all()：如果所有元素都为真，返回 True，否则返回 False。
any()：如果任何一个元素为真，返回 True，否则返回 False。
zip()：将多个可迭代对象打包成一个元组。
map()：将指定函数应用于可迭代对象的每个元素。
filter()：过滤掉不符合条件的元素。

示例：内置函数 `map()` 和 `filter()`

numbers = [1, 2, 3, 4, 5]# 使用 map() 将每个数字乘以 2
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # 输出 [2, 4, 6, 8, 10]# 使用 filter() 过滤出偶数
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # 输出 [2, 4]

13. 函数的调用栈和递归深度

在 Python 中，函数的调用是通过“调用栈”（Call Stack）来管理的。每次调用一个函数时，Python 会将该函数的执行信息压入栈中，直到该函数执行完成并返回结果时，栈中的信息才会被移除。

对于递归函数，如果递归调用的深度过大，可能会导致栈溢出（RecursionError）。你可以通过设置 sys.setrecursionlimit() 来调整递归的最大深度（但不推荐用于生产环境，因为这可能会影响程序的稳定性）。

示例：递归深度限制

import sys
sys.setrecursionlimit(2000)  # 设置递归深度为 2000def factorial(n):if n == 0:return 1return n * factorial(n - 1)print(factorial(1000))  # 输出 1000 的阶乘

14. 函数的性能优化

在 Python 中，函数的性能优化非常重要，尤其是在处理大量数据或复杂计算时。以下是一些常见的优化方法：

1. 避免重复计算

在函数中，尽量避免对同一表达式或计算结果进行多次计算。可以使用变量来保存中间结果，减少重复计算的开销。

# 性能差：重复计算
def calculate(a, b):return (a + b) * (a + b)# 优化：保存中间结果
def optimized_calculate(a, b):sum_ab = a + breturn sum_ab * sum_ab

2. 使用内置函数和库

Python 内置函数通常是用 C 语言实现的，性能上比 Python 自定义的代码更高效。例如，在处理列表时，使用内置的 sum()、min()、max() 等函数通常比用 for 循环实现要快。

# 性能差：手动计算和比较
def manual_sum(numbers):total = 0for num in numbers:total += numreturn total# 优化：使用内置函数
def optimized_sum(numbers):return sum(numbers)

3. 使用生成器而非列表

如果不需要一次性加载所有数据，使用生成器而不是列表可以节省大量内存并提高性能，尤其是在处理大数据时。

# 性能差：使用列表
def get_squared_numbers(numbers):return [x ** 2 for x in numbers]# 优化：使用生成器
def get_squared_numbers_generator(numbers):for x in numbers:yield x ** 2

生成器按需计算每个值，而不是一次性将所有值放入内存。

4. 避免过度的函数调用

在一些性能要求较高的代码中，函数调用的开销也可能影响性能。虽然 Python 中的函数调用开销较小，但在处理大量数据时，过多的函数调用会成为性能瓶颈。如果可能，尽量将代码逻辑集中在少数几个函数中。

5. 利用并行化和多线程

Python 中可以使用 concurrent.futures 或 threading 模块来实现多线程或并行计算，从而加速一些耗时的任务。

import concurrent.futuresdef square(x):return x ** 2numbers = [1, 2, 3, 4, 5]# 使用多线程加速计算
with concurrent.futures.ThreadPoolExecutor() as executor:results = list(executor.map(square, numbers))print(results)  # 输出 [1, 4, 9, 16, 25]

在 CPU 密集型任务中，使用 concurrent.futures.ProcessPoolExecutor 可以更好地利用多核 CPU。

15. 函数与异步编程（Async Programming）

Python 支持异步编程，可以通过 async def 和 await 关键字来定义异步函数。异步编程通常用于 I/O 密集型任务，比如网络请求、文件操作等，以提高程序的响应性和并发性。

示例：异步函数和事件循环

import asyncioasync def hello_world():print("Hello")await asyncio.sleep(1)  # 模拟异步I/O操作print("World")# 运行异步任务
asyncio.run(hello_world())

输出：

Hello
World

在这个例子中，asyncio.sleep(1) 是一个异步操作，await 关键字表示等待该异步操作完成。由于 Python 是单线程运行的，通过异步编程，我们可以在等待 I/O 操作时继续执行其他任务，从而提高效率。

示例：并发执行多个异步任务

import asyncioasync def fetch_data(n):print(f"Fetching data {n}")await asyncio.sleep(1)print(f"Data {n} fetched")return f"Result {n}"async def main():tasks = [fetch_data(i) for i in range(5)]results = await asyncio.gather(*tasks)print(results)# 运行多个异步任务
asyncio.run(main())