Python 性能优化：从入门到精通的实用指南

Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出剖析的完整指南
02-玩转 LangChain Memory 模块：四种记忆范例详解及应用场景全覆盖
03-全面把握 LangChain：从核心链条构建到动态任务分配的实战指南
04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 把握 LangChain Agents：自定义工具 + LLM 打造智能工作流！
python系列文章目录

01-Python 基础语法入门：从变量到输入输出，零基础也能学会！
02-Python 流程控制终极指南：if-else 和 for-while深度剖析
03-Python 列表与元组全攻略：从新手到高手的必备指南
04-Python 字典与集合：从入门到精通的全面剖析
05-Python函数入门指南：从定义到应用
06-Python 函数高级特性：从默认参数到闭包的全面剖析
07-Python 模块与包：从零到自定义的全面指南
08-Python非常处理：从入门到精通的实用指南
09-Python 文件操作：从零基础到日志纪录实战
10-Python面向对象编程入门：从类与对象到方法与属性
11-Python类的方法与属性：从入门到进阶的全面剖析
12-Python继续与多态：提升代码复用与灵活性的关键技术
13-把握Python魔法方法：如何用__add__和__len__自定义类的行为
14-python面向对象编程总结：从基础到进阶的 OOP 核心思想与筹划本领
15-把握 Python 高级特性：深入理解迭代器与生成器
16-用 Python 装饰器提升服从：日志与权限验证案例
17-再也不怕资源泄漏！Python 上下文管理器，with语句全攻略
18-Python 标准库必备模块：math、random、os、json 全剖析
19-Python 性能优化：从入门到精通的实用指南

---

  

---

前言

Hey，你有没有遇到过这样的环境：代码跑得太慢，CPU 风扇狂转，甚至内存直接爆满？在 Python 开发中，性能问题是个绕不外去的坎儿。无论是处理大数据、写爬虫，照旧开发 Web 应用，优化性能都能让你的程序更快、更省资源。这篇文章的目标很简朴：带你从零开始，搞懂影响 Python 性能的因素，学会几个超实用的优化本领，还要教你怎么用 timeit 模块测测代码到底有多快。不管你是刚入门的小白，照旧有点履历的开发者，这里都有干货等着你！
本文会聊三大块：

• 影响 Python 性能的“幕后黑手”：时间复杂度和空间复杂度。
  
• 优化代码的“锦囊奇策”：避免重复盘算、减少 IO 操作。
  
• 性能检测的“秘密武器”：timeit 模块。
  

准备好了吗？咱们这就开始！

---

一、影响 Python 性能的因素

性能优化得先知道问题出在哪儿，对吧？Python 固然简朴好用，但有些地方不留意就会拖慢速率。这部门咱们聊聊两个核心因素：时间复杂度和空间复杂度。
1.1 时间复杂度

时间复杂度听起来有点学术，着实就是“你的代码跑起来需要多久”。它跟数据量大小直接挂钩，数据越多，影响越显着。
1.1.1 为什么时间复杂度紧张？

简朴说，时间复杂度决定了一个算法的服从。比如你在列表里找个数，数据量小还好，可要是列表里有几百万条数据，服从低的算法能让你等到怀疑人生。

• 举个例子：用列表和集合找数字的区别。
  1. # 列表找数字，时间复杂度 O(n)
  2. my_list = [1, 2, 3, 4, 5]
  3. if 3 in my_list:  # 得一个个检查
  4.     print("找到啦！")
  6. # 集合找数字，时间复杂度 O(1)
  7. my_set = {1, 2, 3, 4, 5}
  8. if 3 in my_set:  # 直接定位，超快
  9.     print("找到啦！")

  复制代码
• 关键点：列表是线性查找，时间复杂度是 O(n)；集合用哈希表，均匀时间复杂度是 O(1)。数据量越大，差距越显着。
  

1.1.2 怎么优化时间复杂度？

• 建议：需要频仍查找时，用集合（set）或字典（dict）取代列表。
  
• 场景：比如去重、查重这种操作，集合简直是神器。
  

1.2 空间复杂度

时间跑得快还不敷，内存用得少也很紧张。空间复杂度就是“你的代码占了多少内存”。
1.2.1 空间复杂度为啥关键？

Python 自动管理内存，但用错了数据结构，内存照样吃紧。比如存一堆数字，用列表和生成器差别可不小。

• 举个例子：
  1. # 列表存一百万个数，全都加载到内存
  2. my_list = [i for i in range(1000000)]  # 内存占用大
  4. # 生成器，边用边生成，内存几乎不占
  5. my_gen = (i for i in range(1000000))  # 超省空间

  复制代码
• 关键点：列表把全部数据都存下来，空间复杂度 O(n)；生成器只存当前值，空间复杂度接近 O(1)。
  

1.2.2 怎么优化空间复杂度？

• 建议：大数据场景下，优先用生成器或迭代器。
  
• 场景：比如读取大文件、处理流数据，用生成器能省下不少内存。
  

---

二、Python 性能优化本领

知道了影响性能的因素，咱们得动手优化代码。这部门分享两个超实用的本领：避免重复盘算和减少 IO 操作。
2.1 避免重复盘算

重复盘算就像你炒菜时把同一个葱花切了十遍，太浪费时间！Python 里有些操作可以提前做好，省下不少力气。
2.1.1 利用缓存机制

缓存就是把算过的结果存起来，下次直接拿来用。Python 自带一个神器：functools.lru_cache。

• 代码示例：优化递归盘算斐波那契数列。
  1. from functools import lru_cache
  3. @lru_cache(maxsize=128)  # 缓存最多 128 个结果
  4. def fibonacci(n):
  5.     if n < 2:
  6.         return n
  7.     return fibonacci(n-1) + fibonacci(n-2)
  9. print(fibonacci(50))  # 超快！

  复制代码
• 关键点：没缓存时，递归会重复算很多多少次；加了缓存，直接查表，时间从“天文数字”变成“秒级”。
  
• 场景：递归函数、频仍调用的盘算任务。
  

2.1.2 预盘算和惰性盘算

• 预盘算：提前把结果算好，比如程序启动时把常用数据准备好。
  
• 惰性盘算：用到时再算，用生成器就是典型例子。
  1. def lazy_range(n):
  2.     i = 0
  3.     while i < n:
  4.         yield i  # 每次只生成一个数
  5.         i += 1
  7. for num in lazy_range(1000):  # 按需取值
  8.     print(num)

  复制代码
• 建议：不常用的数据用惰性盘算，常用的小数据用预盘算。
  

2.2 减少 IO 操作

IO 操作（比如读文件、发网络请求）特别慢，减少它的次数能让代码飞起来。
2.2.1 批量处理数据

别一行行读文件，一次性读完再处理服从更高。

• 代码示例：
  1. # 逐行读，IO 次数多
  2. def process(line):
  3.     print(line)
  5. with open('file.txt', 'r') as f:
  6.     for line in f:  # 每次都调用 IO
  7.         process(line)
  9. # 一次性读，IO 次数少
  10. with open('file.txt', 'r') as f:
  11.     content = f.read()  # 一次读完
  12.     lines = content.splitlines()
  13.     for line in lines:
  14.         process(line)

  复制代码
• 关键点：批量操作把多次 IO 变成一次，速率提升显着。
  
• 场景：读写大文件、数据库操作。
  

2.2.2 利用异步 IO

网络请求多的时候，等一个完再发下一个太慢，用异步 IO 可以同时处理。

• 代码示例：用 asyncio 抓网页。
  1. import asyncio
  2. import aiohttp
  4. async def fetch_url(url):
  5.     async with aiohttp.ClientSession() as session:
  6.         async with session.get(url) as response:
  7.             return await response.text()
  9. async def main():
  10.     urls = ['http://example.com', 'http://example.org']
  11.     tasks = [fetch_url(url) for url in urls]
  12.     results = await asyncio.gather(*tasks)
  13.     print(results[0][:100])  # 只打印前 100 个字符
  15. asyncio.run(main())

  复制代码
• 关键点：异步 IO 让多个请求并行，特别适合爬虫或高并发任务。
  
• 场景：网络密集型任务。
  

---

三、利用 timeit 模块丈量代码性能

优化完代码，怎么知道结果咋样？用 timeit 模块测一测就知道了！
3.1 timeit 模块简介

timeit 是 Python 自带的小工具，专门测小段代码的运行时间。它会重复跑代码取均匀值，结果很靠谱。
3.1.1 为什么用 timeit？

手动用 time.time() 测时间禁绝，由于系统负载会干扰。timeit 跑许多次，数据更稳固。
3.2 如何利用 timeit 丈量代码性能

3.2.1 下令行利用 timeit

直接在终端跑，适合快速测试。

• 示例：测列表推导式的速率。
  1. python -m timeit "sum([i for i in range(1000)])"

  复制代码
• 输出：类似“1000 loops, best of 5: 123 usec per loop”，表现均匀每次多久。
  
• 建议：调试小代码时用这个，简朴又快。
  

3.2.2 在代码中利用 timeit

想在脚本里测？也很简朴。

• 代码示例：
  1. import timeit
  3. def my_function():
  4.     return sum([i for i in range(1000)])
  6. # 跑 100 次，测总时间
  7. execution_time = timeit.timeit(my_function, number=100)
  8. print(f"总耗时: {execution_time} 秒")

  复制代码
• 关键点：number 是运行次数，自己调，别设太大跑不动。
  
• 场景：对比不同实现方案的性能。
  

---

四、总结

本文聊了 Python 性能优化的三大块：

• 影响因素：时间复杂度管速率，空间复杂度管内存，选对数据结构很关键。
  
• 优化本领：避免重复盘算用缓存和生成器，减少 IO 用批量和异步。
  
• 丈量工具：timeit 帮你量化优化结果。
  

希望你看完能有所劳绩，赶紧把这些本领用到自己的代码里吧！有什么问题，随时问我哦～

---

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。