、算法设计

Python 的数据结构，算法和设计模式的实现。另请参阅真棒算法。

演算法

algorithms 数据结构和算法的最小示例。

https://github.com/keon/algorithms

python-ds 用于采访采访的数据结构和算法的集合。

https://github.com/prabhupant/python-ds

sortedcontainers 排序集合的快速和纯 Python 实现。

https://github.com/grantjenks/python-sortedcontainers

TheAlgorithms- 用 Python 实现的所有算法。

https://github.com/TheAlgorithms/Python

设计模式

PyPattyrn- 一个简单但有效的库，用于实现常见的设计模式。

https://github.com/tylerlaberge/PyPattyrn

python-patterns -Python 中设计模式的集合。

https://github.com/faif/python-patterns

transitions - 一种轻量级的，面向对象的有限状态机实现。

https://github.com/pytransitions/transitions

二、声音、视频、图像、文字处理

用于处理音频及其元数据的库。

声音的

audioread- 跨库（GStreamer + 核心音频 + MAD + FFmpeg）音频解码。

https://github.com/beetbox/audioread

dejavu- 音频指纹识别。

https://github.com/worldveil/dejavu

kapre - Keras 音频预处理器

https://github.com/keunwoochoi/kapre

librosa- 用于音频和音乐分析的 Python 库

https://github.com/librosa/librosa

matchering - 一个用于自动参考音频制作的库。

https://github.com/sergree/matchering

mingus- 带有 MIDI 文件和播放支持的高级音乐理论和乐谱包。

http://bspaans.github.io/python-mingus/

pyAudioAnalysis- 音频特征提取，分类，分段和应用。

https://github.com/tyiannak/pyAudioAnalysis

pydub- 使用简单易用的高级界面处理音频。

https://github.com/jiaaro/pydub

TimeSide- 开放的 Web 音频处理框架。

https://github.com/Parisson/TimeSide

Metadata

beets- 音乐库管理器和 MusicBrainz 标记器。

https://github.com/beetbox/beets

eyeD3- 一种用于处理音频文件的工具，特别是包含 ID3 元数据的 MP3 文件。

https://github.com/nicfit/eyeD3

mutagen- 处理音频元数据的 Python 模块。

https://github.com/quodlibet/mutagen

tinytag- 用于读取 MP3，OGG，FLAC 和 Wave 文件的音乐元数据的库。

https://github.com/devsnd/tinytag

用于处理视频和 GIF 的库。

moviepy- 用于基于脚本的电影编辑的模块，具有多种格式，包括动画 GIF。

https://zulko.github.io/moviepy/

scikit-video -SciPy 的视频处理例程。

https://github.com/aizvorski/scikit-video

vidgear- 最强大的多线程视频处理框架。

https://github.com/abhiTronix/vidgear

用于处理图像的库。

hmap- 图像直方图重新映射。

https://github.com/rossgoodwin/hmap

imgSeek- 使用视觉相似性搜索图像集合的项目。

https://sourceforge.net/projects/imgseek/

nude.py- 裸露检测。

https://github.com/hhatto/nude.py

pagan - 复古 identicon（阿凡达）根据输入的字符串和哈希生成。

https://github.com/daboth/pagan

pillow- 枕头是友好的 PIL 叉。

https://github.com/python-pillow/Pillow

python- barcode - 在 Python 中创建条形码，没有任何额外的依赖关系。

https://github.com/WhyNotHugo/python-barcode

pygram- 类似 Instagram 的图像过滤器。

https://github.com/ajkumar25/pygram

PyMatting -Alpha 遮罩的库。

http://github.com/pymatting/pymatting

python-qrcode- 一个纯 Python QR Code 生成器。

https://github.com/lincolnloop/python-qrcode

pywal- 一种从图像生成配色方案的工具。

https://github.com/dylanaraps/pywal

pyvips- 具有低内存需求的快速图像处理库。

https://github.com/libvips/pyvips

Quads - 基于四叉树的计算机艺术。

https://github.com/fogleman/Quads

scikit-image- 用于（科学）图像处理的 Python 库。

http://scikit-image.org/

thumbor- 智能影像服务。它可以按需裁剪，调整图像大小和翻转图像。

https://github.com/thumbor/thumbor

wand - MagickWand 的 Python 绑定，ImageMagick 的 C API。

https://github.com/dahlia/wand

用于解析和处理纯文本的库。

一般的

chardet- 与 Python 2/3 兼容的字符编码检测器。

https://github.com/chardet/chardet

difflib-（Python 标准库）用于计算增量的帮助程序。

https://docs.python.org/3/library/difflib.html

ftfy- 自动使 Unicode 文本更清晰，更一致。

https://github.com/LuminosoInsight/python-ftfy

Fuzzywuzzy- 模糊字符串匹配。

https://github.com/seatgeek/fuzzywuzzy

Levenshtein- 快速计算 Levenshtein 距离和字符串相似度。

https://github.com/ztane/python-Levenshtein/

pangu.py- 偏执的文字间距。

https://github.com/vinta/pangu.py

pyfiglet- 用 Python 编写的 figlet 的实现。

https://github.com/pwaller/pyfiglet

pypinyin- 将汉字（Hanzi）转换为拼音（Pyyin）。

https://github.com/mozillazg/python-pinyin

textdistance- 使用 30 多种算法计算序列之间的距离。

https://github.com/orsinium/textdistance

unidecode -Unicode 文本的 ASCII 音译。

https://pypi.org/project/Unidecode/

Slugify

awesome-slugify- 一个可以保留 unicode 的 Python slugify 库。

https://github.com/dimka665/awesome-slugify

python-slugify- 一个 Python slugify 库，它将 unicode 转换为 ASCII。

https://github.com/un33k/python-slugify

unicode-slugify- 一种 Slugifier，它以 Django 为依赖项生成 unicode slug。

https://github.com/mozilla/unicode-slugify

唯一标识符

hashids- 在 Python 中实现 hashids。

https://github.com/davidaurelio/hashids-python

shortuuid- 简洁，明确和 URL 安全的 UUID 的生成器库。

https://github.com/skorokithakis/shortuuid

解析器

ply - 的 lex 和 yacc 解析工具的 Python 实现。

https://github.com/dabeaz/ply

pygments- 通用语法荧光笔。

http://pygments.org/

pyparsing- 生成解析器的通用框架。

https://github.com/pyparsing/pyparsing

python-nameparser - 将人名解析为它们的各个组成部分。

https://github.com/derek73/python-nameparser

python-phonenumbers- 解析，格式化，存储和验证国际电话号码。

https://github.com/daviddrysdale/python-phonenumbers

python-user-agents- 浏览器用户代理解析器。

https://github.com/selwin/python-user-agents

sqlparse- 一个非验证的 SQL 解析器。

https://github.com/andialbrecht/sqlparse

三、日期和时间

用于处理日期和时间的库。

Arrow- 一个 Python 库，提供了一种明智且人性化的方法来创建，操作，格式化和转换日期，时间和时间戳。

https://arrow.readthedocs.io/en/latest/

Chronyk- 一个 Python 3 库，用于解析人类编写的时间和日期。

https://github.com/KoffeinFlummi/Chronyk

dateutil- 标准 Python datetime 模块的扩展。

https://github.com/dateutil/dateutil

delorean- 一个库，用于清除与日期时间有关的不便的事实。

https://github.com/myusuf3/delorean/

maya- 人类的日期时间。

https://github.com/timofurrer/maya

moment - 一个 Python 库用于处理日期 / 时间。受到 Moment.js 的启发。

https://github.com/zachwill/moment

Pendulum-Python 日期时间变得容易。

https://github.com/sdispater/pendulum

PyTime- 一个易于使用的 Python 模块，旨在按字符串操作日期 / 时间 / 日期时间。

https://github.com/shinux/PyTime

pytz- 世界时区定义，现代和历史。将 tz 数据库带入 Python。

https://launchpad.net/pytz

when.py- 提供用户友好的功能来帮助执行常见的日期和时间操作。

https://github.com/dirn/When.py

四、爬虫

自动执行 Web 抓取。

cola- 分布式抓取框架。

https://github.com/chineking/cola

feedparser- 通用供稿解析器。

https://pythonhosted.org/feedparser/

grab - 网站抓取框架。

https://github.com/lorien/grab

MechanicalSoup- 用于自动与网站进行交互的 Python 库。

https://github.com/MechanicalSoup/MechanicalSoup

portia - Scrapy 的视觉抓取。

https://github.com/scrapinghub/portia

pyspider- 强大的蜘蛛系统。

https://github.com/binux/pyspider

robobrowser- 一个简单的 Pythonic 库，无需独立的 Web 浏览器即可浏览 Web。

https://github.com/jmcarp/robobrowser

scrapy- 快速的高级屏幕抓取和网络爬网框架。

https://scrapy.org/

用于提取 Web 内容的库。

html2text- 将 HTML 转换为 Markdown 格式的文本。

https://github.com/Alir3z4/html2text

lassie- 人类的 Web 内容检索。

https://github.com/michaelhelmick/lassie

micawber- 一个小型库，用于从 URL 中提取丰富的内容。
https://github.com/coleifer/micawber

newspaper -Python 中的新闻提取，文章提取和内容管理。

https://github.com/codelucas/newspaper

python- readability - arc90 的可读性工具的快速 Python 端口。

https://github.com/buriy/python-readability

requests-html –适用于人类的 Pythonic HTML 解析。

https://github.com/psf/requests-html

sumy- 自动汇总文本文档和 HTML 页面的模块。

https://github.com/miso-belica/sumy

textract- 从任何文档，Word，PowerPoint，PDF 等中提取文本

https://github.com/deanmalmgren/textract

toapi- 每个网站都提供 API。

https://github.com/gaojiuli/toapi

五、HTML、XML

用于处理 HTML 和 XML 的库。

BeautifulSoup- 提供 Pythonic 惯用法来迭代，搜索和修改 HTML 或 XML。

bleach –基于白名单 HTML 清理和文本 linkification 库中的。

cssutils- 一个 Python 的 CSS 库。

html5lib- 一个符合标准的库，用于解析和序列化 HTML 文档和片段。

lxml- 一个非常快速，易于使用的通用库，用于处理 HTML 和 XML。

MarkupSafe- 为 Python 实现 XML / HTML / XHTML 标记安全字符串。

pyquery- 用于解析 HTML 的类似 jQuery 的库。

untangle –将 XML 文档转换为 Python 对象，以方便访问。

WeasyPrint- 用于 HTML 和 CSS 的可视渲染引擎，可以导出为 PDF。

xmldataset- 简单的 XML 解析。

xmltodict- 使用 XML 就像使用 JSON。

六、HTTP 客户端

使用 HTTP 的库。

grequests- 异步 HTTP 请求的 request + gevent。

httplib2- 全面的 HTTP 客户端库。

httpx- 用于 Python 的下一代 HTTP 客户端。

requests -HTTP 对人类的请求。

treq -Python 请求，例如在 Twisted 的 HTTP 客户端之上构建的 API。

七、office 模块

用于解析和处理特定文本格式的库。

General

tablib -XLS，CSV，JSON，YAML 中的表格数据集的模块。

Office

docxtpl- 通过 jinja2 模板编辑 docx 文档

openpyxl- 用于读取和写入 Excel 2010 xlsx /xlsm/xltx /xltm 文件的库。

pyexcel- 提供一个用于读取，操作和写入 csv，ods，xls，xlsx 和 xlsm 文件的 API。

python-docx- 读取，查询和修改 Microsoft Word 2007/2008 docx 文件。

python-pptx- 用于创建和更新 PowerPoint（.pptx）文件的 Python 库。

unoconv- 在 LibreOffice / OpenOffice 支持的任何文档格式之间转换。

XlsxWriter- 一个用于创建 Excel .xlsx 文件的 Python 模块。

xlwings -BSD 许可的库，可以轻松地从 Excel 调用 Python，反之亦然。

xlwt / xlrd- 从 Excel 文件写入和读取数据以及格式化信息。

PDF 格式

PDFMiner- 一种从 PDF 文档提取信息的工具。

PyPDF2- 一个能够拆分，合并和转换 PDF 页面的库。

ReportLab- 允许快速创建丰富的 PDF 文档。

Markdown

Mistune-Markdown 最快，功能最全的纯 Python 解析器。

Python-Markdown -John Gruber 的 Markdown 的 Python 实现。

YAML

PyYAML- 适用于 Python 的 YAML 实现。

CSV

csvkit- 转换为 CSV 并使用 CSV 的实用程序。

Archive

unp- 一个命令行工具，可以轻松地解压缩档案。

八、序列化

用于序列化复杂数据类型的库

marshmallow- 一个轻量级的库，用于将复杂的对象与简单的 Python 数据类型相互转换。

pysimdjson - 一个 Python 绑定 simdjson。

python-rapidjson- 一个 Python 包装周围 RapidJSON。

ultrajson- 使用 Python 绑定用 C 编写的快速 JSON 解码器和编码器。

九、代码分析、测试

码质量检查器的工具。另请参阅令人敬畏的静态分析。

代码分析

Coala- 语言独立且易于扩展的代码分析应用程序。

code2flow- 将您的 Python 和 JavaScript 代码转换为 DOT 流程图。

prospector- 分析 Python 代码的工具。

pycallgraph- 一个可视化 Python 应用程序流程（调用图）的库。

vulture- 查找和分析无效的 Python 代码的工具。

Code Linters

flake8 - 一个包装器 pycodestyle，pyflakes 和麦凯布。

很棒的片状 8 扩展

pylama- 用于 Python 和 JavaScript 的代码审核工具。

pylint- 完全可定制的源代码分析器。

wemake-python-styleguide- 有史以来最严格，最自以为是的 python linter。

代码格式化程序

black –毫不妥协的 Python 代码格式化程序。

isort- 用于对导入进行排序的 Python 实用程序 / 库。

yapf- 另一个来自 Google 的 Python 代码格式化程序。

静态类型检查器，另请参见 awesome-python-typing

mypy- 在编译期间检查变量类型。

pyre-check- 性能类型检查。

typeshed- 具有静态类型的 Python 库存根的集合。

静态类型注释生成器

MonkeyType- 一个用于 Python 的系统，通过收集运行时类型来生成静态类型注释。

pyannotate- 自动生成 PEP-484 注释。

pytype -pytype 检查并推断 Python 代码的类型 - 无需类型注释。

渗透测试的框架和工具。

fsociety- 渗透测试框架。

setoolkit- 社会工程的工具包。

sqlmap- 自动 SQL 注入和数据库接管工具。

用于测试代码库和生成测试数据的库。

测试框架

hypothesis –假设是一个高级的 Quickcheck 样式基于属性的测试库。

nose2 -nose 基于 `unittest2。的后继者。

pytest- 一个成熟的功能齐全的 Python 测试工具。

Robot Framework 通用的测试自动化框架。

unittest-（Python 标准库）单元测试框架。

测试选手

green - 干净，多彩的测试运行器。

mamba -Python 的权威测试工具。生于 BDD 的旗帜下。

tox- 自动构建和测试多个 Python 版本的发行版

GUI / Web 测试

locust- 用 Python 编写的可扩展用户负载测试工具。

PyAutoGUI -PyAutoGUI 是适用于人类的跨平台 GUI 自动化 Python 模块。

Schemathesis- 用于对基于 Open API / Swagger 规范构建的 Web 应用程序进行基于属性的自动测试的工具。

Selenium - Selenium WebDriver 的 Python 绑定。

sixpack- 与语言无关的 A / B 测试框架。

splinter- 用于测试 Web 应用程序的开源工具。

Mock

doublex- 强大的 Python 测试框架加倍。

Frozengun- 通过模拟 datetime 模块来穿越时间。

httmock- 一个针对 Python 2.6 + 和 3.2 + 的请求的模拟库。

httpretty- 适用于 Python 的 HTTP 请求模拟工具。

mock-（Python 标准库）一个模拟和修补库。

mocket - 具有 gevent /asyncio/ SSL 支持的套接字模拟框架。

responses 一个实用程序库，用于模拟请求 Python 库。

VCR.py- 记录并重放测试中的 HTTP 交互。

对象工厂

factory_boy -Python 的测试装置替代品。

mixer- 另一种灯具更换。支持 Django，Flask，SQLAlchemy，Peewee 等

model_mommy- 创建随机夹具以在 Django 中进行测试。

代码覆盖率

coverage- 代码覆盖率度量。

伪数据

fake2db- 伪数据库生成器。

faker- 一个生成伪造数据的 Python 包。

mimesis- 是一个 Python 库，可帮助您生成虚假数据。

radar - 生成随机的日期时间 / 时间。

用于验证数据的库。

Cerberus- 一个轻量级和可扩展的数据验证库。

colander- 验证和反序列化通过 XML，JSON 和 HTML 表单发布获得的数据。

jsonschema - Python 的 JSON 模式的实现。

schema- 用于验证 Python 数据结构的库。

Schematics –数据结构验证。

valideer - 轻量级可扩展数据验证和适配库。

voluptuous - 的 - 一个 Python 数据验证库。

十、web 框架

传统的全栈 Web 框架。另请参阅 RESTful API。

同步

Django -Python 中最流行的 Web 框架。

很棒的 django

很棒的 django

Flask -Python 的微框架。

很棒的烧瓶

Pyramid- 一个小型，快速，扎实的开源 Python Web 框架。

真棒金字塔

Masonite- 以开发人员为中心的现代 Python Web 框架。

异步

Tornado- 一个 Web 框架和异步网络库。

十一、搜索

用于对数据建立索引并执行搜索查询的库和软件。

django-haystack- 模块化搜索 Django。

elasticsearch-dsl-py -Elasticsearch 的官方高级 Python 客户端。

elasticsearch-py - Elasticsearch 的官方低层 Python 客户端。

pysolr - Apache Solr 的轻量级 Python 包装器。

whoosh- 一个快速的纯 Python 搜索引擎库。

十二、日志记录

用于生成和使用日志的库。

logbook - - 记录 Python 的替换记录。

logging-（Python 标准库）Python 的日志记录工具。

loguru- 旨在以 Python 带来令人愉悦的日志记录的库。

sentry- python - 适用于 Python 的 Sentry SDK。

structlog- 结构化日志变得容易。

十三、并发与并行

用于并发和并行执行的库。另请参阅 awesome-asyncio。

parallel.futures-（Python 标准库）用于异步执行可调用对象的高级接口。

eventlet- 具有 WSGI 支持的异步框架。

gevent- 使用 greenlet 的基于协程的 Python 网络库。

multiprocessing-（Python 标准库）基于进程的并行性。

scoop -Python 中的可伸缩并发操作。

uvloop - 在.NET 之上的 asyncio 事件循环的超快速实现 libuv。

十四、任务队列

用于处理任务队列的库。

celery- 基于分布式消息传递的异步任务队列 / 作业队列。

Dramatiq- 用于 Python 3 的快速可靠的后台任务处理库。

huey- 小多线程任务队列。

mrq- 使用 Redis 和 gevent 的 Python 中的分布式工作者任务队列。

rq -Python 的简单作业队列。

十五、自然语言处理

用于使用人类语言的图书馆。

一般的

gensim- 人类主题建模。

langid.py- 独立的语言识别系统。

nltk- 用于构建 Python 程序以使用人类语言数据的领先平台。

pattern- 一个 Web 挖掘模块。

polyglot- 支持数百种语言的自然语言管道。

pytext 的 - 基于 PyTorch 自然语言建模框架。

PyTorch-NLP- 一种工具包，可用于研究的快速深度学习 NLP 原型。

spacy - 一种用于 Python 和用 Cython 工业强度的自然语言处理库。

Stanza -Stanford NLP Group 的官方 Python 库，支持 60 多种语言。

中国人

funNLP- 中国 NLP 的工具和数据集的集合。

jieba- 最受欢迎的中文文本分割库。

pkuseg-python- 用于各种领域的中文分词的工具包。

snownlp- 用于处理中文文本的库。

十六、深度学习、机器学习、计算机视觉

神经网络和深度学习框架。另请参阅真棒深度学习。

caffe- 深度学习的快速开放框架。

keras- 一个高级神经网络库，能够在 TensorFlow 或 Theano 之上运行。

mxnet- 专为效率和灵活性而设计的深度学习框架。

pytorch- 具有强大 GPU 加速功能的 Python 中的张量和动态神经网络。

SerpentAI- 游戏代理框架。使用任何视频游戏作为深度学习沙箱。

tensorflow- 由 Google 创建的最受欢迎的深度学习框架。

Theano- 一个用于快速数值计算的库。

机器学习图书馆。另请参阅很棒的机器学习。

健身房 - 用于开发和比较强化学习算法的工具包。

H2O- 开源快速可扩展机器学习平台。

指标 - 机器学习评估指标。

NuPIC -Numenta 智能计算平台。

scikit-learn- 最受欢迎的机器学习 Python 库。

Spark ML - Apache Spark 的可扩展机器学习库。

vowpal_porpoise- 用于 Vowpal Wabbit 的轻量级 Python 包装器。

xgboost- 一个可扩展，可移植和分布式的梯度增强库。

MindsDB -MindsDB 是现有数据库的开源 AI 层，可让您使用标准查询轻松地开发，训练和部署最新的机器学习模型。

计算机视觉图书馆。

EasyOCR- 支持 40 多种语言的即用型 OCR。

人脸识别 - 简单的人脸识别库。

Kornia - PyTorch 的开源可区分计算机视觉库。

OpenCV- 开源计算机视觉库。

pytesseract - Google Tesseract OCR 的包装。

SimpleCV- 用于构建计算机视觉应用程序的开源框架。

tesserocr-tesseract-ocr 用于 OCR 的 API 的另一种简单，对枕头友好的包装。

十七、数据分析、可视化

用于数据分析的库。

AWS Data Wrangler -AWS 上的 Pandas。

Blaze -NumPy 和 Pandas 连接到大数据。

Pandas 界面中的 Open Mining- 商业智能（BI）。

Optimus –敏捷数据科学的工作流程变得容易与 PySpark。

Orange –通过可视化编程或脚本进行数据挖掘，数据可视化，分析和机器学习。

Pandas- 一个提供高性能，易于使用的数据结构和数据分析工具的库。

用于可视化数据的库。另请参阅 awesome-javascript。

Altair- 用于 Python 的声明性统计可视化库。

Bokeh- 用于 Python 的交互式 Web 绘图。

bqplot -Jupyter Notebook 的交互式绘图库

Cartopy- 具有 matplotlib 支持的制图 python 库

短跑 - 建立在烧瓶顶部，反应，Plotly 旨在分析 Web 应用程序。

很棒的破折号

图表 - 图表为代码。

Matplotlib- 一个 Python 2D 绘图库。

plotnine- 基于 ggplot2 的 Python 图形语法。

Pygal- 一个 Python SVG 图表创建器。

PyGraphviz - Graphviz 的 Python 接口。

PyQtGraph- 交互式和实时 2D / 3D / 图像绘制以及科学 / 工程小部件。

Seaborn - 使用 Matplotlib 统计数据可视化。

VisPy- 基于 OpenGL 的高性能科学可视化。

十八、数据库驱动程序

用于连接和操作数据库的库。

MySQL- 很棒的 MySQL

mysqlclient- 支持 Python 3 的 MySQL 连接器（mysql-python fork）。

PyMySQL- 与 mysql-python 兼容的纯 Python MySQL 驱动程序。

PostgreSQL- 很棒的 Postgres

psycopg2- 最受欢迎的 Python PostgreSQL 适配器。

查询 -psycopg2 库的包装，用于与 PostgreSQL 交互。

SQlite- 很棒的 SQLite

sqlite3-（Python 标准库）与 DB-API 2.0 兼容的 SQlite 接口

SuperSQLite- 建立在 apsw 之上的增压 SQLite 库。

其他关系数据库

pymssql -Microsoft SQL Server 的简单数据库接口。

clickhouse-driver- 具有 ClickHouse 本地接口的 Python 驱动程序。

NoSQL 数据库

cassandra-driver -Apache Cassandra 的 Python 驱动程序。

happybase -Apache HBase 的开发人员友好型库。

kafka-python -Apache Kafka 的 Python 客户端。

py2neo- 用于 Neo4j 的客户端库和工具包。

pymongo -MongoDB 的官方 Python 客户端。

redis-py -Redis 的 Python 客户端。

异步客户端

motor -MongoDB 的异步 Python 驱动程序。

十九、DevOps 工具

DevOps 的软件和库。

配置管理

ansible- 一个非常简单的 IT 自动化平台。

cloudinit- 一个多分发包，用于处理云实例的早期初始化。

OpenStack- 用于构建私有和公共云的开源软件。

pyinfra- 通用的 CLI 工具和 python 库，可自动执行基础架构。

saltstack- 基础结构自动化和管理系统。

SSH 样式的部署

cuisine - 类似于 Fabric 的厨师功能。

fabric - 一个简单的，Python 化工具，用于远程执行和部署。

fabtools- 编写很棒的 Fabric 文件的工具。

流程管理

honcho - Foreman 的 Python 克隆，用于管理基于 Procfile 的应用程序。

supervisor - 用于 UNIX 监事过程控制系统。

监控方式

psutil- 跨平台的流程和系统实用程序模块。

后备

BorgBackup- 具有压缩和加密功能的重复数据删除存档器。

其他

docker- compose- 使用 Docker 的快速隔离开发环境。

二十、分布式计算

分布式计算的框架和库。

批量处理

dask- 用于分析计算的灵活并行计算库。

luigi- 一个模块，可帮助您构建批处理作业的复杂管道。

mrjob- 在 Hadoop 或 Amazon Web Services 上运行 MapReduce 作业。

PySpark - Apache Spark Python API。

Ray- 用于并行和分布式 Python 的系统，统一了机器学习生态系统。

流处理

faust- 流处理库，将想法从 Kafka Streams 移植到 Python。

streamparse- 通过 Apache Storm 针对实时数据流运行 Python 代码。

二十一、配置、打包构建

用于存储和解析配置选项的库。

configobj- 带有验证的 INI 文件解析器。

configparser-（Python 标准库）INI 文件解析器。

hydra -Hydra 是用于优雅配置复杂应用程序的框架。

profig- 使用值转换从多种格式进行配置。

python-decouple- 严格将设置与代码分开。

用于创建打包的可执行文件以进行发行的库。

dh-virtualenv- 以 Debian 软件包的形式构建和分发 virtualenv。

Nuitka - 将脚本，模块，程序包编译为可执行文件或扩展模块。

py2app- 冻结 Python 脚本（Mac OS X）。

py2exe- 冻结 Python 脚本（Windows）。

pyarmor- 一种用于混淆 python 脚本，将混淆后的脚本绑定到固定计算机或使混淆后的脚本失效的工具。

PyInstaller- 将 Python 程序转换为独立的可执行文件（跨平台）。

pynsist- 用于构建 Windows 安装程序的工具，安装程序将 Python 本身捆绑在一起。

shiv- 命令行实用程序，用于构建完全独立的 zipapp（PEP 441），但包括其所有依赖项。

二十二、虚拟环境

用于 Python 版本和虚拟环境管理的库。

pyenv- 简单的 Python 版本管理。

virtualenv- 创建隔离的 Python 环境的工具。

二十三、界面开发

用于处理图形用户界面应用程序的库。

curses - - 内置包装器 ncurses 的用于创建终端 GUI 的应用程序。

Eel- 一个用于制作简单的类似于电子的脱机 HTML / JS GUI 应用程序的库。

enaml- 使用声明性语法（如 QML）创建漂亮的用户界面。

Flexx -Flexx 是用于创建 GUI 的纯 Python 工具包，它使用 Web 技术进行呈现。

Gooey - 使用命令行将命令行程序转换为完整的 GUI 应用程序。

kivy- 用于创建 NUI 应用程序的库，可在 Windows，Linux，Mac OS X，Android 和 iOS 上运行。

pyglet -Python 的跨平台窗口和多媒体库。

PyGObject -GLib / GObject / GIO / GTK +（GTK + 3）的 Python 绑定。

PyQt - Qt 跨平台应用程序和 UI 框架的 Python 绑定。

PySimpleGUI - tkinter，Qt，WxPython 和 Remi 的包装。

pywebview- 围绕 webview 组件的轻量级跨平台本机包装器。

Tkinter -Tkinter 是 Python 的事实上的标准 GUI 软件包。

Toga -Python 本机，OS 本机 GUI 工具箱。

urwid- 一个用于创建终端 GUI 应用程序的库，该库对小部件，事件，丰富的颜色等具有强大的支持。

wxPython -wxWidgets C ++ 类库与 Python 的混合。

DearPyGui- 一个简单的 GPU 加速的 Python GUI 框架

二十四、游戏开发

很棒的游戏开发库。

Arcade -Arcade 是一个现代 Python 框架，用于制作具有引人注目的图形和声音的游戏。

Cocos2d -cocos2d 是用于构建 2D 游戏，演示和其他图形 / 交互应用程序的框架。

Harfang3D- 用于 3D，VR 和游戏开发的 Python 框架。

Panda3D- 迪士尼开发的 3D 游戏引擎。

Pygame -Pygame 是一组旨在编写游戏的 Python 模块。

PyOgre -Ogre 3D 渲染引擎的 Python 绑定，可用于游戏，模拟或任何 3D。

PyOpenGL -OpenGL 及其相关 API 的 Python ctypes 绑定。

PySDL2 -SDL2 库的基于 ctypes 的包装器。

RenPy- 一个视觉小说引擎

二十五、任务调度器

用于计划作业的库。

Airflow 气流是一个以编程方式编写，安排和监视工作流的平台。

APScheduler- 轻巧但功能强大的进程内任务计划程序，可让您计划功能。

django-schedule -Django 的日历应用程序。

doit- 一个任务运行器和构建工具。

gunnery - 具有基于 Web 界面的分布式系统的多用途任务执行工具。

Joblib- 一套在 Python 中提供轻量级流水线的工具。

Plan - 像用吊饰一样用 Python 编写 crontab 文件。

Prefect- 一个现代的工作流程编排框架，可轻松构建，调度和监视强大的数据管道。

schedule- 针对人类的 Python 作业调度。

Spiff- 用纯 Python 实现的功能强大的工作流引擎。

TaskFlow- 一个 Python 库，可帮助简化，一致且可靠的任务执行

二十六、科学计算

用于科学计算的图书馆。另请参见 Python for-Scientists。

astropy- 天文学的社区 Python 库。

bcbio-nextgen- 提供最佳实践流水线，用于全自动高通量测序分析。

bccb- 收集与生物学分析有关的有用代码。

Biopython -Biopython 是一套免费的生物计算工具。

cclib- 一个用于解析和解释计算化学程序包结果的库。

Colour - 实施大量的颜色理论转换和算法。

Karate Club - 用于图形结构化数据的无监督机器学习工具箱。

NetworkX- 用于复杂网络的高生产率软件。

NIPY- 神经影像工具箱的集合。

NumPy- 使用 Python 进行科学计算的基本软件包。

ObsPy- 地震学的 Python 工具箱。

Open Babel- 一种化学工具箱，旨在讲多种化学数据语言。

PyDy -Python Dynamics 的缩写，用于协助工作流进行动态运动建模。

PyMC- 马尔可夫链蒙特卡洛采样工具包。

QuTiP -Python 中的 Quantum Toolbox。

RDKit- 化学信息学和机器学习软件。

SciPy- 用于数学，科学和工程的基于 Python 的开源软件生态系统。

SimPy- 一个基于过程的离散事件模拟框架。

statsmodels -Python 中的统计建模和计量经济学。

SymPy- 一个用于符号数学的 Python 库。

Zipline- 一个 Pythonic 算法交易库。

RPC

RPC 兼容服务器。

RPyC（远程 Python 调用）- 用于 Python 的透明且对称的 RPC 库

zeroRPC -zerorpc 是基于 ZeroMQ 和 MessagePack 的灵活 RPC 实现。

from turtle import*
def nose(x,y):#鼻子
 penup()#提起笔
 goto(x,y)#定位
 pendown()#落笔，开始画
 setheading(-30)#将乌龟的方向设置为to_angle/为数字（0-东、90-北、180-西、270-南）
 begin_fill()#准备开始填充图形
 a=0.4
 for i in range(120):
 if 0<=i<30 or 60<=i<90:
 a=a+0.08
 left(3) #向左转3度
 forward(a) #向前走a的步长
 else:
 a=a-0.08
 left(3)
 forward(a)
 end_fill()#填充完成
 penup()
 setheading(90)
 forward(25)
 setheading(0)
 forward(10)
 pendown()
 pencolor(255,155,192)#画笔颜色
 setheading(10)
 begin_fill()
 circle(5)
 color(160,82,45)#返回或设置pencolor和fillcolor
 end_fill()
 penup()
 setheading(0)
 forward(20)
 pendown()
 pencolor(255,155,192)
 setheading(10)
 begin_fill()
 circle(5)
 color(160,82,45)
 end_fill()
def head(x,y):#头
 color((255,155,192),"pink")
 penup()
 goto(x,y)
 setheading(0)
 pendown()
 begin_fill()
 setheading(180)
 circle(300,-30)
 circle(100,-60)
 circle(80,-100)
 circle(150,-20)
 circle(60,-95)
 setheading(161)
 circle(-300,15)
 penup()
 goto(-100,100)
 pendown()
 setheading(-30)
 a=0.4
 for i in range(60):
 if 0<=i<30 or 60<=i<90:
 a=a+0.08
 lt(3) #向左转3度
 fd(a) #向前走a的步长
 else:
 a=a-0.08
 lt(3)
 fd(a)
 end_fill()
def cheek(x,y):#腮
 color((255,155,192))
 penup()
 goto(x,y)
 pendown()
 setheading(0)
 begin_fill()
 circle(30)
 end_fill()
def mouth(x,y): #嘴
 color(239,69,19)
 penup()
 goto(x,y)
 pendown()
 setheading(-80)
 circle(30,40)
 circle(40,80)
def setting(): #参数设置
 pensize(4)
 hideturtle() #使乌龟无形（隐藏）
 colormode(255) #将其设置为1.0或255.随后 颜色三元组的r，g，b值必须在0 .. cmode范围内
 color((255,155,192),"pink")
 setup(840,500)
 speed(10)
def main():
 setting() #画布、画笔设置
 nose(-100,100) #鼻子
 head(-69,167) #头
 ears(0,160) #耳朵
 eyes(0,140) #眼睛
 cheek(80,10) #腮
 mouth(-20,30) #嘴
 done()
if __name__=='__main__':
	main()

元测试（Unit Testing）

为程序编写测试——如果做的到位——有助于减少bug的出现，并可以提高我们对程序按预期目标运行的信心。通常，测试并不能保证正确性，因为对大多数程序而言， 可能的输入范围以及可能的计算范围是如此之大，只有其中最小的一部分能被实际地进 行测试。尽管如此，通过仔细地选择测试的方法和目标，可以提高代码的质量。

大量不同类型的测试都可以进行，比如可用性测试、功能测试以及整合测试等。这里, 我们只讲单元测试一对单独的函数、类与方法进行测试，确保其符合预期的行为。

TDD的一个关键点是，当我们想添加一个功能时——比如为类添加一个方法—— 我们首次为其编写一个测试用例。当然，测试将失败，因为我们还没有实际编写该方法。现在，我们编写该方法，一旦方法通过了测试，就可以返回所有测试，确保我们新添加的代码没有任何预期外的副作用。一旦所有测试运行完毕（包括我们为新功能编写的测试），就可以对我们的代码进行检查，并有理有据地相信程序行为符合我们的期望——当然，前提是我们的测试是适当的。

比如，我们编写了一个函数，该函数在特定的索引位置插入一个字符串，可以像下面这样开始我们的TDD：

def insert_at（string, position, insert）:

"""Returns a copy of string with insert inserted at the position

>>> string="ABCDE"

>>> result=[]

>>> for i in range(-2, len(string) + 2):

... result.append(insert_at(string, i,“-”))

>>> result[:5]

['ABC-DE', 'ABCD-E', '-ABCDE','A-BCDE', 'AB-CDE']

>>> result[5:]

['ABC-DE', 'ABCD-E', 'ABCDE-', 'ABCDE-']

"""

return string

对不返回任何参数的函数或方法（通常返回None）,我们通常赋予其由pass构成的一个suite,对那些返回值被试用的，我们或者返回一个常数（比如0）,或者某个不变的参数——这也是我们这里所做的。（在更复杂的情况下，返回fake对象可能更有用一一对这样的类，提供mock对象的第三方模块是可用的。）

运行doctest时会失败，并列出每个预期内的字符串（'ABCD-EF'、'ABCDE-F' 等），及其实际获取的字符串（所有的都是'ABCD-EF'）。一旦确定doctest是充分的和正确的，就可以编写该函数的主体部分，在本例中只是简单的return string[:position] + insert+string[position:]。（如果我们编写的是 return string[:position] + insert,之后复制 string [:position]并将其粘贴在末尾以便减少一些输入操作，那么doctest会立即提示错误。）

Python的标准库提供了两个单元测试模块，一个是doctest,这里和前面都简单地提到过，另一个是unittest。此外，还有一些可用于Python的第三方测试工具。其中最著名的两个是nose (code.google.com/p/python-nose)与py.test (codespeak.net/py/dist/test/test.html), nose 致力于提供比标准的unittest 模块更广泛的功能，同时保持与该模块的兼容性，py.test则采用了与unittest有些不同的方法，试图尽可能消除样板测试代码。这两个第三方模块都支持测试发现，因此没必要写一个总体的测试程序——因为模块将自己搜索测试程序。这使得测试整个代码树或某一部分 (比如那些已经起作用的模块)变得很容易。那些对测试严重关切的人，在决定使用哪个测试工具之前，对这两个(以及任何其他有吸引力的)第三方模块进行研究都是值 得的。

创建doctest是直截了当的：我们在模块中编写测试、函数、类与方法的docstrings。 对于模块，我们简单地在末尾添加了 3行：

if __name__=="__main__":

import doctest

doctest.testmod()

在程序内部使用doctest也是可能的。比如，blocks.py程序(其模块在后面)有自己函数的doctest，但以如下代码结尾：

if __name__=="__main__":

main()

这里简单地调用了程序的main()函数，并且没有执行程序的doctest。要实验程序的 doctest,有两种方法。一种是导入doctest模块，之后运行程序---比如，在控制台中输 入 python3 -m doctest blocks.py (在 Wndows 平台上，使用类似于 C:\Python3 l\python.exe 这样的形式替代python3)。如果所有测试运行良好，就没有输出，因此，我们可能宁愿执行python3-m doctest blocks.py-v,因为这会列出每个执行的doctest,并在最后给出结果摘要。

另一种执行doctest的方法是使用unittest模块创建单独的测试程序。在概念上， unittest模块是根据Java的JUnit单元测试库进行建模的，并用于创建包含测试用例的测试套件。unittest模块可以基于doctests创建测试用例，而不需要知道程序或模块包含的任何事物——只要知道其包含doctest即可。因此，为给blocks.py程序制作一个测试套件，我们可以创建如下的简单程序(将其称为test_blocks.py)：

import doctest

import unittest

import blocks

suite=unittest.TestSuite()

suite.addTest(doctest.DocTestSuite(blocks))

runner=unittest.TextTestRunner()

print(runner.run(suite))

注意，如果釆用这种方法，程序的名称上会有一个隐含的约束：程序名必须是有效的模块名。因此，名为convert-incidents.py的程序的测试不能写成这样。因为import convert-incidents不是有效的，在Python标识符中，连接符是无效的（避开这一约束是可能的，但最简单的解决方案是使用总是有效模块名的程序文件名，比如，使用下划线替换连接符）。这里展示的结构（创建一个测试套件，添加一个或多个测试用例或测试套件，运行总体的测试套件，输出结果）是典型的机遇unittest的测试。运行时，这一特定实例产生如下结果：

...

.............................................................................................................

Ran 3 tests in 0.244s

OK

<unittest._TextTestResult run=3 errors=0 failures=0>

每次执行一个测试用例时，都会输出一个句点（因此上面的输出最前面有3个句点），之后是一行连接符，再之后是测试摘要（如果有任何一个测试失败，就会有更多的输出信息）。

如果我们尝试将测试分离开（典型情况下是要测试的每个程序和模块都有一个测试用例），就不要再使用doctests,而是直接使用unittest模块的功能——尤其是我们习惯于使用JUnit方法进行测试时ounittest模块会将测试分离于代码——对大型项目（测试编写人员与开发人员可能不一致）而言，这种方法特别有用。此外，unittest单元测试编写为独立的Python模块，因此，不会像在docstring内部编写测试用例时受到兼容性和明智性的限制。

unittest模块定义了 4个关键概念。测试夹具是一个用于描述创建测试（以及用完之后将其清理）所必需的代码的术语，典型实例是创建测试所用的一个输入文件，最后删除输入文件与结果输出文件。测试套件是一组测试用例的组合。测试用例是测试的基本单元—我们很快就会看到实例。测试运行者是执行一个或多个测试套件的对象。

典型情况下，测试套件是通过创建unittest.TestCase的子类实现的，其中每个名称 以“test”开头的方法都是一个测试用例。如果我们需要完成任何创建操作，就可以在一个名为setUp()的方法中实现；类似地，对任何清理操作，也可以实现一个名为 tearDown()的方法。在测试内部，有大量可供我们使用的unittest.TestCase方法，包括 assertTrue()、assertEqual()、assertAlmostEqual()（对于测试浮点数很有用）、assertRaises() 以及更多，还包括很多对应的逆方法，比如assertFalse()、assertNotEqual()、failIfEqual()、 failUnlessEqual ()等。

unittest模块进行了很好的归档，并且提供了大量功能，但在这里我们只是通过一 个非常简单的测试套件来感受一下该模块的使用。这里将要使用的实例,该练习要求创建一个Atomic模块，该模块可以用作一 个上下文管理器，以确保或者所有改变都应用于某个列表、集合或字典，或者所有改变都不应用。作为解决方案提供的Atomic.py模块使用30行代码来实现Atomic类， 并提供了 100行左右的模块doctest。这里，我们将创建test_Atomic.py模块，并使用 unittest测试替换doctest,以便可以删除doctest。

在编写测试模块之前，我们需要思考都需要哪些测试。我们需要测试3种不同的数据类型：列表、集合与字典。对于列表，需要测试的是插入项、删除项或修改项的值。对于集合，我们必须测试向其中添加或删除一个项。对于字典，我们必须测试的是插入一个项、修改一个项的值、删除一个项。此外，还必须要测试的是在失败的情况下，不会有任何改变实际生效。

结构上看，测试不同数据类型实质上是一样的，因此，我们将只为测试列表编写测试用例，而将其他的留作练习。test_Atomic.py模块必须导入unittest模块与要进行测试的Atomic模块。

创建unittest文件时，我们通常创建的是模块而非程序。在每个模块内部，我们定义一个或多个unittest.TestCase子类。比如，test_Atomic.py模块中仅一个单独的 unittest-TestCase子类，也就是TestAtomic (稍后将对其进行讲解)，并以如下两行结束:

if name=="__main__":

unittest.main()

这两行使得该模块可以单独运行。当然，该模块也可以被导入并从其他测试程序中运行——如果这只是多个测试套件中的一个，这一点是有意义的。

如果想要从其他测试程序中运行test_Atomic.py模块，那么可以编写一个与此类似的程序。我们习惯于使用unittest模块执行doctests,比如：

import unittest

import test_Atomic

suite=unittest.TestLoader().loadTestsFromTestCase(test_Atomic.TestAtomic)

runner=unittest.TextTestRunner()

pnnt(runner.run(suite))

这里，我们已经创建了一个单独的套件，这是通过让unittest模块读取test_Atomic 模块实现的，并且使用其每一个test*()方法(本实例中是test_list_success()、test_list_fail()，稍后很快就会看到)作为测试用例。

我们现在将查看TestAtomic类的实现。对通常的子类(不包括unittest.TestCase 子类)，不怎么常见的是，没有必要实现初始化程序。在这一案例中，我们将需要建立 一个方法，但不需要清理方法，并且我们将实现两个测试用例。

def setUp(self)：

self.original_list=list(range(10))

我们已经使用了 unittest.TestCase.setUp()方法来创建单独的测试数据片段。

def test_list_succeed(self):

items=self.original_list[:]

with Atomic.Atomic(items) as atomic:

atomic.append(1999)

atomic.insert(2, -915)

del atomic[5]

atomic[4]=-782

atomic.insert(0, -9)

self.assertEqual(items,

[-9, 0, 1, -915, 2, -782, 5, 6, 7, 8, 9, 1999])

def test_list_fail(self):

items=self.original_list[:]

with self.assertRaises(AttributeError):

with Atomic.Atomic(items) as atomic:

atomic.append(1999)

atomic.insert(2, -915)

del atomic[5]

atomic[4]=-782

atomic.poop() # Typo

self.assertListEqual(items, self.original_list)

这里，我们直接在测试方法中编写了测试代码，而不需要一个内部函数，也不再使用unittest.TestCase.assertRaised()作为上下文管理器(期望代码产生AttributeError)。 最后我们也使用了 Python 3.1 的 unittest.TestCase.assertListEqual()方法。

正如我们已经看到的，Python的测试模块易于使用，并且极为有用，在我们使用 TDD的情况下更是如此。它们还有比这里展示的要多得多的大量功能与特征——比如，跳过测试的能力，这有助于理解平台差别——并且这些都有很好的文档支持。缺失的一个功能——但nose与py.test提供了——是测试发现，尽管这一特征被期望在后续的Python版本(或许与Python 3.2—起)中出现。

性能剖析（Profiling）

如果程序运行很慢，或者消耗了比预期内要多得多的内存，那么问题通常是选择的算法或数据结构不合适，或者是以低效的方式进行实现。不管问题的原因是什么， 最好的方法都是准确地找到问题发生的地方,而不只是检査代码并试图对其进行优化。 随机优化会导致引入bug,或者对程序中本来对程序整体性能并没有实际影响的部分进行提速，而这并非解释器耗费大部分时间的地方。

在深入讨论profiling之前，注意一些易于学习和使用的Python程序设计习惯是有意义的，并且对提高程序性能不无裨益。这些技术都不是特定于某个Python版本的， 而是合理的Python程序设计风格。第一，在需要只读序列时，最好使用元组而非列表； 第二，使用生成器，而不是创建大的元组和列表并在其上进行迭代处理；第三，尽量使用Python内置的数据结构 dicts、lists、tuples 而不实现自己的自定义结构，因为内置的数据结构都是经过了高度优化的；第四，从小字符串中产生大字符串时， 不要对小字符串进行连接，而是在列表中累积，最后将字符串列表结合成为一个单独的字符串；第五，也是最后一点，如果某个对象(包括函数或方法)需要多次使用属性进行访问(比如访问模块中的某个函数)，或从某个数据结构中进行访问，那么较好的做法是创建并使用一个局部变量来访问该对象，以便提供更快的访问速度。

Python标准库提供了两个特别有用的模块，可以辅助调査代码的性能问题。一个是timeit模块——该模块可用于对一小段Python代码进行计时，并可用于诸如对两个或多个特定函数或方法的性能进行比较等场合。另一个是cProfile模块，可用于profile 程序的性能——该模块对调用计数与次数进行了详细分解，以便发现性能瓶颈所在。

为了解timeit模块，我们将查看一些小实例。假定有3个函数function_a()、 function_b()、function_c(), 3个函数执行同样的计算，但分别使用不同的算法。如果将这些函数放于同一个模块中(或分别导入)，就可以使用timeit模块对其进行运行和比较。下面给出的是模块最后使用的代码：

if __name__=="__main__":

repeats=1000

for function in ("function_a", "function_b", "function_c"):

t=timeit.Timer("{0}(X, Y)".format(function),"from __main__ import {0}, X, Y".format(function))

sec=t.timeit(repeats) / repeats

print("{function}() {sec:.6f} sec".format(**locals()))

赋予timeit.Timer()构造子的第一个参数是我们想要执行并计时的代码，其形式是字符串。这里，该字符串是“function_a(X,Y)”；第二个参数是可选的，还是一个待执行的字符串，这一次是在待计时的代码之前，以便提供一些建立工作。这里，我们从 __main__ (即this)模块导入了待测试的函数，还有两个作为输入数据传入的变量(X 与Y),这两个变量在该模块中是作为全局变量提供的。我们也可以很轻易地像从其他模块中导入数据一样来进行导入操作。

调用timeit.Timer对象的timeit()方法时，首先将执行构造子的第二个参数(如果有)， 之后执行构造子的第一个参数并对其执行时间进行计时。timeit.Timer.timeit()方法的返回值是以秒计数的时间，类型是float。默认情况下，timeit()方法重复100万次，并返回所 有这些执行的总秒数，但在这一特定案例中，只需要1000次反复就可以给出有用的结果, 因此对重复计数次数进行了显式指定。在对每个函数进行计时后，使用重复次数对总数进行除法操作，就得到了平均执行时间，并在控制台中打印出函数名与执行时间。

function_a() 0.001618 sec

function_b() 0.012786 sec

function_c() 0.003248 sec

在这一实例中，function_a()显然是最快的——至少对于这里使用的输入数据而言。 在有些情况下一一比如输入数据不同会对性能产生巨大影响——可能需要使用多组输入数据对每个函数进行测试，以便覆盖有代表性的测试用例，并对总执行时间或平均执行时间进行比较。

有时监控自己的代码进行计时并不是很方便，因此timeit模块提供了一种在命令行中对代码执行时间进行计时的途径。比如，要对MyModule.py模块中的函数function_a()进行计时，可以在控制台中输入如下命令：python3 -m timeit -n 1000 -s "from MyModule import function_a, X, Y" "function_a(X, Y)"(与通常所做的一样，对 Windows 环境，我们必须使用类似于C:\Python3l\python.exe这样的内容来替换python3)。-m选项用于Python 解释器，使其可以加载指定的模块(这里是timeit),其他选项则由timeit模块进行处理。 -n选项指定了循环计数次数，-s选项指定了要建立，最后一个参数是要执行和计时的代码。命令完成后，会向控制台中打印运行结果，比如：

1000 loops, best of 3: 1.41 msec per loop

之后我们可以轻易地对其他两个函数进行计时，以便对其进行整体的比较。

cProfile模块(或者profile模块，这里统称为cProfile模块)也可以用于比较函数 与方法的性能。与只是提供原始计时的timeit模块不同的是，cProfile模块精确地展示 了有什么被调用以及每个调用耗费了多少时间。下面是用于比较与前面一样的3个函数的代码：

if __name__=="__main__":

for function in ("function_a", "function_b", "function_c"):

cProfile.run("for i in ranged 1000): {0}(X, Y)".format(function))

我们必须将重复的次数放置在要传递给cProfile.run()函数的代码内部，但不需要做任何创建，因为模块函数会使用内省来寻找需要使用的函数与变量。这里没有使用显式的print()语句，因为默认情况下，cProfile.run()函数会在控制台中打印其输出。下面给出的是所有函数的相关结果(有些无关行被省略，格式也进行了稍许调整，以便与页面适应)：

1003 function calls in 1.661 CPU seconds

ncalls tottime percall cumtime percall filename:lineno(function)

1 0.003 0.003 1.661 1.661 <string>:1 (<module>)

1000 1.658 0.002 1.658 0.002 MyModule.py:21 (function_a)

1 0.000 0.000 1.661 1.661 {built-in method exec}

5132003 function calls in 22.700 CPU seconds

ncalls tottime percall cumtime percall filename:lineno(function)

1 0.487 0.487 22.700 22.700 <string>: 1 (<module>)

1000 0.011 0.000 22.213 0.022 MyModule.py:28(function_b)

5128000 7.048 0.000 7.048 0.000 MyModule.py:29(<genexpr>)

1000 0.00 50.000 0.005 0.000 {built-in method bisectjeft}

1 0.000 0.000 22.700 22.700 {built-in method exec}

1000 0.001 0.000 0.001 0.000 {built-in method len}

1000 15.149 0.015 22.196 0.022 {built-in method sorted}

5129003 function calls in 12.987 CPU seconds

ncalls tottime percall cumtime percall filename:lineno(function)

1 0.205 0.205 12.987 12.987 <string>:l (<module>)

1000 6.472 0.006 12.782 0.013 MyModule.py:36(function_c)

5128000 6.311 0.000 6.311 0.000 MyModule.py:37(<genexpr>)

1 0.000 0.000 12.987 12.987 {built-in method exec}

ncalls ("调用的次数")列列出了对指定函数(在filename:lineno(function)中列出) 的调用次数。回想一下我们重复了 1000次调用，因此必须将这个次数记住。tottime (“总的时间”)列列出了某个函数中耗费的总时间，但是排除了函数调用的其他函数内部花费的时间。第一个percall列列出了对函数的每次调用的平均时间(tottime // ncalls)。 cumtime ("累积时间")列出了在函数中耗费的时间，并且包含了函数调用的其他函数内部花费的时间。第二个percall列列出了对函数的每次调用的平均时间，包括其调用的函数耗费的时间。

这种输出信息要比timeit模块的原始计时信息富有启发意义的多。我们立即可以发现，function_b()与function_c()使用了被调用5000次以上的生成器，使得它们的速度至少要比function_a()慢10倍以上。并且，function_b()调用了更多通常意义上的函数，包括调用内置的sorted()函数，这使得其几乎比function_c()还要慢两倍。当然,timeit() 模块提供了足够的信息来查看计时上存在的这些差别，但cProfile模块允许我们了解为什么会存在这些差别。正如timeit模块允许对代码进行计时而又不需要对其监控一样，cProfile模块也可以做到这一点。然而，从命令行使用cProfile模块时，我们不能精确地指定要执行的 是什么——而只是执行给定的程序或模块，并报告所有这些的计时结果。需要使用的 命令行是python3 -m cProfile programOrModule.py,产生的输出信息与前面看到的一 样，下面给出的是输出信息样例，格式上进行了一些调整，并忽略了大多数行：

10272458 function calls (10272457 primitive calls) in 37.718 CPU secs

ncalls tottime percall cumtime percall filename:lineno(function)

10.000 0.000 37.718 37.718 <string>:1 (<module>)

10.719 0.719 37.717 37.717 <string>:12(<module>)

1000 1.569 0.002 1.569 0.002 <string>:20(function_a)

1000 0.011 0.000 22.560 0.023 <string>:27(function_b)

5128000 7.078 0.000 7.078 0.000 <string>:28(<genexpr>)

1000 6.510 0.007 12.825 0.013 <string>:35(function_c)

5128000 6.316 0.000 6.316 0.000 <string>:36(<genexpr>)

在cProfile术语学中，原始调用指的就是非递归的函数调用。

以这种方式使用cProfile模块对于识别值得进一步研究的区域是有用的。比如，这里 我们可以清晰地看到function_b()需要耗费更长的时间，但是我们怎样获取进一步的详细资料？我们可以使用cProfile.run("function_b()")来替换对function_b()的调用。或者可以保存完全的profile数据并使用pstats模块对其进行分析。要保存profile,就必须对命令行进行稍许修改:python3 -m cProfile -o profileDataFile programOrModule.py。 之后可以对 profile 数据进行分析，比如启动IDLE,导入pstats模块，赋予其已保存的profileDataFile,或者也可以在控制台中交互式地使用pstats。

下面给出的是一个非常短的控制台会话实例，为使其适合页面展示，进行了适当调整，我们自己的输入则以粗体展示：

$ python3 -m cProfile -o profile.dat MyModule.py

$ python3 -m pstats

Welcome to the profile statistics browser.

% read profile.dat

profile.dat% callers function_b

Random listing order was used

List reduced from 44 to 1 due to restriction <'function_b‘>

Function was called by...

ncalls tottime cumtime

<string>:27(function_b) <- 1000 0.011 22.251 <string>:12(<module>)

profile.dat% callees function_b

Random listing order was used

List reduced from 44 to 1 due to restriction <'function_b'>

Function called...

ncalls tottime cumtime

<string>:27(function_b)->

1000 0.005 0.005 built-in method bisectJeft

1000 0.001 0.001 built-in method len

1000 1 5.297 22.234 built-in method sorted

profile.dat% quit

输入help可以获取命令列表，help后面跟随命令名可以获取该命令的更多信息。比如, help stats将列出可以赋予stats命令的参数。还有其他一些可用的工具，可以提供profile数据的图形化展示形式，比如 RunSnakeRun (www.vrplumber.com/prograinming/runsnakerun), 该工具需要依赖于wxPython GUI库。

使用timeit与cProfile模块，我们可以识别出我们自己代码中哪些区域会耗费超过预期的时间；使用cProfile模块，还可以准确算岀时间消耗在哪里。

以上内容部分摘自视频课程05后端编程Python-19调试、测试和性能调优(下)，更多实操示例请参照视频讲解。跟着张员外讲编程，学习更轻松，不花钱还能学习真本领。