版本修订记录

这个版本修订记录从版本 64 开始记录是因为这本小书之前的版本都是以 PDF 的形式编写和发布的。从版本 64 开始，这本小书将开始以线上书籍的方式编写和发布，以提高更新速度。

版本 64

• 改版以 MDBook 形式编写和发布。
• 增加 Python 3.10 中新增的match语句介绍。

简介

Python 是一种解释型高级语言，诞生于 20 世纪 90 年代。与 Java、C++等语言不同，Python 在运行时不需要编译，而是采用解释执行的方式运行。Python 在设计上坚持了清晰划一的风格，这让 Python 成为了一门易读、易维护的语言，Python 的设计者秉着对于一个特定的问题，只有一种最好的方法来解决的指导思想，使得 Python 的编程习惯和处理问题的思维方式在团队内部可以达到高度统一，这也是 Python 相比其他语言的一个优势之一。

Python 有两个版本：Python 2 与 Python 3，这两个版本之间不能相互兼容。截止到成稿时 Python 2 的最新版本是 2.7.5，Python 3 的最新版本是 3.11.0。造成这一不兼容现象的原因是 Python 3 在设计之初，就是为了不从 Python 2 带入过多的累赘。

在 Python 3 已经发展到 3.11.0 版的现在，大部分常用的 Python 库都已经完成了对 Python 3 的兼容，所以在系统中可以摒弃 Python 2 版本，专注使用 Python 3 版本完成系统开发了。

Python 作为一门解释型语言，虽然执行速度较 Java、C++等编译型语言要慢，但是其书写简单且功能强大，是编译型语言无法比拟的。自从大数据以及人工智能的兴起，Python 更是因为一些著名的项目框架越发频繁的出现在了人们面前。与 PHP、Javascript 等解释型语言不同，Python 更适合计算密集型的任务，而作为著名的“胶水语言”，Python 可以十分简便的使用 C++、Java 等语言的库，这也更加加强了 Python 本就十分强大的功能。

相对于 PHP 等网页开发语言，Python 不仅能够适用于网站开发，还可以胜任桌面应用开发、自动化脚本、复杂计算系统、科学计算、生命支持管理系统、物联网、游戏、机器人、自然语言处理等多种方面。可以说是一个功能十分全面的多面手。并且自 2018 年 3 月开始，全国计算机等级考试（NCRE）将 Python 列入了 2018 版考试大纲，Python 正式成为程序设计科目可选语言之一；并且在多地的信息技术教材中，都将 Python 列入了进来。这些国家层面的政策都大大增强了 Python 的普及程度，也为这一门古老而常青的语言注入了更多的活力。

如果你所计划开发的项目属于请求密集型的项目，那么可能 Python 并不适合你的需求，对于请求密集型的项目，Javascript 会处理的更加的心应手。但是如果你的项目中充满了统计、分析、数据检索、数据计算这类计算密集型的任务，那么 Python 就再合适不过了。当然，如果你硬要将 Python 应用于请求密集型的任务中，你可能也会发现，在 Nginx 等 HTTP 服务的辅助下，Python 的性能也不会差到哪里去。

本指南面向的读者需要一定的编程基础，并且使用了一些与其他常用语言的对比，所以如果读者有其他语言的使用经验，Python 会更加容易上手。

环境搭建

Python 是一种跨平台的语言，其解释器在 Windows、macOS、Linux、OS/2 甚至 Java 和.Net 虚拟机上都有相应的实现。

这里阐述两种 Python 的安装方式：安装包安装和软件管理器安装。

安装包安装

安装包是最简单的 Python 安装方式，Python 对于大部分常用系统都提供了可以直接下载的安装包供下载，尤其是对于 Linux 系统，也不必从源码自行编译安装了。

Python 安装包可以从Python Download上根据自己的系统选择相应的安装包下载。安装包一般都是可执行的，下载之后只需要运行即可。

对于 Windows 系统，一般 Python 会默认安装到C:\Python3目录下，这个可以不做特别的修改，如果更换到了其他的目录中，需要检查系统环境变量PATH中是否包含了 Python3 可执行文件python.exe和pythonw.exe所在的目录。

使用软件管理器安装

使用安装包安装 Python 虽然简单，但是在升级 Python 版本时就会显得繁琐，由于不确定是否可以覆盖安装，但又担心完全卸载后安装新版本会导致之前项目中所以来的库丢失，就会出现既纠结又尴尬的局面。

软件管理器的出现，大大方便了 Python 这类软件的安装和更新的操作。而主流操作系统中都有相应的软件管理器可供使用。

Chocolately

Chocolately 是 Windows 系统中的软件管理器，但是它并不是微软开发的，所以并不附在 Windows 发行版中。要使用 Chocolately，需要有一点 PowerShell 的基础，而 Chocolately 的安装也是通过 PowerShell 完成的。

本教程中不再详细叙述 Chocolately 的安装，对于 Chocolately 的安装和使用将简单的一带而过。如果对 Chocolately 不熟悉，可以先按照本教程给出的命令完成 Python 3 的安装。

Chocolately 只能按照官网给定的安装方法安装，这种安装方法实际上是运行官网上的一个 PowerShell 安装脚本。在 PowerShell 下可以通过以下命令来完成 Chocolately 的安装。

# 设定允许执行远程脚本
Set-ExecutionPolicyBypass-ScopeProcess-Force
# 下载并执行安装脚本
iex((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

在完成 Chocolately 的安装之后，可以使用以下命令来完成 Python 的安装：choco install python3。如果需要对通过 Chocolately 安装的 Python 进行升级，则可以执行以下命令：choco upgrade python3。

Homebrew

Homebrew 是 macOS 中的软件管理器，同样不附在 macOS 发行版中。要使用 Homebrew，也同样需要在终端中进行安装。在 macOS 中安装 Homebrew 并不是一件复杂的事情，因为 Homebrew 与 Chocolately 一样，也是通过远程安装脚本完成安装的。

打开终端后，可以运行以下命令完成 Homebrew 的安装。

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

使用 Homebrew 安装 Python3 就简单多了，只需要在终端中执行命令：brew install python3。同样的，升级系统中已经通过 Homebrew 安装的 Python3 也只需要换个命令：brew upgrade python3。

apt-get

Linux 系统中的软件管理器都是附在 Linux 发行版中的，不同的发行版所使用的软件管理器都不相同，这需要根据所使用的 Linux 发行版来确定软件管理器的命令。这里以 Debian 和 Ubuntu 中所使用的apt-get命令为例。

安装 Python3 的命令为：sudo apt-get install python3，升级 Python3 的命令为：sudo apt-get update python3。

使用 Anaconda 发行版

Anaconda 是一个开源的 Python 发行版本，其中集成了用于科学计算用的大部分库，可以让用户以最快的速度投入 Python 的开发和部署中，是一个十分值得选择的发行版。Anaconda 可以在Anaconda Download下载。Anaconda 基本上都是使用可执行安装文件进行安装，安装完成后会集成 Anaconda 的专有辅助管理工具。

此外，Anaconda 还提供了一个用于 Visual Studio Code 编辑器的插件，可以使 Visual Studio Code 能够对 Python 支持的更好。

Anaconda 的安装和使用十分简单，这里不再赘述。对于 Anaconda 所使用的 Conda 环境管理器，后文将做简要的说明。

基础的基础

在开始 Python 的学习之前，还有一些比语言基础知识更加基础的 Python 常识需要了解。了解这些内容可以使 Python 的编程过程更加顺畅，阅读他人的代码也会更加省时省力。

本教程将主要从项目组织形式、功能库的安装、变量命名习惯等方面来介绍这些基础常识。

变量命名

在编程界对于变量的命名主要分为两大阵营：下划线阵营与驼峰法阵营。Python 诞生于 C/C++称雄的年代，自然继承了众多下划线阵营的习惯。这在阅读 Python 标准库以及普遍使用的库时，经常会看到采用下划线分割的变量及函数名称（snake_case），例如：calculate_the_max_prime_number。但是随着时代的发展，驼峰法命名变量显然更加便捷，于是有相当数量的库开始采用驼峰命名法（camelCase），例如：calculateTheMaxPrimeNumber。

这就让 Python 有些尴尬，我们书写的代码中会出现两种命名方法混合使用的情况。但是这并不影响 Python 的使用，我们在自己的代码中只要按照约定规则进行命名即可。

在本教程中，推荐采用 PEP8 约定的命名方法，关于 PEP8 的概要内容，后文将会介绍。

此外，下划线在 Python 中还有特殊的用途：标记特殊变量。后文中会介绍到，Python 中没有私有字段，私有字段是靠约定形成的访问规则，而这个规则则是使用下划线标记字段。而由双下划线包围的变量，例如：__main__，则是 Python 提供的内部变量，用于提供代码访问脚本属性的能力。这些内容都将在后文中一一提到。

PEP

在使用 Python 的时候，经常会看到 PEP 的字样，例如后文提到的 PEP8。PEP 的全称是 Python Enhancement Proposals，即 Python 增强建议书。每一个 PEP 是一份为 Python 社区提供各种增强功能的技术规范，也是提交新特性，精确化技术文档的提案。

PEP 即是新特性提案，也是 Python 中标准化的内容，其中规定了 Python 代码与特性应该遵循的规范和协议。当然，PEP 中也包含了相应的技术文档，如果 Python 中某个库不知道怎样使用，可以参考这个库相应的 PEP 文档。

解释器

Python 既然是一门解释型语言，自然与编译型语言不同。编译型语言需要经过编译器编译成为二进制文件或者字节码文件后才能由计算机执行。而解释型语言一般是由解释器实时将代码转译交由计算机执行的。从这个流程上也可以看出，解释型的语言在运行效率上的确是要比编译型语言慢。但是解释型语言一般都是比编译型语言高一个层级的存在，所以往往拥有更强的扩展能力，并且更加自由，这也是为什么解释型语言更多是以脚本语言的形式出现。

既然是解释型语言，那么 Python 必然具备运行代码所必须的解释器。Python 的解释器是两个可执行文件，Windows 中为 python.exe 和 pythonw.exe，Linux 和 macOS 中都为 python 和 pythonw（可能部分可执行文件带有版本标记）。其中名称为 python 的可执行文件为命令行解释器，也就是通常所说的运行时会出现黑界面的解释器；而 pythonw 则是没有黑界面的解释器。

一般情况下，只有运行 GUI 应用时，才使用 pythonw 解释器；大部分脚本都是使用 python 解释器运行的。

交互式运行

直接在命令行中运行不带有任何参数的 python 命令，可以进入交互式运行模式。在这个模式下，python 可以立刻执行输入的任何语句。

在交互式运行模式下，执行语句exit()可以退出。

命令行脚本

将代码保存在后缀为.py的文件中，使用python file.py的命令运行保存的代码文件，就是最常用的脚本执行方法。

如果运行的是一个完整的项目，那么python命令后指示运行的代码文件，需要是项目的入口文件。

bash 脚本

对于 Linux 以及 macOS 系统来说，bash 脚本是一种特殊的脚本，其可以使用任何解释型语言编写，Python 也不例外。bash 脚本的执行不需要使用python <filename>的格式，而且 bash 脚本的文件名后缀一般为.sh，并且使用chmod +x赋予可执行属性。bash 脚本在终端中可以直接使用./bash.sh的方式执行。

bash 脚本与 Python 源代码文件的区别，就是在文件的最开头，声明了用于解释执行 bash 脚本的解释器。使用 Python 书写 bash 脚本，脚本的首行声明如下：

#!/usr/local/bin/python3

或者还可以使用下面这种标注，下面这种标注会通过环境变量寻找 Python3 解释器的位置。

#!/usr/bin/env python3

其他 Linux 发行版中安装 Python 之后，在书写 bash 脚本之前，需要自行寻找一下解释器所在的位置以及确定一下解释器的版本，以防运行出错。

项目文件组织形式

Python 项目主要通过包和模块来组织其代码，一般可以按照功能对代码进行分组形成模块和包。

既然是一个完整的项目，那么仅有包和模块提供功能是不够的，还需要在项目根目录下提供一个项目入口文件，供解释器加载。

模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是`.py}。模块可以被别的程序引入以使用该模块中函数等功能。这也是 Python 功能库的组成方法。

模块中除了可以包含方法定义以外，还可以包含可执行的代码，用于在第一次导入时初始化模块使用。每个模块都有独立的符号表，在模块内部为所有的函数当作全局符号来使用，所以在模块内部可以放心大胆的使用这些全局变量。

在阅读其他作者书写的模块时，常常会在模块的结尾看到以下格式的代码段。

if __name__ == '__main__':
    pass

这是利用__name__属性来判断模块是独立运行还是被另一个程序引入执行。具体可以参考以下示例。

if __name__ == '__main__':
    print('程序独立运行')
else:
    print('来自另一个模块')

利用这项功能，可以为模块的不同运行模式进行不同的初始化工作。

包

包是管理 Python 模块命名空间的形式，采用package.module（点模块名称）的格式。比如一个模块的名称是A.B，则表示包 A 中的子模块 B。

使用点模块名称的好处是不用担心不同库之间的模块重名的情况。

包在文件系统中，就是一个普通的目录，其中需要放置一个__init__.py文件作为包的标记，并且其中可以放置包的初始化代码，在一般情况下，只需要放置一个空白的__init__.py即可。并且包中可以有子包存在，例如下面的包结构。

father_package/
    __init__.py
    father_module.py
    father_module_another.py
    child_package/
        __init__.py
        child_module.py
        child_module_another.py

这里的示例在后文中还会使用。

在导入一个包的时候，实际上是导入了它的__init__.py文件，所以可以在__init__.py中批量导入需要的模块，而不用再次一一导入。此外，__init__.py中还有一个重要的变量：__all__，它接受一个字符串列表作为它的值，凡是出现在其中的内容，都会在使用from ... import *导入时被全部导入，所有没有列入__all__的不会被导入。但是__all__不会影响明确列明要导入内容的模块，例如上例中的import father_package.father_module。

文件编码

Python2 是不支持 UTF-8 格式的源代码文件的，所有出现和使用 UTF-8 内容的位置都需要采用转义的方式表示。在 Python3 中这一情况有了极大的改观，因为 Python3 默认采用 UTF-8 作为源代码的编码格式。

如果需要使用其他的编码格式保存源代码文件，需要在源代码文件首行使用以下格式的标记来声明要使用的编码格式。

# -*- coding: gbk -*-

代码格式

Python 有一套详细而具体的编码规范可供参考和遵循，具体见后文对于 PEP8 的阐述。这里只针对一般常用的基本代码格式做一个介绍。

标识符

第一个字符必须是字母或者下划线，其他字符可以由字母、数字和下划线组成。Python 的标识符是大小写敏感的。

注释

有单行注释和多行注释两种类型。其中单行注释以#开头，而多行注释既可以以#开头，也可以直接使用"""三引号字符串。

缩进

这是 Python 的一大特色。Python 不使用大括号来表示代码块，而是使用缩进来表示代码块。相同的缩进数量表示一个代码块。如果缩进的空格数不一致，并且没有新代码块的引导语句，那么 Python 将会报错。这一点需要在日常的练习和编码中多加体会。

语句 Python 的语句不使用分号等任何符号结尾，每行中建议仅书写一条语句。如果需要书写多条语句，那么语句之间需要使用分号隔开。如果语句过长需要分行书写，可以在每行的末尾使用反斜线进行分行标记。

功能库

Python 的生命力大部分来自其众多的第三方功能库。这些功能库为 Python 提供了丰富而全面的功能。这些功能库可以使用 Python 自带的包管理工具 PIP 来进行管理。已经安装到 Python 的功能库可以直接导入到脚本中使用。

Python 并不提倡「重复制造轮子」的行为，如果有可以使用的第三方功能库，建议在项目中优先使用，自行编写功能库和「造轮子」是最后的选择。

PIP

PIP 是一个现代的通用的 Python 包管理工具，现在会随着 Python 的发布版本自动安装，提供了对 Python 包的查找、下载、安装和卸载等功能。PIP 在命令行中运行，常用的指令有以下这些。

• pip install SomePackage，安装指定的包。
• pip show SomePackage，查看相关包的信息。
• pip list}`，查看已经安装的包。
• pip list --outdated，列出目前存在更新的包。
• pip install --upgrade SomePackage，更新指定的包。
• pip search keyword，搜索包。
• pip uninstall SomePackage，卸载指定的包。

在 Python2 和 Python3 共存的机器上，可以通过python3 -m pip <参数>的命令格式来执行 Python2 或者 Python3 中携带的 PIP。

如果 PIP 安装功能库缓慢，可以使用以下指令来设置 PIP 使用清华大学的安装源。

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

或者参考后文中的 pipenv 中提到的其他 Pypi 的源。

Conda

Conda 是一个随着 Anaconda 发行版发布的环境管理工具，与 PIP 一样提供了 Python 包的查找、下载、安装等功能，但是不同的是，Conda 的功能主要是偏向于环境管理功能，所以其可以直接在系统中创建和管理虚拟 Python 环境。不同的虚拟 Python 环境可以共存，并通过 Conda 进行激活和切换。Conda 常用的命令有以下这些。

• conda create --name 环境名称 [库名称=版本,...]，创建一个带有指定 Python 版本和库的环境。例如conda create --name py35 python=3.5}`将会创建一个使用 Python 3.5 版本解释器的虚拟环境。
• conda env remove --name 环境名称，删除指定虚拟环境。
• activate 环境名称，激活指定虚拟环境，macOS 和 Linux 使用source activate 环境名称。
• deactivate，关闭当前虚拟环境，macOS 和 Linux 使用source deactivate。
• conda install 库名称[=版本]，向当前环境中安装指定库，并可以指定库版本。
• conda remove 库名称，从当前环境中移除指定库，注意与删除环境的区别。
• conda update 库名称，升级当前环境中的指定库，可以用于升级 Conda 自身。
• conda search 库名称，搜索指定库。
• conda list，列出当前环境中安装的全部库。
• conda env list，列出当前已经创建的环境。
• conda env export > 文件名，将当前环境的配置导出到 YAML 文件中以方便共享。
• conda env create -f 文件名，从导出的 YAML 文件中创建虚拟环境。

Conda 的命令和功能远不止以上这些，具体其他的命令和功能可以在使用时查询文档。

在 macOS 和 Linux 中，Conda 可以直接在终端环境中使用。在 Windows 系统中需要在 Anaconda 安装的「Anaconda Prompt」程序中使用，当然如果你喜欢在命令行中使用也是可以的。

Anaconda 默认的软件包源中，可能包含的内容不足，并且访问速度较慢，这时我们可以使用以下命令来让 Conda 使用清华大学的源。

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --set show_channel_urls yes

# 以下是清华大学维护的第三方源

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/msys2/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/bioconda/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/menpo/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/peterjc123/

加载到源文件

要使用功能库与模块，需要在另一个 Python 源文件中执行import语句，当解释器遇到 import 语句时，就会在当前的全部搜索路径中进行搜索并导入。解释器会优先搜索当前项目的路径，之后是所有库目录的列表。Python 的搜索路径保存在 sys 模块的 path 变量中，可以在交互式解释器中查看。

一个模块只会被导入一次，这可以防止模块被一遍又一遍的执行以及递归导入的出现。

import module

这是最普通的导入语句了。它会将目标模块内容导入到当前脚本中，但是如果需要访问其中的内容，需要使用\lstinline|module.function|的全名模式，因为其不会对当前的命名空间作出任何修改，只是加载了一个新的命名空间供使用而已。例如：

import sys
print(sys.path)

from module import ...

与import module不同，这条导入语句可以将指定模块的一个指定部分导入到当前的命名空间中。这里用一个示例来说明。

假如有这样一个模块：

# fibo.py

def fib(n):
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
        print()

使用import module的格式来使用这个函数的方法如下：

import fibo

fibo.fib(1000)

但是如果使用from module import ...的格式来使用这个函数的方法则是：

from fibo import fib

fib(1000)

仔细对比函数的调用，就会理解from module import ...是如何工作的。

from module import *

这个引入操作更加容易理解，它将把指定模块中的全部内容都导入到当前的命名空间中。这个导入语句并不建议使用，因为这种导入非常容易造成命名空间中成员重名的情况。

前面提到了，模块可以使用包来组织，那么对于之前的示例使用from father_package import *会出现什么情况？如果在__init__.py中没有定义任何内容，这条引入语句是不会引入任何内容的。这是因为在包是依赖文件系统来组织模块的，Python 不能保证每个平台（尤其是 Windows）上模块的名称都是唯一的，比如 Windows 是不区分大小写的，DOS 对大于 8 个字符的文件名称有特殊处理，Linux 是区分大小写的。

这就需要在__init__.py中使用__all__来定义一个精确的列表，用来指示哪些模块是可以被导入的。当然，如果不使用from package import *的方式引入库，也是不必要去定义__init__.py的内容的。

Pythonic

只要使用 Python，总会接触到 Pythonic 这个词语。但是 Pythonic 又是一个非常难于定义的东西。一般说来，Pythonic 是指那些极具 Python 特色的 Python 代码，这些代码会明显区别于其他语言的写法。

这里先引用《Python 之禅》中的经典阐释：

• 优美胜于丑陋；
• 明了胜于晦涩；
• 简洁胜于复杂；
• 复杂胜于凌乱；
• 扁平胜于嵌套；
• 间隔胜于紧凑;
• 可读性很重要。

Pythonic 追求的是对 Python 语法的充分发挥，而不是与其他语言相似。如何让代码书写的更加 Pythonic 需要在日常不断的进行积累，并且要对 Python 的语法深入了解，还要有一定的想象力。

后文会在可以 Pythonic 的位置进行抛砖引玉的示例说明。

PEP8：Python 编码规范

代码编排

1. 缩进采用 4 个空格，不使用 Tab 进行缩进，不能混合使用 Tab 和空格，可以利用 IDE 将 Tab 转换为 4 个空格。
2. 每行最大长度为 79 字符，包含缩进空格。需要换行可以使用\，最好使用圆括号，圆括号内的内容换行不需要反斜线。换行回车要在操作符后面出现，即操作符不能在一行中打头。
3. 类和 top-level 函数定义、全局变量定义之间空两行书写；类中方法定义之间空一行书写；函数内逻辑无关段落之间空一行；其他位置尽量不要空行。

文档编排

1. 模块中内容的顺序为：
   1. 模块说明和 docstring；
   2. import，库的引用按照标准库、第三方库和自编库的顺序依次排放，三者之间空一行；
   3. 全局变量（globals）与常量（constants）；
   4. 其他定义。
2. 不要在一条 import 中引用多个库。
3. 如果采用from package.module import xx方式引用库，可以省略 module；如果产生命名冲突需要明确采用import module。

例如：

"""This is the example.

The docstring stuff
"""
from __future__ import barry_as_FLUFL

__all__ = ['a', 'b', 'c']
__version__ = '0.1'
__author__ = 'FarDawn'

import os
import sys

空格的使用

1. 所有右括号前不要加空格。
2. 逗号、冒号、分号前不要加空格。
3. 函数的左括号前不要加空格。
4. 序列的左括号前不要加空格。
5. 操作符的左右各加一个空格，不要为了对齐添加额外的空格。
6. 函数默认参数使用赋值符左右不添加空格。
7. 不要在一行内写入多条语句。
8. if/for/while 语句中，即便语句块中只有一条语句，也必须另起一行书写。

注释

1. 在代码块前增加的注释，在#后增加一个空格。
2. 尽量避免采用在语句后增加注释的行注释方式。
3. 避免无谓的注释。

文档描述

1. 所有的共有模块、函数、类、方法都应该附加 docstring；非共有的内容可不加。
2. 如果 docstring 需要换行，可以使用三引号括起的方式。

命名规范

1. 尽量单独使用小写字母i、大写字母O等易混淆字母。
2. 模块命名尽量短小，使用全部小写的方式，可以使用下划线。
3. 包命名尽量短小，使用全部小写的方式，不可以使用下划线。
4. 类的命名使用CapitalizeWord格式，模块的内部类采用_CapitalizeWord格式。
5. 异常类命名采用CapitalizeWordError格式。
6. 全局变量尽量只在模块内有效，类似 C 语言中的 static；可以采用__all__或者前缀一条下划线的方式实现。
7. 函数命名使用全部小写的方式，可以使用下划线。
8. 常量命名使用全部大写的方式，可以使用下划线。
9. 类的属性（包括方法和变量）命名使用全部小写的方式，可以使用下划线。
10. 类的属性有 3 种作用域：public、non-public 和 subclass API，可以理解为 C++ 中的 public、private、protected，在 non-public 属性前，需要前缀一条下划线。
11. 类的属性如果与关键字名称冲突，可后缀一条下划线，不要使用缩略等其他方式。
12. 为避免与子类属性命名冲突，在类的一些属性前，前缀两条下划线。
13. 类的方法第一个参数必须是 self（相当于 C++中的 this），静态方法第一个参数必须是 cls（代表类）。

编码建议

1. 代码应该兼顾 Python 的不同实现，如 CPython 中，+操作符拼合字符串的性能很好，但 Jython 中不是这样，所以应该采用''.join()来兼顾不同的 Python 实现。
2. 与单例内容进行比较时，应该采用is或者is not，例如：if x is not None。
3. is not|操作顺序要比not … is`更加直观。
4. 在进行排序和比较时，优先选择实现用于比较的六个操作：__eq__、__ne__、__lt__、__le__、__gt__、__ge__。
5. 不要用 Lambda 表达式来定义函数或者方法，始终使用def。
6. 使用基于类的异常，每个模块和包都要有自己的继承自 Exception 的异常类。
7. 异常中不要使用裸露的 except，except 后要跟具体的 Exception。
8. 异常中 try 的代码要尽可能的少。
9. 字符串不要使用空格结尾。
10. 方法中的所有 return 语句都要有返回值，如果确实不返回内容，要返回 None。
11. 尽量使用语义明确的方法替代切片操作。
12. 不要使用==对布尔值进行比较操作。

语言基础

前文说的都是一些基础中的基础，这里要开始阐述的是 Python 语言的基本元素：运算符、数据类型以及基础语句。

运算符

运算符是组成表达式的基本要素，是将标识符连接起来进行运算的主要方式。Python 中的运算符主要有算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、成员运算符和身份运算符几种。

操作符一般有两个操作数，分别称为左操作数和右操作数，个别的操作符仅能接受一个操作数。

下面将依次进行介绍。

算术运算符

算术运算符是最基本的运算符，用于各种数学计算。

比较运算符

比较运算符用于两个操作数之间的比较，比较运算符会返回关键字True或者False。实际上所有比较运算符只会返回整型数值，其中 0 对应关键字False，即假值；1 对应关键字True，即真值。

赋值运算符

Python 中的变量不需要声明，但是每个变量在使用前都必须赋值，变量赋值后该变量才会被创建。Python 中的变量没有类型，一般所说的类型是指变量所指向的内存中对象的类型。赋值运算符还可以与算术运算符组合形成快速赋值运算符。

Python 中的变量有一个非常重要的特性，就是它仅仅是一个名称，是对对象的引用，而不是存储对象本身。

Python 允许同时为多个变量赋值，例如：a = b = c = 1，这样三个变量都将指向同一个内存位置。还允许同时为多个对象指定多个变量，例如：a, b, c = 1, 2, "Hello"，这样变量 a 与 b 将分别被分配给 1 和 2，而字符串对象"Hello"将分配给 c。

对于赋值，Python 还提供了一个快速交换两个变量内容的方式，即a, b = b, a，这可以让两个变量直接交换其指向的位置，从而达到交换变量值的目的。

位运算符

位运算符是将数字作为二进制来进行计算的。位运算在一些协议处理和低级别信息处理上十分有用。

逻辑运算符

逻辑运算符与比较运算符类似，也是返回True或者False的值，但是这里需要注意的是，部分操作符还可能返回右操作数的值。

对于or操作符，可以用来获取默认值，参考以下示例：

a = 40
print(a or 30) # 输出 40
a = 0
print(a or 30) # 输出 30
a = None
print(a or 30) # 输出 30

成员操作符

成员操作符用来测试实例中是否包含指定的成员，成员操作符可以应用于字符串、列表和元组中。

身份操作符

身份操作符用于比较两个对象的存储单元。对于一个对象，可以使用id()函数来获取其内存地址，身份操作符主要是用于判断两个操作数是否引用了同一个地址的对象。

is与==的区别在于，==是用于判断引用的对象的值是否相等，而is则是判断引用的对象的内存地址是否相等。

运算符优先级

当不同的运算符组合在一起时，不同的运算符会有一个优先级的区别，相同优先级的运算符遵循自左至右的计算，而拥有高优先级的运算符则会优先计算结果。这与日常先乘除后加减的数学计算规则相似。

下表按照由高至低的顺序列出了全部运算符的优先级。

基础数据类型

Python3 中有七个标准数据类型，有如前面说过的这个数据类型并不是变量的数据类型，而是内存中存储的数据的类型，即变量指向的内存空间的类型。

这七个数据类型分别为：

• Bool，布尔
• Number，数字
• String，字符串
• List，列表
• Tuple，元组
• Sets，集合
• Dictionary，字典

这七个数据类型中，数字、字符串、元组和集合是不可变数据，列表和字典是可变数据。不可变数据在每次内容发生更改时，Python 都会将其复制一份后再进行修改。

Python 所有的数据，不仅这七种基础数据类型，甚至包括其他复杂数据结构、函数及程序，都是以对象的形式存在的。这使得 Python 从根基上就是一种面向对象的语言。并且 Python 是强类型语言，已有对象的类型是无法修改的。要获取一个对象或者一个字面值的类型，可以使用type()函数。

布尔型

布尔型值其实非常简单，只表示真与假，由两个关键字代表它的值，分别是True和False。布尔型值也是条件表达式的运算结果。

由于历史原因，布尔型值可以作为数值类型进行运算，其中True的值为 1，False的值为 0。如果将数值类型直接用于条件判断，则零值为False，非零数值为True。

数字

Python 支持三种数值类型：

• 整型（int），可以是正负整数，不带有小数点。Python3 的整数没有大小限制，可以当作 Long 类型使用。
• 浮点型（float），由整数和小数部分组成，浮点型也常用科学计数法表示。
• 复数（complex），由实数和虚数部分组成可以使用a+bj或者complex(a, b)表示。

整型数值还可以使用十六进制、八进制和二进制来表示，其中前缀0x表示十六进制数值，0o表示八进制，0b表示二进制。反过来，可以使用函数hex()、oct()、bin()来分别获得整型数值的十六进制、八进制和二进制表示。

在很多时候我们经常需要进行数字类型转换，数据类型转换只需要将数据类型作为函数名即可，例如：int(x)。复数类型转换可以接受两个参数，分别作为复数的实数部分和虚数部分。

之前运算符中的整除运算符：//，在进行计算时需要注意，如果左右操作数都是整型，那么其将会返回整型结果，如果有一个操作数是浮点型，那么就会返回浮点型结果。

浮点型数值是不精确数值，其在进行计算的时候也是不精确的，所以在使用时需要严加注意。Python 提供了多种可供精确计算带小数点的数值的库或者类，后文将拣选部分予以介绍。

分数计算

模块fractions提供了一个名为Fraction的类，用以支持分数类型及计算。Fraction 类有以下两个构造函数：

class fractions.Fraction(numerator=0, denominator=1) # numerator 为分子，denominator 为分母
class fractions.Fraction(int|float|str|Decimal|Fraction)

使用分子和分母实例化分数类时，两者需要均为 int 类型或者 numbers.Rational 类型，分母为 0 会抛出ZeroDivisionError的异常。

分数类型可以直接使用运算操作符进行计算，返回结果也为 Fraction 类型实例，但是 print()的数值则是约分化简后的字符串分数形式。

from fractions import Fraction

x = Fraction(2, 10)
y = Fraction(3, 5)
z = x + y # z 的值为 Fraction(4, 5)

print(z) # 会输出"4/5"

精确小数计算

模块decimal提供了一个Decimal数据类型用于精确小数计算，并且可以指定其计算精度。其具体使用可参考以下示例：

import decimal

decimal.getcontext().prec = 4 # 设定全局计算精度为 4 位小数

print(decimal.Decimal(1) / decimal.Decimal(7)) # 会输出"0.1429"

with decimal.loacalcontext() as ctx:
ctx.prec = 2 # 设定当前上下文计算精度为 2 位小数
print(decimal.Decimal('1.00') / decimal.Decimal('3.00')) # 输出"0.33"

数学计算

Python3 中的数学计算主要是由math模块提供的，该模块中提供了以下函数供使用。

随机数生成

随机数生成功能是由random模块提供的，该模块提供了以下常用函数供使用。

浮点数取整

round()函数是 Python 标准库提供的功能，不需要加载任何模块即可使用。该函数使用的进舍准则与日常的“四舍五入”有所不同，其进舍的处理方法采用统计学标准，使得进舍后数值变化对系统误差影响降低到最低。

round()接受两个参数，一个为待处理的数字，一个为小数保留位数，其中小数保留位数默认为 0。在进行取整时，round()会遵循以下规则。

1. 要求保留位数的后一位如果是 4 或者 4 以下的数字，则舍去，例如 4.124 保留两位小数为 4.12。
2. 要求保留位数的后一位如果是 6 或者 6 以上的数字，则进位，例如 4.126 保留两位小数为 4.13。
3. 如果保留位数的后一位是 5，并且该位数后有数字，哪怕是 0.00000000001 之类的，则进位，例如 4.1250001，保留两位小数为 4.13。
4. 如果保留位数的后一位是 5，且该位后没有数字，则根据保留位采用“奇进偶舍”的规则进行进舍，例如 3.35 保留一位小数为 3.4。

Python 的进舍规则是遵照《GB/T8170-2008 数值修约规则与极限数值的表示和判定》来进行处理的，其中对于数值修约规则，可根据以下口诀来记忆。

字符串

Python 中的字符串可以使用单引号或者双引号来创建，使用单引号和双引号创建的字符串没有区别。Python 中没有单字符类型，即便是一个字符，也是作为一个字符串使用。字符串支持使用切片来截取其子字符串，切片的使用方法可见“切片”一节。

Python 中的字符串是不可变数据，每次在进行运算时，都会产生一个新的字符串对象，如果使用id()函数去获取他们的内存地址就会发现变量的指向地址始终在变化。

字符串支持下表中的运算符进行运算。

由于 Python3 的字符串类型为str，在内存中以 Unicode 表示，一个字符对应若干个字节，所以要在网络上传输或者保存到磁盘，就需要将其转换为以字节为单位的bytes，这可以使用b在字符串前进行标记，例如：b'ABC'。中文内容不能用 ASCII 编码表示，但是可以将含有中文的str编码为bytes。

Python 中还允许使用三引号"""来包裹字符串，三引号定义的字符串可以跨多行，并且可以包含换行、制表等特殊字符。三引号字符串可以自行保持字符串的原有格式，每行的换行符以及行首、行尾的空格都会保留，使日常编程不再需要字符串组合与转义等。

使用str()可以将其他数据类型转换为字符串。在使用print()或者字符串差值是，Python 都会自动使用str()对非字符串对象进行转换。

在字符串名后面添加[]，并在括号中指定索引，可以提取指定索引位置的单个字符，字符串的索引值从 0 开始。索引值可以是负数，这代表从字符串尾端开始。如果对指定索引位置进行赋值，则会得到TypeError错误，因为字符串是不可变的。如果需要改变字符串，需要使用字符串函数或者切片来完成，这些将在后面具体提到。

字符串格式化

Python 中的字符串格式化使用与 C 语言中printf()一样的语法，其基本思路是将一个值或者数个值插入到一个有字符串格式描述符的字符串中。

例如：

print("这是来自%d 光年外%s 的信息。" % (3000, "St. Alpha"))

# 会输出“这是来自 3000 光年外 St. Alpha 的信息。”

字符串格式化通过一系列的格式化符号对要替换的内容进行标记，常用的格式化符号见下表。

格式化符号可以接受一些辅助指令的来对输出内容的格式进行详细规定。常用的辅助指令见下表。

自从 Python 2.6 版本开始，字符串提供了str.format()函数来进行增强的字符串格式化功能，调用格式为"模版字符串".format(逗号分割的参数)。调用format()方法后会返回一个全新的字符串。模版字符串中使用{}来代表参数，称为格式槽，参数从 0 开始索引，例如："进程{}的 CPU 占用率为{}%。".format("Python", 10)会输出"进程 Python 的 CPU 占用率为 10%。"。如果需要引用指定索引的参数，可以在{}中书写指定参数的索引，例如例如："进程{1}的 CPU 占用率为{0}%。".format(10, "Python")会输出"进程 Python 的 CPU 占用率为 10%。"。若要输出大括号，可以使用{{表示{，用}}表示}。

format()方法中同样可以控制参数的格式，其中格式槽的格式为{<参数序号>:<填充><对齐><宽度><,><.精度><类别>}。各个格式位的使用方法可参考下表。

例如"{0:e},{0:0.4f}".format(3.14)，读者可自行在交互式解释器中实验以下这条语句的运行结果。

自 Python 3.6 版本开始，Python 基金会通过 PEP 498 – Literal String Interpolation 引入了格式化字符常量来产生一个格式化后的字符串，因为这种用法是采用f""的字符串标记形式，所以又称为“f-string”。f-string 的功能与之前介绍的使用“%”进行格式化和使用str.format()进行格式化的功能基本相同，但具有更好的性能，所以如果要使用 Python 3.6 以后的版本，推荐使用 f-string 来进行字符串格式化。

f-string 在字符串中使用{}来直接填入替换内容，并且其中支持表达式和函数调用。最简单的使用方法可见一下示例。

number = 7
print(f"Total number is {number}")

print(f"Calculate result is {(2 + 4j) / (2 - 3j)}")

name = "ERIC"
print(f"The lowercase version is {name.lower()}")

f-string 在使用时也是有一些限制要求的，主要集中在符号的使用上，限制条件主要有以下几个。

1. 大括号内所使用的引号不能与大括号外的字符串定界符冲突，例如|f“{“ERIC”}“|是错误的。
2. 如果单引号和双引号不能满足要求，可以使用三引号来定义字符串，例如|f““”{“Eric”}“”“|。
3. 大括号外的引号可以使用||进行转义，但大括号内不可以。
4. 如果在大括号外要显示大括号，需要使用|{{|和|}}|的形式。

f-string 也支持格式描述，其使用格式为{内容:格式}，例如f"{number:8.2f}"。f-string 的格式描述符格式与str.format()基本相同，但是其更扩展支持了 datetime 库中用于格式化时间的描述符，具体内容可在使用时参考 datetime 库文档。

内建函数

对于字符串操作，Python 提供了以下常用函数。

• capitalize()，将字符串第一个字符转换位大写。
• center(width, fillchar)，返回一个指定宽度为 width 并居中的字符串，字符串两端使用 fillchar 填充，默认使用空格。
• count(str, begin=0, end=len(string))，返回 str 在字符串中出现的次数，其中 begin 和 end 用于指定进行统计的字符串范围。
• bytes.decode(encoding='utf-8', errors='strict')，Python3 中的字符串没有 decode 方法，所以需要使用bytes模块中的decode()方法来解码 bytes 对象。
• encode(encoding='UF-8', errors='strict')，以指定编码格式编码字符串，如果出错则报ValueError的异常，除非errors的值为'ignore'或者'replace'。
• endswith(suffix, begin=0, end=len(string))，检查字符串是否以suffix结束，如果指定begin和end的值，则检查指定范围。返回布尔型值。
• expandtabs(tabsize=8)，将字符串中的 tab 符号转换为空格，默认一个 tab 转换为 8 个空格。
• find(str, begin=0, end=len(string))，检查str是否包含在字符串中，如果指定begin和end的值，则检查指定范围。返回布尔型值。
• index(str, begin=0, end=len(string))，获取str在字符串中的索引位置，如果字符串中不存在str则报异常。
• isalnum()，如果字符串至少有一个字符且全部都是字符或者数字，返回True。
• isaloha()，如果字符串至少有一个字符且全部都是字符，返回True。
• isdigit()，如果字符串至少有一个字符且全部都是数字，返回True。
• islower()，如果字符串中包含至少一个区分大小写的字符，且全部都是小写，返回True。
• isnumeric()，如果字符串只包含数字字符，返回True。
• isspace()，如果字符串只包含空白，返回True。
• istitle()，如果字符串是标题化的，返回True。
• isupper()，如果字符串中包含至少一个区分大小写的字符，且全部都是大写，返回True。
• join(seq)，以指定字符串为分隔符，将seq中的所有元素合并为一个新的字符串。
• len(string)，返回字符串长度。
• ljust(width[, fillchar])，返回一个宽度为width的字符串，原字符串在新字符串中左对齐，右侧用fillchar填充。
• lower()，将所有字符转为小写。
• lstrip()，截掉字符串左边的空格或者指定字符。
• maketrans()，创建字符映射的转换表。
• max(str)，返回字符串str中最大的字母。
• min(str)，返回字符串str中最小的字母。
• replace(old, new[, max])，将字符串中的old替换成new，替换不超过max次。
• rfind(str, begin=0, end=len(string))，从右侧查找。
• rindex(str, begin=0, end=len(string))，从右侧获取索引。
• rjust(width[, fillchar])，返回一个宽度为width的字符串，原字符串在新字符串中右对齐，左侧用fillchar填充。
• rstrip()，删除字符串末尾的空格。
• split(str='', num=string.count(str))，以str为分隔符截取字符串，截取num个子字符串。
• splitlines([keepends])，按照'\r'、'\r\n'、'\n'为分割，返回包含各行作为元素的列表。如果keepends为False则不包含换行符。
• startswith(prefix, begin=0, end=len(string))，检查字符串是否以prefix结束，如果指定begin和end的值，则检查指定范围。返回布尔型值。
• strip([chars])，在字符串上执行lstrip()和rstrip()。
• swapcase()，将字符串中的大小写反转。
• title()，返回标题化字符串，即每个单词都是大写开始，其余字母均为小写。
• translate(table, deletechars='')，根据table给出的表，转换字符串，要过滤掉deletechars中的字符。
• upper()，转换字符串中的字母为大写。
• zfill(width)，返回长度为width的字符串，原字符串右对齐，左侧填充 0。
• isdecimal()，检查字符串中是否只包含十进制字符。

列表

序列是 Python 中最基本的数据结构，序列中每一个元素都会被分配一个用于表示其位置的数字，即索引。序列的索引从 0 开始。Python 中有 6 个序列类型，常用的是列表和元组。所有序列类型都可以进行索引、切片、加、乘和成员检查的操作。

列表是最常用的数据类型，通常使用在方括号中使用逗号分割值的形式定义，列表的数据项不需要有相同的数据类型。空列表可以使用[]，或者list()函数来创建。

list1 = ['a', 'b', 'c']
list2 = [1, 2, 3, 4, 5]
list3 = ['a', 'b', 'c', 1, 2, 3]
list4 = list()
list5 = []

列表使用索引来访问相应的元素，并且可以对元素进行修改。要删除列表元素需要使用del语句。例如：

list1 = [1, 2, 3, 4, 5]
print(list1[2]) # 输出 3
list1[2] = 9
print(list1) # 输出[1, 2, 9, 4, 5]
del list1[3]
print(list1) # 输出[1, 2, 9, 5]

在使用索引访问列表元素时需注意超范围访问，即下标越界，此时 Python 会抛出IndexError。列表可以嵌套来定义多维列表，例如：[[1, 2, 3], ['a', 'b', 'c']]。

列表操作

使用+可以拼接组合两个列表，*可以将列表的内容重复指定次数，in可以用来判断元素是否存在于列表中，搭配for可以用来进行列表内容的迭代。

使用for来进行列表迭代的时候，默认是直接迭代列表中的值，如果需要获取元素的索引，则需要使用enumerate()函数来辅助，该函数是一个生成器，每次会返回一个元组，其中第一个元素为索引值，第二个元素为索引对应的值，使用格式一般为for index, element in enumerate(list)。

对于列表，Python 提供了以下函数和方法。

• len(list)，返回列表元素个数。
• max(list)，返回列表中元素的最大值。
• min(list)，返回列表中元素最小值。
• list(tuple)，将元组转换为列表。
• list.append(obj)，将obj添加到列表末尾。
• list.count(obj)，统计列表中obj出现的次数。
• list.extend(seq)，在列表末尾追加另一个列表中的元素。
• list.index(obj)，返回obj在列表中的索引。
• list.insert(index, obj)，将obj插入到列表的指定索引位置。
• list.pop(index=-1)，移除列表中指定索引的元素，默认最后一个元素，并返回其值。
• list.remove(obj)，移除列表中obj的第一个匹配项。
• list.reverse()，返回反转后的列表。
• list.sort(cmp=None, key=None, reverse=False)，对原列表进行排序。
• list.clear()，清空列表。
• list.copy()，复制列表。

切片

切片是 Python 中强大功能之一，常用于操作序列和字符串。切片与序列和字符串的索引访问类似，都是使用方括号，但格式不同。切片可以包含三个数字，完整格式为：[起始索引:结束索引:步进]。这三个数字可正可负，分别表示不同的含义。切片中的这三个数字有些时候可以省略，但起始索引和结束索引之间的冒号不可以省略。

列表与字符串中每个元素都对应一正一负两个索引值，其中正值索引是从左向右的索引，负值索引是从右向左的索引。所以切片中步进值为正表示从左向右截取，负值则表示从右向左截取。

切片应用于列表，其返回结果也还是列表；应用于字符串，其返回结果依旧是字符串。

以下通过一些示例，来说明不同切片值的含义。假设有一个列表a = [1, 2, 3, 4, 5, 6, 7]，就可以有以下操作。

• a[:]，返回完整列表内容。
• a[4:]，返回索引从 4 开始以后的全部数据，即[5, 6, 7]。
• a[:3]，返回索引$[0,3)$的元素组成的集合，即[1, 2, 3]。
• a[:-5]，返回 0 到从右数第五个元素，即[1, 2]。
• a[:5:2]，以步进 2 返回 0 到 5 的元素，即返回索引 0、2、4，即[1, 3, 5]。
• a[:4:-1]，步进为负值，从右侧开始取到索引 4 的前一个元素位置，即[7, 6]。
• a[:10]，返回索引$[0, 10)$的的全部数据，超过实际索引后也不会报错。
• a[::-1]，返回逆序列表，即[7, 6, 5, 4, 3, 2, 1]。

任何情况下都需要记住，结束索引始终不会包含在切片中。对切片进行操作，会改变列表的结构和值。下面通过几个示例来演示对切片赋值的操作结果。

list = ['a', 'b', 'c', 'd', 'e', 'f']
list[len(list):] = ['g', 'h'] # 将指定列表添加到原列表的末尾，操作完后的 list 是['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
list[1:4] = [1, 2] # 用指定列表替换原列表中切片部分，操作完成后的 list 是['a', 1, 2, 'e', 'f', 'g', 'h']
list[:] = '' # 替换掉原列表的内容，而不是创建一个新的对象

列表推导式

列表推导式提供了创建列表的简单途径，通常用于将一些操作应用于序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的条件创建子序列。用简单的话说，列表推导式相当于 Java 语言中 stream 操作的map和filter的组合。列表推导式都在for关键字后跟一个表达式，之后还会跟零到多个for或者if子句；返回结果是一个根据表达式从其后的 for 和 if 上下文环境中生成出来的列表。如果希望返回元组，则需要用括号包裹推导式。

下面看一些示例。

vec = [2, 4, 6]
list = [3*x for x in vec]
print(list) # 会输出[6, 12, 18]
list = [[x, x**2] for x in vec]
print(list) # 会输出[[2, 4], [4, 16], [6, 36]]
list = [3*x for x in vec if x > 3]
print(list) # 会输出[12, 18]

列表推导式中可以使用复杂表达式和嵌套函数。下面给出一些技巧性的演示，读者可以自行在解析器中尝试运行。

vec1 = [2, 4, 6]
vec2 = [4, 3, -9]
print([x*y for x in vec1 for y in vec2])
print([vec1[i]\*vec2[i] for i in range(len(vec1))])
print([str(round(355/113, i) for i in range(1, 6))])

例如有以下矩阵：

matrix = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]
]

可以使用以下推导式完成矩阵的旋转：

new_matrix = [[row[i] for row in matrix] for i in range(4)]

元组

元组与列表类似，也是由任意类型元素组成的序列。但是与列表不同的是，元组是不可变的，可以认为元组是一个常量列表。

元组使用()包裹使用逗号分割的元素进行创建。例如：

tup1 = (1, 2, 3, 4)
tup2 = ('a', 'b', 1, 2)
tup3 = ()
tup4 = tuple()
tup5 = (40,)

注意上例中，当元组中有且仅有一个元素时，需要在元素后添加一个逗号防止括号被当作运算符使用。此外，在定义元组时也可以省略括号，但逗号不能省略，因为 Python 解释器是依靠逗号来定义元组的，这种语法并不推荐使用。

元组也可以向列表一样使用索引来访问其中的元素，但元组的元素是不允许修改的，仅能够对元组进行连接操作。能够使用索引，就意味着元组可以使用切片来进行操作；对元组进行切片操作，依旧会返回元组类型。

另外一种快速取得元组内元素的方式，称为元组解包。这种方式是通过将元组一次性赋予多个变量来完成的，多个变量之间使用逗号分割。例如：a, b, c = (1, 2, 3)。

元组在进行数据库操作时会常常被用到，从数据库返回的记录结果集中的记录行，一般就是元组类型。此外，函数的参数也是以元组形式传递的，这在之后的函数中会有更加详细的介绍。

元组中也可以使用列表推导式一样的推导式语法，但是其形成的并不是一个元组，而是一个生成器。具体生成器的概念，可参考后文“函数”一节中生成器的内容。

字典

字典也是序列的一种，但不是使用索引进行访问，其中元素的顺序也无关紧要。字典中的元素都拥有唯一的键值（Key），键值通常为字符串，也可以是其他任意不可变类型，如布尔型、整型、浮点、元组等。字典是可变的，所以可以进行增加、删除、修改等操作。

字典使用大括号包裹的逗号分割的键值对进行定义，键值对中键与值之间使用冒号分开。例如：

dict1 = { 'abc': 123, 'bcd': 456, 98.7: 'ui' }
dict2 = {}
dict3 = dict()

对于字典中值的访问需要使用键值，键值需要放在方括号中，例如：dict1['abc']。对于值的修改，也是通过对于键值的访问完成的；删除操作也一样。

使用dict()可以将固定格式的二维序列转换为字典，这个格式为((键, 值), (键, 值))。具体内容类型可以是列表和元组或者是两者混合的类型，甚至还可以是双字符字符串列表。字典中的键是唯一的，如果同一个键被定义两次，则只有最后一次定义生效。

字典操作

字典可以使用in来测试其中是否包含指定的键，注意不是值。

对于字典，Python 提供了以下函数和方法来操作。

• len(dict)，计算元素个数。
• str(dict)，输出字典到字符串。
• type(dict)，返回字典的类型。
• dict.update(dict2)，将 dict2 中的内容合并到 dict 中。
• dict.clear()，删除字典内的全部元素。
• dict.copy()，复制字典内容。
• dict.keys()，以列表返回字典中全部的键。
• dict.get(key, default=None)，尝试获取指定键对应的值，如果键不存在则返回default指定的值。
• dict.items()，以列表返回可遍历的由键和值组成的元组序列。
• dict.setdefault(key, default=None)，尝试设置指定键的值，如果键不存在则添加键并设置默认值。
• dict.values()，以列表返回字典中的所有值。
• dict.pop(key, default=None)，删除字典中的键以及对应值，返回被删除的值，如果键不存在，返回default值。
• dict.popitem()，随机返回并删除字典中的一对键和值。

集合

集合也是常用的序列的一种，其特性与字典相似，但是没有键的存在，集合中的值不允许重复。如果只需要关心元素是否存在，那么集合是最佳选择。

集合使用大括号{}或者set()创建，其中的值使用逗号进行分隔。例如：

set1 = {1, 2, 3, 4}
set2 = set('a', 'b', 'c')
set3 = set()

字典与集合都可以使用推导式语法，并且都是使用{}包裹推导式，但区别是定义字典需要使用冒号:来分隔键与值。

集合操作

集合也可以使用in来判断其中是否包含指定值。除此之外还支持其他的一些操作符进行集合专有的操作。

• &或者set.intersection(set2)，交集运算，返回两个集合的交集。
• |或者set.union(set2)，并集运算，返回两个集合的和。
• -或者set.difference(set2)，差集运算，返回仅存在于第一个集合但不出现在第二个集合中的元素组成的集合。
• ^或者set.symmetric_differnece(set2)，异或集运算，返回仅在两个集合中出现一次的元素组成的集合。
• <=或者set.issubset(set2)，判断 set 是否是 set2 的子集。
• <，用于真子集的判断。
• >=或者set.issuperset(set2)，判断 set 是否是 set2 的超集。
• >，用于真超集的判断。

命名元组

命名元组是元组的子类，在一定程度上可以替代类来使用。命名元组适合用来存储数据，所以适合在仅保存数据而不内置其他方法的情况下使用，类似于 Java 中的 POJO（Plain Ordinary Java Object，简单 Java 对象即普通的 Java Bean）。命名元组既可以通过namedTuple.name来访问元组，还可以通过namedTuple[offset]来访问元素。

命名元组不是 Python 内置自动支持的类型，使用之前需要使用from collections import namedtuple来加载命名元组类型。命名元组的使用与元组不同，它不是直接定义的元组类型数据，而是需要先定义一个带有元素命名内容的数据结构，之后再进行数据的初始化。这个数据结构的定义需要两个参数：命名元组的名称和由多个域名组成的字符串，各个域名之间使用空格隔开。

具体参考以下示例，读者可在交互式解释器中观察示例的输出结果。

from collections import namedtuple

Person = namedtuple('Person', 'firstname lastname age') # 定义命名元组
# 通过指定详细参数来初始化命名元组的内容
student = Person('Bill', 'Lynn', 17)
# 或者通过命名参数来初始化命名元组的内容
student = Person(firstname='Bill', lastname='Lynn', age=17)

print(student)
print(student.firstname)
print(student.age)
print(student[1])

# 命名元组还可以使用字典来初始化
parts = {'firstname': 'Kate', 'lastname': 'Lynn', 'age': 18}
student2 = Person(**parts) # **可以将字典中的键和值取出来提供给函数使用，作为后文中会提到的命名参数

命名元素是不可变的，可以通过._replace()来替换其中的某些域的值来创建一个带有新值的命名元组，例如：student3 = student2._replace(firstname='Lucy')。命名元组的域一旦确定就不能再进行添加或者删除。

条件控制

Python 中的条件控制只有if一种，其语句格式为：

if 条件1:
	语句块1
elif 条件2:
	语句块2
else:
	语句块3

一个if语句中，可以有多个elif条件语句块，但是仅有一个else语句块。if语句可以嵌套在其他语句块结构中，但是要注意语句块的缩进。

这里需要注意以下两个使用要点：

1. 每个条件后面都要使用冒号:，表示接下来是满足条件后要执行的语句块。冒号也是定义新语句块的符号。
2. 一个语句块中的语句要使用相同的缩进。

在 Python 中，if语句的使用方法十分灵活。由于 Python 没有其他语言中的三元操作符，即?:操作，但是 Python 利用if语句实现了更加强大的选择赋值操作。这种操作与前面提到过的列表推导式十分相似，以下用一个示例来说明。

c = []
b = max(c) if len(c) > 0 else -1

在上例中，if被放在了一个表达式后面，这表示这个表达式的执行将由if条件来决定，如果条件不满足，则返回else语句的值。所以上例中b的值即为-1。如果列表c中有内容，不是空列表，则b的内容则是列表中的最大值。

关于 switch

从前面的基本控制语句中可以看出，Python 中没有提供 switch/case 语句。这是因为 Python 认为 switch/case 语法结构需要对参与判断的内容进行 Hash 和唯一性识别，与 Python 的优雅背道而驰。但实际上，我们依旧有多种方法来实现 switch/case 语法结构的替代。

最常用的替代方法是使用字典。

def case(value):
    return {
        'value1': some_value,
        'value2': lambda x: x + 1
    }.get(value, None)

case(some_value)

使用字典来实现 switch/case 结构依靠字典的键来进行判断，返回的是字典中键对应的值。另外一种替代方法则用到了后文中才会提到的一些技术，例如嵌套函数和生成器。

def switch(value):
    fall = False
    def match(\*args):
        nonlocal value, fall
        if fall or not args:
            return True
        elif value in args:
            fall = True
            return True
        else:
            return False
    yield match

for case in switch('v'):
    if case('v'):
        pass
    if case('b'):
        pass

这种替代方法使用生成器，返回了用于判断的函数，实现了 switch/case 的连续判断分支结构。在这种方法中，对于match()中的逻辑可以根据需要进行更加详细的定义。

match结构

在Python 3.10版本中，一个功能更加强大的match语句结构被引入了进来。自此，Python中也就具备了类似与switch语句的结构，但是功能要更加强大。

match语句格式非常简单，其使用格式如下所示。

match 表达式:
    case 条件1:
        语句1
    case 条件2:
        语句2
    case 条件3 | 条件4 | 条件5:
        语句3
    case default:
        默认语句

match语句最简单的使用方式就是跟其他语言中的switch语句一样，在case语句中列举需要匹配的值即可。此时的match语句相当于多条if exp == value:的组合。如果想要达到在匹配多个值时都执行相同分支语句的效果，那么可以使用上面格式说明中的组合条件：case 条件 | 条件 | 条件:，这种形式的分支允许match语句匹配列举的任意条件。

传统使用if/else结构分支语句的时候，在语句结构的最后往往会使用一个else语句块来执行没有任何匹配内容时的处理。在match语句中，这种默认匹配是采用case default:或者使用case _:的分支来声明的，这个默认分支通常都被放置在整个match语句结构的末尾。

match语句还支持对给定的表达式进行解构，例如以下示例中就解构了一个元组。

point = (2, 1)

match point:
    case (1, y):
        print(f"点在行1，列{y}上")
    case (x, 0):
        print(f"点在纵座标轴上，行{x}")
    case (x, y):
        print(f"点在行{x}，列{y}上")
    case _:
        raise ValueError("给定值不是一个点坐标。")

除了可以解构元组以外，match语句还可以解构数据类，其解构的使用方法与解构元组基本一致，只是case分支要改用数据类的类名来进行解构操作指定，如果只需要解构其中一部分内容，还可以使用命名参数来获取指定字段的内容。

另外，对于上面这个示例来说，还可以使用更加Pythonic的方式，那就是使用if来执行额外的判断。改写一下上面这个示例变成了以下的样子。

point = (2, 1)

match point:
    case (x, y) if x == 1:
        print(f"点在行1，列{y}上")
    case (x, y) if y == 0:
        print(f"点在纵座标轴上，行{x}")
    case (x, y):
        print(f"点在行{x}，列{y}上")
    case _:
        raise ValueError("给定值不是一个点坐标。")

在使用if进行额外判断的时候，要记住，match语句会首先捕获值，然后再执行if判断。

对于匹配枚举类中的成员，匹配的值必须书写连带枚举类名称的枚举成员全称，例如以下示例。

from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

match color:
    case Color.RED:
        pass
    case Color.GREEN:
        pass
    case Color.BLUE:
        pass

在对枚举类成员进行匹配的时候，match语句中的分支应该尽量列举枚举中所有可能的值，避免出现空缺匹配的问题。

循环

Python 中的循环语句有for和while两种。需要注意的是 python 中没有do...while循环。

while循环

while 循环是前置真值条件循环，也就是说会先对判断条件进行求值，如果返回真值，则开始执行循环体内容；如果返回假值，则退出循环。while 的语句格式为：

while 判断条件:
    语句块

例如以下示例可以用于求和：

sum = 0
count = 1
while count <= 100:
    sum = sum + count
    count += 1

如果 while 的条件表达式值永远为True，则 while 就变成了一个无限循环，这在运行常驻服务以及 GUI 程序时十分有用。

while 语句可以附加一个 else 语句块，用以在判断条件为False时执行，其语句格式为：

while 判断条件:
    语句块
else:
    语句块

如果 while 中只有一条语句，则可以将其与 while 写在同一行中，但是 while 语句末尾的冒号不可省略。

for 语句

与其他语言中的 for 语句不同，Python 中的 for 语句用于遍历任意序列，如列表或者字符串。其语句格式为：

for 循环变量 in 序列:
    语句块
else:
    语句块

for 语句与 while 语句一样，也可以附加一个 else 语句块，这个 else 语句块是在序列为空，没有执行循环时执行的。

如果需要像其他语言一样循环遍历一个数字序列，可以使用range()定义一个数字序列，例如：

for i in range(5, 10):
    print(i)

range(n, m)会生成一个\( [n,m) \)的区间，如果加入第三个参数，即range(n, m, s)则可以定义序列增长的步进。

对于序列，可以使用函数enumerate(seq)来同时获取序列的索引和值，例如：

for index, value in enumerate(seq):
    pass

循环退出

break和continue语句提供了从循环中退出的功能，其中break会完全退出当前循环体，并且循环体附加的 else 语句块也不会执行。continue语句则是用于跳过循环块中剩余的语句并开始下一次循环的执行。

空语句

空语句十分简单，它不执行任何操作，只是为了保持程序结构的完整性。空语句使用关键字pass完成占位操作。例如：

while True:
	pass

海象表达式

海象表达式（:=）是在 Python 3.8 版本中引入的，在使用时需要注意目前项目所使用的 Python 版本。海象表达式可以用于给变量赋值或者创建局部变量，并将局部变量带入其作用域。海象表达式的值为完成赋值后的变量的值。其具体使用可以参考以下示例。

# 取得列表长度，避免做两次len()运算
if (n := len(arr)) > 10:
	print(f"List is longer than {n}")

# 从文件中循环读取指定长度的内容，并进行处理
# 在没有获取到内容时结束循环读取
while (block := f.read(1024)) != "":
	process_data(block)

# 在列表推导中使用临时变量
new_arr = [a for a in some-arr if (cond := process(a)) in other_list]

迭代

迭代是 Python 中最强大的功能之一，是快速科学访问集合元素的方式之一。迭代器是一个可以记录遍历位置的对象，在迭代器进行迭代时，会从集合的第一个元素开始，直到所有元素都访问结束，并且只能前进不能后退。

迭代器使用iter(seq)进行创建，使用next(it)进行迭代操作。可以用于创建迭代器的数据类型有列表、元组、集合和字符串。如前面所述的推导式语法，创建一个迭代器最快的方法就是使用元组推导式。

使用next(it)可以对生成的迭代器进行取值，并将其向下步进一位。此外，迭代器还可以使用 for 语句进行遍历。以下两段代码的执行结果是一样的。

list = [1, 2, 3, 4]
it = iter(list)
for i in it:
	print(i, end=" ")

it2 = iter(list)
while True:
	try:
		print(next(it))
	except StopIteration:
		sys.exit()

next()在默认情况下，步进到迭代器结尾的时候会抛出StopIteration异常以示迭代结束。但是next()除了可以接受迭代器作为第一个参数外，还可以接受一个默认值作为第二个参数。当给定默认值时，next(iter, default)在步进到迭代器末尾时便不会抛出StopIteration异常，而是会返回给定的默认值。

在 Python 中没有提供对于列表等可迭代类型中元素的检索函数，但是比较 Pythonic 的方法就是使用next()来完成，可参考以下示例语句。

item = next((element for element in arr if element["property"] == someValue), None)

以上语句可以完成对可迭代对象中第一个符合条件的元素进行搜索，并且当可迭代对象中没有满足指定条件的对象时，会直接返回None值。

异常处理

这里所指的异常并不是语法错误，语法错误在 Python 中被称为解析错误。解析错误一般会由 Python 解析器直接指出。异常则是在语法都正确的情况下，解析器在运行期检测到的错误。在没有进行异常处理时，Python 会终止脚本的执行并指出错误所在。

使用try...except可以进行异常处理，这与其他语言中的try...catch功能基本一致。其使用格式为：

try:
	可能出错的语句块
except 错误类型:
	处理语句块

如果没有异常发生，except语句块的内容会被略过；如果发生了异常，则会执行except语句块内容，发生错误之后的 try 语句块内容将被略过。一个 try 语句可以包含多个except语句块，但同一时刻仅有一个except语句块会被执行。如果需要在except中处理多种错误，可以将其组合成元组放置于except关键字后，例如：

try:
	pass
except (RuntimeError, TypeError, NameError):
	pass

通常习惯中，try 语句的最后一个 except 语句块不附加任何错误，直接接一个冒号，这表示这一条 except 语句块将捕获前面所有 except 语句块未捕获的异常。此外，try 语句还可以附加一个 else 语句块，这个 else 语句块必须放置在所有 except 语句块之后，它将会在 try 语句块未发生任何异常的时候执行。具体使用可见以下示例。

try:
	pass
except IOError:
	pass
except:
	pass
else:
	pass

Python 可以使用raise语句抛出一个新的异常实例，例如：raise NameError('Hi')。在 except 语句块中使用不带任何参数的raise，可以将捕获到的异常再次抛出。对于异常的自定义，将在后面类的定义中介绍。

try 语句还可以附加 finally 语句块，用于在任何情况下语句块的执行，通常用来进行异常现场的清理。finally 语句块的用法与 else 语句块类似。

函数

函数是可重复使用的实现单一或者相关功能的代码段。函数能够提高应用的模块性和代码的重复利用率。除了内建函数以外，Python 允许用户自定义函数。要定义一个函数需要遵守以下基本的规则。

1. 函数代码段由def开头，后接函数标识符和圆括号。
2. 任何传入的参数和自变量都必须放在圆括号中间。
3. 函数的第一行语句可以选择性的使用三引号字符串，即 docstring，来对函数进行说明。
4. 函数内容以冒号起始，并且保持缩进一致。
5. 使用return结束函数并返回值。不带表达式的return相当于返回None。

所以定义函数的一般格式为：

def 函数名(函数参数表):
	函数体

定义好的函数通过函数标识符进行调用，调用格式为函数标识符(参数列表)。

def area(width, height):
	return width * height

print(area(15, 10))

参数传递

Python 中的数据类型分为可变类型和不可变类型两种，其中字符串、元组、数字是不可变对象，列表、集合、字典等则是可变对象。在进行参数传递时，不同类型的对象在传递时也不相同。

• 不可变类型：类似于 C++的值传递，传递的只是实参的复制，对形参的修改不影响实参本身。
• 可变类型：类似于 C++的引用传递，传递的是实参的内存地址，对形参的修改将使实参受到影响。

由于 Python 中一切都是对象，所以不能使用值传递或者引用传递的概念，而是应该使用传递可变对象或者传递不可变对象。简而言之，被传递的对象是可变的，那么在函数中对形参的修改，也将直接反映到被传递的对象上，反之亦然。

参数定义

Python 中函数的参数有四种类型：

• 必需参数,
• 关键字参数,
• 默认参数，
• 不定长参数。

必需参数是必需以定义时的顺序传入函数的参数，调用时参数的数量和顺序必须和声明时完全一致。大部分的函数都是采用此种方式声明和调用。这也是函数定义的默认状态。

关键字参数是使用关键字来确定传入的参数值，这时解释器可以根据参数名来确定和匹配参数值，也就允许函数调用时，参数的顺序和声明时的顺序不一致。

def area(width, height):
	return width * height

# 使用必需参数形式调用
area(10, 5)
# 使用关键字参数形式调用
area(height=5, width=10)

参数可以在函数声明时设定默认值，这样在函数调用时，如果没有传递这个参数，解释器就会使用设定的默认值填充参数。默认参数在定义时必须放置在参数列表最后的位置。

def area(width, height=5):
	return width * height

# 使用默认参数
area(10)
# 不使用默认参数
area(10, 8)

不定长参数可以允许函数能够处理比声明时更多的参数，与之前的参数不同，不定长参数不会命名，也没有默认值。不定长参数的使用格式如下：

def 函数标识符([常规形参表], *不定长形参名):
	"docstring"
	函数体
	return 返回表达式

不定长参数使用*在其前方进行标记，所有未命名的变量参数都会形成一个元组传入不定长形参中。用于标记不定长参数的*可以单独出现，例如：func(a, b, *, c)，这种情况下，星号后的参数必须以命名参数的形式出现。

def f(a,b, /, **kwargs):
	print(a, b, kwargs)

# 以下调用将输出：10 20 {'a': 1, 'b': 2}
f(10, 20, a=1, b=2)

如果使用**在不定长参数前进行标记，则会将所有未显式定义的命名参数转化为字典。例如：

def foo(country, **kwargs):
	print(kwargs)

foo('China', province='Hebei', city='Shijiazhuang')

return 语句

return 表达式语句用于退出函数，选择性的向调用方返回一个表达式。不带参数的return语句会返回None。

Python 允许在一个函数中返回多个元素，同时被返回的元素将组合成一个元组，可以使用解包语句来获取其内容。例如：

def twins()
	return 0, 1

zero, one = twins()

# 如果只需要从其中获得部分元素，则可以使用_来屏蔽掉不需要的元素，例如
zero, _ = twins()

此外，一个函数中可以有多个return语句，但只有最后一个return语句的结果被返回，这尤其是在使用try...finally...语句时需要注意。

生成器

不使用return返回值，而使用yield返回值的函数称为生成器。与return不同的是，yield用于不断的返回值，也就是说是用于迭代操作。生成器实际上就是一个迭代器。

生成器在运行过程中，遇到yield时就会暂停运行并保存当前的运行信息，并返回yield的值；当执行next()时，生成器会从保存的位置继续运行，并抛出下一个值。所以调用生成器返回的是一个迭代器对象。如果生成器在运行过程中遇到了return则会直接抛出StopIteration终止迭代。

如果函数需要返回一个容量很大的列表，并且其中的内容是动态计算得到的，那么使用生成器会更加经济、快速。

以下示例构建了一个用于生成斐波那契数列的生成器。读者可以自行在交互式解释器中实验这个函数的运行。

def fibonancci(n):
	a, b, counter = 0, 1, 0
	while True:
		if (counter > n):
			return
		yield a
		a, b = b, a + b
		counter += 1

生成器不仅可以用在for循环中，还可以用于函数的参数。如果这个函数接受一个iterable（可迭代）参数，就可以将生成器传递给这个函数。

除了可以使用next()来获取生成器中的下一个值以外，还可以使用send(arg)来获取生成器中的下一个值。这两个函数的区别是send()函数会将参数传递给yield表达式作为yield表达式的值。这里需要仔细理解生成器的整个操作过程，因为这个操作过程是 Python 进行异步处理的核心概念。以下给出一个生成器接受send()传递的值的例子。

def echo():
	m = 0
	while m < 100:
		m = yield m


f = echo()
value = f.next() # 或者可以调用 f.send(None)
print(value)
value = f.send(98)
print(value)

yield关键字会返回其右侧的值，并从send()函数中取得新值作为其表达式值，在下一次迭代时，将会从yield的下一行开始执行。函数next()和send()的返回值就是本次yield关键字右侧的值。

生成器在初始化后的第一次调用必须使用next()或者send(None)，在第一次调用生成器时，这两条语句是等同的。之所以给send()传递参数None，是因为在调用send()时，还没有出现第一个yield，所以send()没有对应的yield表达式可以修改，必须传递None值以保证生成器的正常运行。

在日常使用时，还会发现yield from关键字形式。yield from关键字允许在一个生成器中调用另一个生成器，并抛出另一个生成器生成的值。yield from常用来将嵌套循环或序列扁平化。以下给出一个扁平化的例子。

# 没有进行扁平化的生成器
def chain(*iterables):
	for it in iterables:
		for value in it:
			yield value

# 扁平化后的生成器
def chain(*iterables):
	for it in iterables:
		yield from it

以下示例使用yield from实现了一个类似于递归的扁平化循环嵌套型序列的方法，请仔细体会。

from collections import Iterable


def flatten(items):
	for it in items:
		if isinstance(it, Iterable):
			yield from flatten(it)
		else:
			yield it

匿名函数

使用lambda关键字可以创建一个只包含一条语句的匿名函数。其定义格式为：lambda 参数列表:表达式。匿名函数默认返回表达式的结果。

area = lambda width, height: width * height
print(area(10, 5))

匿名函数在其他语言中也称为闭包、Lambda 表达式，其功能主旨都是基本相同的。这里要注意的是，匿名函数中变量作用域与普通函数是有不同的，所以不能将其作为普通函数的完全替代品来使用。

变量作用域

Python 中变量的作用域也是由变量的定义位置决定的，并且范围由小到大有以下四种作用域。

• 局部作用域（Local）；
• 闭包外作用域（Enclosing）；
• 全局作用域（Global）；
• 内建作用域（Built-in）。

在 Python 中只有模块、类和函数才会引入新的作用域，除此之外其他的代码块是不会引入新的作用域的。

定义在函数内部的变量拥有一个局部作用域，局部变量只能在其被声明的函数内部访问，如果在函数内部要修改外部作用域的变量时，需要使用global关键字来修饰声明要引用的变量。例如：

num = 1
def foo():
	global num
	num = 2
	print(num)

foo()

如果需要修改嵌套作用域，而外层作用域又非全局作用域，则需要使用nonlocal关键字。例如：

def outer():
	num = 10
	def inner():
		nonlocal num
		num = 20
		print(num)
	inner()

outer()

修饰器

修饰器可以在不修改目标函数代码的情况下，在目标函数执行前后增加一些额外功能，例如函数计时、鉴权等。修饰器是一个函数，它需要返回一个新的函数，修饰器在模块加载时就会执行生成一个个被修饰的新函数。

以下示例定义了一个用于计时的修饰器。

import time

def timing(fn):
	def new_fn(*args):
		start = time.time() # 在被修饰的函数执行前进行操作
		result = fn(*args) # 调用被修饰的函数，被修饰的函数调用结果收集起来
		end = time.time() # 在被修饰的函数执行后进行操作
		duration = end - start
		print("%s secnods cunsomed in executing %s" % (duration, fn.__name__))
		return result # 返回被修饰的函数执行结果
	return new_fn # 返回局部定义的函数

# 使用@来调用修饰器函数对目标函数进行修饰
@timing
def acc(start, end):
	a = 0
	for i in xrange(start, end):
		a += i
	return a

acc(10, 1000000)

修饰器函数使用@进行调用来标记目标函数，并且不允许与函数定义书写在同一行。修饰器函数可以接收参数，定义时只需要再在外面套一层函数即可，带参数的修饰器在调用时直接按照函数调用格式书写参数即可。

以下根据上例修改了一个带参数的修饰器，可以设定是否保留函数元信息。

import time
import functools

def timing(keep_meta=False):
	def real_dec(fn):
		if keep_meta:
			@functools.wraps(fn)
			def new_fn(*args):
				pass # 这里照搬上例中的计时和调用代码即可
		else:
			def new_fn(*args):
				pass # 这里照搬上例中的计时和调用代码即可
		return new_fn
	return real_dec

@timing(keep_meta=True)
def acc(start, end):
	pass # 这里也照搬上例中的处理代码

面向对象

Python从设计之初就是一门面向对象的语言，所以在Python中创建一个类和对象是十分简便的。与其他语言相比，Python在尽可能不增加新语法和语义的情况下加入了类机制。

在面向对象部分中，主要会用到下面这些概念。

• 类：用来描述具有相同功能的属性和方法的集合。对象是类的实例。
• 实例化：创建一个类的实例的过程。
• 对象：通过类定义的数据结构实例，一般包括两种数据成员和方法。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例中是公用的，又称为“字段”或者“特性”。类变量定义在类中但在函数体外。类变量通常不作为实例变量使用。
• 实例变量：定义在方法中的变量，只作用于当前实例的类。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关数据。
• 继承：派生类继承基类的字段和方法的过程。继承也允许把一个派生类的对象作为一个基类对象对待。Python支持一个派生类继承多个基类。
• 方法重载：如果从基类继承的方法不能满足派生类的要求，可以对其进行改写，这时子类的方法会覆盖掉父类的方法，这个过程称为方法重载。Python中的派生类可以重载基类中的任何方法，并且可以调用基类中的同名方法。

类定义

Python中的类使用关键字class进行定义，格式如下：

class 类名:
	类变量定义
	
	def 方法名(self, 参数列表):
		方法体

在上面方法定义中有一个特殊的self参数，这个参数有特殊意义并且是强制规范，这将在后面方法定义中具体阐述。

类定义后，即可使用其实例化对象。实际上，可以通过类名访问其属性。

类对象

类的实例（即对象）支持两种操作：属性引用和实例化。

属性引用使用和Python中所有属性引用一样的标准语法：obj.name。类的实例化有点儿类似于函数调用，使用类名与圆括号，例如：x = MyClass()。

下面给出一个简单的示例，读者可以自行在交互式解释器中实验。

class MyClass:
	"""一个简单的类实例"""
	i = "Hello my class"
	
	def f(self):
		return 'foo'

x = MyClass()

print("MyClass类的属性为{0}".format(x.i))
print("MyClass类的方法输出内容为{0}".format(x.f()))

方法定义

类的方法与普通函数基本上没有什么区别，唯一的区别是它们必须有一个额外的第一个参数名称，在惯例上，这个参数命名为self，也可以根据其他语言的习惯使用this，但是这样并不Pythonic。

这里的参数self代表的是类的实例，而不是类。读者可以在交互式解析器中运行以下示例来查看self的代表。

class Test:
	def prt(self):
		print(self)
		print(self.__class__)

t = Test()
t.prt()

如果使用@classmethod修饰符对一个方法进行修饰，并将第一个参数由self更换为cls（即class，但class为关键字不能够作为参数名称使用），这个方法则会成为类方法。类方法通过类来调用，而不是类实例。类方法的第一个参数cls代表类本身，其不能访问任何实例变量和实例方法，但可以访问类变量。

第三种特殊的方法则是静态方法，这种方法使用修饰器@staticmethod修饰，其定义不包含self或者cls等任何参数。静态方法即不会影响类，也不会影响类的对象，它们的存在仅是因为代码组织的规范，其调用方法与类方法相同。

以下示例演示了类方法与静态方法的定义和使用，读者可自行在交互式解释器中试验。

class A:
	count = 0 # 注意这个变量的级别，这是一个类变量

	def __init__(self):
		A.count += 1 # 这里使用类特性，而不是对象的特性

	@classmethod
	def children(cls):
		print("Has {0} children".format(cls.count))
	
	@staticmethod
	def standalone():
		print("A static method")

ch1 = A()
ch2 = A()
ch3 = A()

A.children()
A.standalone()

构造函数

Python中没有构造函数的概念，只有初始化方法的概念，即__init__()方法。这里借用其他面向对象语言中的构造函数的概念来描述这个初始化方法的功能。初始化方法与普通方法的定义方法一样，但是其名称是Python内部固定不可改变的。所以其定义格式为：

class MyClass:
	def __init__(self):
		pass

初始化方法除了self参数以外，还可以接受其他的参数，这一点与其他方法无异。但是如果添加了其他的参数，那么在类实例的实例化时，也需要传入相应的参数。例如：

class MyCalss:
	def __init__(self, mark):
		self.mark = mark

x = MyClass('check')

上例中MyClass的初始化方法中声明的self.mark是一个实例变量，可以在类中的其他方法中使用。这个实例变量从类内部需要使用self.name的形式来访问，在类外部则需要使用实例名.name的形式来访问。

初始化方法__init__()也可以被重载。可以在类中多次定义初始化方法，但它们所能够接收的参数列表不能相同。在实例化时，传入不同数量的参数，Python就会调用相应的初始化方法。

读者可自行在交互式解释器中试验以下代码。

class MyClass:
	w = 0
	h = 0

	def __init__(self, w):
		self.w = w
	
	def __init__(self, w, h):
		self.w = w
		self.h = h
	
	def export(self):
		print("Width: {0}, height: {1}".format(self.w, self.h))

x1 = MyClass(9)
x1.export()

x2 = MyClass(8, 10)
x2.export()

属性的使用

面向对象的语言一般都支持私有字段，这部分字段不能从对象外部直接访问。但是Python中所有字段都是公开的，即public的。所以Python中有一条惯例：使用双下划线标记的字段为私有字段，不能从对象外部及其子类中直接访问，即__name形式的字段，私有字段在类内部也要使用self.__name的形式访问。同理，私有方法则是在方法名前增加两条下划线，即def __private_method()；如果需要允许在子类中访问指定属性或方法，则需要使用单下划线语法，即_name和def _protected_method()。

这种私有内容的表示方法虽然是约定惯例，但目前Python的解释器已经将其实装并在出现非法访问时会提示错误。

要对私有字段进行访问，Python提供了属性这个特性。可以允许为对象编写getter和setter方法来组成对类内部字段的操作。下面通过一个示例来说明属性的定义方法。

def Person:
	__name = ''
	
	def __init__(self, name):
		self.__name = name
	
	def get_name(self):
		return self.__name
	
	def set_name(self, name):
		self.__name = name
	
	name = property(get_name, set_name)

h = Person('Howard')
print(h.name)
h.name = 'Lynn'
print(h.name)

示例中的get_name()和set_name()都是可以直接调用的，最后一个property()的定义将两者结合了起来形成了一个属性。

另一种定义属性的方式是使用修饰符。使用修饰符定义属性设计两个修饰符的使用：@property和@propertyName.setter。这里需要使用定义的属性名称替换propertyName。

下面用修饰符重新定义上面的示例。

def Person:
	__name = ''
	
	def __init__(self, name):
		self.__name = name
	
	@property
	def name(self):
		return self.__name
	
	@name.setter
	def name(self, name):
		self.__name = name

这种定义已经不像前面那一种一样需要两个显式的getter和setter方法了。这里的属性使用同一个名称但有两个不同重载的方法组成，并且包含不同的修饰符。属性的名称默认是@property修饰符修饰的方法名称。

除了可以对类内部的私有字段进行操作以外，属性还可以用来获取动态产生的计算结果值，即计算属性。如果没有定义setter属性，那么使用@property定义的属性即成为只读属性。

魔术方法

Python中提供了一些特殊的方法，对它们进行重载，就可以让你的类实现实例的加减乘除等操作，而且还包括一些特殊的操作，这些方法也被称为魔术方法。魔术方法以双下划线（__）开头和结束，就像之前说过的构造函数__init__()。可以通过重载这些魔术函数来实现一些Python内置的操作。下表列出了常用的Python支持的方法以及如何使用它们，具体可重载的方法可参考标准库operator。

其中方法__add__()、__sub__()、__mul__()、__floordiv__()、__truediv__()等都有添加i前缀的对应方法，例如__iadd__()，可以用来实现自增、自减等操作，例如a += b。其他可以使用i前缀的方法可参考标准库文档。

继承与组合

继承是面向对象编程的基础之一，Python也不例外。Python支持从多继承，也就是一个派生类可以继承多个基类的内容。派生类的定义格式为：

class 派生类(基类1, 基类2, ...):
	pass

派生类可以重载基类的方法，重载只需要保持函数签名一致即可。派生类可以重载任何一级基类的方法。派生类可以使用super()调用基类的方法。具体使用方法可参考以下示例：

def Base:
	def __init__(self):
		pass
		
	def hello(self):
		pass

def Child(Base):
	def __init__(self):
		super().__init__()
		
	def greeting():
		super().hello()

对于类的继承关系来说，可以使用isinstance()函数来判断一个实例的类型，如果对子类的实例去判断其是否是基类的实例，会得到True的结果。

继承就像是把一个原材料加工成成品或者零件，而组合则是将零件组装成更加强大的产品的过程。换句话说，继承是is的识别关系，而组合则是has的包含关系。

使用组合十分容易，只需要将其他的类实例作为组合类的字段或者属性即可。

鸭子类型

这里的“鸭子类型”并不是真的去指代一个鸭子，而是借用鸭子来说明动态语言与静态语言的区别。对于静态类型，如果需要传入一个Animal类型，则传入的对象必须是Animal类型或者它的子类，否则将会无法调用其中的walk()方法。但是对于Python这种动态语言来说，则不一定要传入Animal类型，只需要保证传入的对象有一个walk()方法就可以了。

这就是动态语言的“鸭子类型”，它不要求严格的继承体系，一个对象如果“看起来像鸭子，走起路来像鸭子，那它就可以被看做是鸭子”。这就是“鸭子类型”的精髓。

对于数据结构的选择

对于数据结构的选择实际上是一件十分Pythonic的事情，虽然条条大路通罗马，但是还是有一些可以参考采纳的Pythonic方法的。

当需要许多相似行为但状态不同的实例时，使用类对象是最好的选择。因为类支持继承而模块不支持继承。但是如果需要保持实例的唯一性，使用模块则是最好的选择，因为不管模块在程序中引用多少次，始终只有一个实例被加载，所以可以把Python的模块理解为单例。

用最简单的方式解决问题。字典、列表和元组往往比模块和类更加简单、简洁和高效。

引用Python创始人Guido的建议：

自定义异常

前面介绍了异常的处理，在很多时候Python内置和标准库提供的异常就已经足够满足使用，但是在一些项目中，应用自定义异常也是十分普遍的事情，而且能够达到针对项目进行特殊设计。

异常就是一个继承了Exception类的类。Python中的所有异常都直接或者间接继承自Exception类。异常一般以Error字样结尾。当创建的一个模块有可能抛出多种不同的异常时，通常的做法是为这个包建立一个基础异常类，然后基于这个基类为不同的错误情况建立不同的子类。例如：

class Error(Exception):
	def __init__(self, value):
		self.value = value
	def __str__(self):
		return repr(self.value)

class InputError(Error):
	pass

class TransitionError(Error):
	pass

使用__slots__

正常情况下，在定义了一个类并且创建其实例后，可以向这个实例绑定任何属性和方法，这是动态语言的灵活性。例如：

class Student:
	pass

s = Student()
s.name = 'Kate'
print(s.name)

以上示例只是绑定了一个属性，实际上还可以为其绑定方法。但是对一个实例绑定的方法，对另一个实例是不起作用的。如果需要给所有实例都绑定方法，可以直接将方法绑定给类。例如：

# 以下绑定了一个方法到实例
def set_age(self, age):
	self.age = age

from types import MethodType
s.set_age = MethodType(set_age, s)
s.set_age(25)
print(s.age)

# 以下绑定了一个方法到类
def set_score(self, score):
	self.score = score

Student.set_score = set_score
s.set_score(100)
print(s.score)

但是在很多时候需要限制实例的属性，不能允许随意添加属性，这时就需要__slots__来完成限制工作。Python允许在定义类的时候使用一个特殊的__slots__变量来限制类能够添加的属性。例如：

class Student:
	__slots__ = ('name', 'age')

s = Student()
s.name = 'Kate'
s.age = 20
s.score = 100 # 这一句将会报错

如果子类中也定义了__slots__，那么子类中允许定义的属性就是其自身定义的__slots__加上父类的__slots__。

使用__dict__存取任意数据

类的静态函数、类函数、普通函数、全局变量以及内置属性都是放在类的__dict__属性中，直接操作__dict__属性可以直接向类的实例中动态的添加成员。在发生继承时，子类有自己的__dict__，父类也有自己的__dict__，属于子类的全局变量和函数将放置在子类的__dict__中，父类的放置在父类的__dict__中，父类的__dict__不会影响子类的__dict__。

__dict__是一个字典类型，可以直接使用字典的常规操作来处理。配合魔术方法__getattr__和__setattr__可以做到在类中存取任意数量的数据。

以下给出一个可自由保存数据的类的示例。

class Storage:
	def __init__(self, **kwargs):
		self.__dict__.update(kwargs)
	
	def __getattr__(self, name):
		if name in self.__dict__.keys():
			return self.__dict__.get(name)
		else:
			return None
	
	def __setattr__(self, key, value):
		self.__dict__.update({key: value})


sample = Storage({"id": 0, "name": "sample"})
sample.create_time = "1970-1-1"
sample.create_time = "1970-1-2"
print(sample)

枚举类

常量一般用大写来定义，但是有相关关系的一组常量一般都是使用类来定义，每个常量都是类的唯一实例。Python在这里提供了枚举类来辅助完成这项工作。

以下给出一个示例。

from enum import Enum

Weekday = Enum('Weekday', ('Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'))

print(Weekday.Mon) # 访问成员
# 迭代成员
for name, member in Weekday.__members__.items():
	print("{} => {}".format(name, member))

也可以使用以下方法来精确控制枚举类的定义。

from enum import Enum, unique

# @unique可以用来保证没有重复值出现
@unique
class Weekday(Enum):
	Sun = 0
	Mon = 1
	Tue = 2
	Wed = 3
	Thu = 4
	Fri = 5
	Sat = 6

数据类

自3.7版本开始，Python引入了一个新的功能：数据类（dataclass）。根据PEP-557的定义，数据类是一个带有默认值的可变命名元组。可以认为数据类就是一个类，其中的属性都是公有的，属性都带有默认值并且可以修改，这个类中还可以包含与这些属性相关的方法。

声明一个数据类需要引入dataclasses模块中的dataclass修饰器。以下给出一个简单的数据类示例。

from dataclasses import dataclass, field


@dataclass
def Book:
	name = ""
	isbn = ""
	price = 0.0
	authors = field(default_factory=list)

数据类在定义后会自动产生一个为所有属性赋值的构造函数，并且会自动建立__repr__()和__eq__()两个方法。数据类中的属性可以不带有默认值，但是需要注意的是不带默认值的属性要写在带有默认值的属性前面，这与函数参数的书写顺序要求是一致的。

修饰器dataclass可以接受一些参数来自定义数据类的建立，主要的参数有以下这些，全都都只接受布尔类型值。

• init，指示是否生成构造函数，如果需要自己定义构造函数则应设置为False。
• repr，指示是否生成__repr__()方法。
• eq，指示是否生成__eq__()方法。
• order，指示是否生成__lt__()、__gt__()、__le__()、__ge__()等用于比较的方法。
• unsafe_hash，根据eq和frozen的值来决定是否生成__hash__。
• frozen，设置为True的时候实例对象将是不可变的。

数据类通过dataclass修饰器自动生成的构造函数默认会调用名为__post_init__()的方法，如果使用了默认生成的构造函数，那么一些追加的构造操作可以在__post_init__()方法中书写。

数据类支持继承，dataclass修饰器会检查数据类的所有基类，会将其中出现的其他数据类按顺序添加进当前的数据类中，如果子类的属性与基类的属性重名，则子类的属性会覆盖掉基类的同名属性。

数据类中的每个属性都会在dataclass修饰器的作用下自动转化为dataclasses.Field对象。通常这个自动转换的过程是无需干预的，但是有的时候则需要定制这个转换过程。我们可以通过dataclasses.field()函数来定义一个属性，并声明它的特性。

正如前面示例中的authors属性，这是一个列表，如果直接使用list()或者[]来定义，则会在数据类实例创建的时候仅复制列表的引用，这会造成不必要的混乱。所以使用field()函数来定义这个属性的具体特性。dataclasses.field()函数可以接受以下参数来定制dataclasses.Field对象。

• default，设置属性的默认值。
• default_factory，控制如何产生默认值，接受一个callable类型值。
• repr，是否包含到默认的__repr__()方法输出中。
• hash，是否参与到生成__hash__中。
• init，是否参与到构造函数中。
• compare，是否参与实例比较方法。
• metadata，使用字典类型值设定属性的元数据，用于第三方扩展使用。

除此之外，dataclasses中还提供了一些常用的工具函数，其功能如下。

• asdict()，将数据类实例转换为一个字典类型实例。
• astuple()，将数据类实例转换为一个元组。

迭代器与生成器

在前面的魔术方法的表格中，出现了两个魔术方法：__iter__()和__next__()。通过这两个魔术方法的组合，可以将一个类创建成一个迭代器。其中__iter__()方法需要返回一个可迭代对象，__next__()需要返回被迭代的对象中的一个元素。

如果一个类只重写了__iter__()，那么这个类可以被称为可迭代对象。如果一个类同时重写了__iter__()和__next__()方法，那么这个类可以被称为迭代器。由于生成器也是一个可迭代对象，所以如果要让一个类成为生成器，只需要重写__iter__()方法即可。以下通过三个示例来分别展示将类书写为不同的形式的方法。

可迭代对象

仅仅作为一个可迭代对象，类中的__iter__()方法需要返回另一个可迭代的对象。

class Collector:
	_collect = []
	
	def __iter__(self):
		return self._collect


for i in Collector():
	pass

示例中通过返回另一个可迭代对象，把这个类定义为了一个可迭代对象，可以直接用于iter()函数或者for循环。

如果在__iter__()方法中使用yield抛出一个值，那么这个类的实例就会变成一个生成器。

class Fib:
	def __init__(self):
		self.a, self.b = 0, 1
	
	def __iter__(self):
		while True:
			yield self.a
			self.a, self.b = self.b, self.a + self.b


for i in Fib():
	pass

迭代器

如果要将可迭代对象扩展为迭代器，需要额外重写__next__()方法，并且__iter__()方法中需要返回类实例本身。

class Fib:
	def __init__(self):
		self.a, self.b = 0, 1
	
	def __iter__(self):
		return self
	
	def __next__(self):
		return_value = self.a
		self.a, self.b = self.b, self.a + self.b
		return return_value

这里需要注意的是，在__next__()方法中不能使用yield关键字抛出值，那样会导致next()函数取得一个生成器对象，而不是一个值。

用类写修饰器

在前面函数一章最后介绍的修饰器，一般都是使用函数来书写的。类也可以被用来书写修饰器，这主要依靠魔术方法来实现。

以下给出一个使用类来书写日志记录器的示例。

from functools import wraps

class Log(object):
	def __init__(self, logfile="some_path"):
		self.log_file = logfile
	
	def __call__(self, func):
		# __call__魔术方法负责进行被修饰函数的调用
		@wraps(func)
		def wrapped_func(*args, **kwargs):
			self.write_log(*args, **kwargs)
			return func(*args, **kwargs)
		return wrapped_func
	
	def write_log(self, *args, **kwargs):
		pass


# 使用类的实例作为修饰器
@Log()
def some_operate():
	pass

使用类书写的修饰器来做日志记录只是其最常见的功能实现，更多的使用场景，读者可以发挥想象力来应用。

类型标注

Python是一个静态类型的语言，但是在编码过程中并不需要严格指定变量、参数的类型，也不需要声明函数返回值的类型。这种特性在Python日常编程中虽然带来了很大的自由度，但是也带来了许多潜在的问题，例如在不知情的情况下错将一个整型值赋予了字符串类型变量。

此外，对于变量及参数类型的不显式限定，也给代码中确定参数类型带来了额外的工作。

于是在Python 3.5版本开始，按照PEP 484的规定，Python增加了类型标注功能（Type Hints）。这项协议旨在为Python加入显式的类型声明，其中就包括函数参数与函数返回值的类型声明。但是需要注意的是，Python 3.5开始加入的类型标注功能仅仅是一个类型标注协议，但未提供类型检查工具，所以在编码时需要其他的工具来配合使用。

类型标注只是给Python提供了一个额外的属性，并不影响任何运行时功能，解释器也不会根据类型标注进行任何类型检查。

类型定义

类型标注所使用的类型可以是Python内置类型，例如str、int等，可以是抽象基类，可以是types模块中定义的类型，亦或者是用户自定义的类。

为了能够对Python所使用的数据类型进行描述，Python在typings模块中声明了一系列的特殊类型。其中包括None、Any、Tuple、Union、Callable。其中None与常量None所表示的意义相同并且可以由常量None来作为类型标注。

将类型赋予一个变量可以便捷的创建类型别名，例如：Url = str。类型别名还可以使用更加复杂的类型，例如T = TypeVar('T', int, float, complex)，表示类型T可以代表整型、浮点以及复数类型，这就使得T表现的像是一个泛型中的类型变量一样，而事实也的确如此。

函数类型较为复杂，是使用Callable来定义的。Callable使用Callable[[参数1类型, 参数2类型], 返回值类型]的格式来定义一个函数，其中列表中第一个元素是由函数所接收的全部参数的类型组成的列表，第二个元素是函数返回值的类型。例如：Callable[[int, str], str]。

以下给出一些常用的类型描述：

泛型

前面提到可以使用TypeVar()来定义类型变量，而在泛型中，类型参数就是一种类型变量，所以使用TypeVar()定义的变量可以作为泛型的类型参数来使用。TypeVar()接受至少一个参数，其第一个参数用于声明类型变量的名称，之后的参数用于限定类型变量可以代表的类型。

类型变量是存在作用域的，例如如果使用了类型变量的两个方法都在同一个class中，那么类型变量的值是统一的、不能改变的。这与其他面向对象语言中的泛型特性相同。

类型标注的使用

类型定义好之后必须要能够使用才能发挥其标注的作用。在函数中进行类型标注是一个最典型的应用案例。

def foo(a: str, b: int) -> str:
	pass

在以上代码示例中，类型标注使用:来标注参数的类型，使用->来标注函数返回值的类型。

前向引用

类型标注有时需要引用一些尚未定义的类型，例如引用自身类型的类。这种情况下直接使用尚未定义的类型进行标注是不正确的，作为替代的方法，Python提供了使用字面量表达式引用尚未定义的类型。例如：

class Tree:
	def __init__(self, left: 'Tree', right: 'Tree'):
		self.left = left
		self.right = right

这种使用字面量表达式引用尚未定义的的类型的方法就叫做前向引用。进行前向引用的字面量表达式中应该包含合法的Python表达式。

工厂方法

工厂方法通常用来创建一个类的实例，这是一种应用很普遍的设计模式。在面向对象的语言中，工厂方法通常是隶属于类的静态方法。Python中因为没有相应定义静态方法及类方法的关键字，所以引入了修饰器来标记方法的不同特征。

工厂方法属于类方法，可以直接使用类来调用，这里给出一个工厂方法的示例。

T = TypeVar('T', bound='C') # 声明类型变量T绑定至类型C，即C及C的子类。

class C:

	@classmethod
	def factory(cls: Type[T]) -> T:
		pass

class D(C):
	pass

d = D.factory() # 此处将生成D类型的实例。

类型转换

有很多时候，编码者自身已经明确变量内容的类型，但是需要返回相应的类型，这就要用到类型转换。类型转换使用typing模块中的cast()函数完成。

cast()函数的使用非常简单，cast(目标类型, 值)即可将指定值转换为目标类型。

自由参数和默认值

阅读到这里，相信读者对自有参数已经不陌生了，其经典示例就是def foo(*args, **kwargs)。这种自由参数也可以标注其参数类型，但是一旦标注类型，函数就会将参数解析为指定类型的列表和字典。例如def foo(*args: str, **kwargs: int)。

此外，进行标注了的参数也依旧可以使用原有的默认参数语法指定参数的默认值，例如def foo(y: int = 0)。

元编程

软件开发中的一条重要原则就是“不要重复自己的工作”，当我们需要复制粘贴的时候，通常都会存在一个更加优雅的解决方案。在Python中，这类问题通常是使用元编程来处理的。元编程的主要目的是创建函数和类，并对代码进行修改、生成或者包装。Python中用于实现这个目的的主要特性有修饰器、类修饰器和元类。

其中使用修饰器来修饰一个函数从而产生一个新的函数在前文中已经介绍过了，这里不再赘述。本章将主要以类修饰器和元类为主进行介绍。

类修饰器

类修饰器是一个普通的函数或者类，可以接受一个类作为参数，并返回一个新的类。类修饰器可以修改类的函数或者修改类的成员。

以下示例是使用类修饰器给类增加成员。

def addAttrs(*attrs):
	def rebuild(cls):
		class NewClass(cls):
			def __init__(self, *args, **kwargs):
				for attr in attrs:
					setattr(self, attr, None)
				self.__id = id
				super(NewClass, self).__init__(*args, **kwargs)
		return NewClass
	return rebuild


@addAttrs('uuid', 'created')
class DBModel(object):
	def __init__(self, *args, **kwargs):
		pass


m = DBModel()
print(m.created)

任何对类的修改，其原理都是动态创建被修改类的一个子类。修改类的函数也不例外。以下示例也是通过动态创建被修改的类的子类来修改类的函数。

def class_decor(*method_names):
	def class_rebuilder(cls):
		class NewClass(cls):
			def __getattribute__(self, attr_name):
				attr_val = super(NewClass, self).__getattribute__(attr_name)
				# 这里可以做一些其他的处理
				return attr_val
		return NewClass
	return class_rebuilder


@class_decor('first_method', 'second_method')
class DecoratedClass(object):
	def first_method(self, *args, **kwargs):
		pass
	
	def second_method(self, *args, **kwargs):
		pass

使用类修饰器来对类进行改变是具有一定局限性的，如果需要更强大的动态修改功能，可以使用下面的元类。

元类

元类是Python中的一个重要特性，要理解其工作方式，必须要明确用于建立对象实例的类也是对象，那么就一定有用于建立类的相关类。在Python中，定义所有类的基类都是内置的type类。

例如，运行以下示例代码，可以看到类的类型。

class MyClass:
	pass


print(type(MyClass))

使用type()创建类

type()作为class的等效功能，给定类名、基类名和属性映射即可创建一个新类。具体创建方法可以参考以下示例。

def foo(self):
	print("From foo")

def boo(self):
	print("From boo")
	
DynamicClass = type("DynamicClass", (object, ), {"func1": foo, "func2": boo})
obj = DynamicClass()
print(type(obj))
obj.func1()

元类模板

使用class创建的类都隐式默认使用type()作为元类，在定义类的时候，可以使用metaclass来指定要使用的元类来改变Python的默认行为。

前面面向对象一章曾经介绍过Python中的魔术方法，在定义元类时也常常使用魔术方法来定义元类模板。元类模板中所使用的魔术方法与一般类中的魔术方法有所不同，以下表格中列出了元类模板定义常用的魔术方法，这些魔术方法也可以被使用到一般类的定义中，并不局限于元类模板中使用。

有了以上这些魔术方法，就可以仿照以下示例来定义和使用元类模板。

class MetaClassTemplate(type):
	""" 注意元类模板中的魔术方法接受的第一个参数大多都为一个类，而不是一个实例 """
	
	@classmethod
	def __prepare__(metacls, name, bases, **kwargs):
		""" __prepare__方法的第一个参数要接受一个元类，所以需要使用@classmethod修饰 """
		print("Meta Class Template __prepare__")
		return super().__prepare__(name, bases, **kwargs)
	
	def __new__(metacls, name, bases, namespace):
		print("Meta Class Template __new__")
		return super().__new__(metacls, name, bases, namespace)
		
	def __init__(cls, name, bases, namespace, **kwargs):
		print("Meta Class Template __init__")
		super().__init__(name, bases, namespace)
	
	def __call__(cls, *args, **kwargs):
		print("Meta Class Template __call__")
		return super().__call__(*args, **kwargs)


class ANewClass(metaclass=MetaClassTemplate):
	def __new__(cls):
		print("New Class __new__")
		return super().__new__(cls)
	
	def __init__(self):
		print("New Class __init__")
		super().__init__()


# 可以观察一下以上元类模板和使用元类定义的类的执行顺序
obj = ANewClass()

常见设计模式的实现

设计模式是经过长时间总结、优化过的针对常见编程问题的解决方案。设计模式提供了在特定情形下编制方法的模板，其并不会绑定具体的编程语言。在常见的23种设计模式中，Python也提供了具有自身特色的实现方法。这里从23种设计模式中拣选一些比较常用的设计模式进行简要的介绍。

工厂方法

当一个类或者函数不知道它所需要创建的对象时，可以责成它的子类来创建目标对象，通过联合不同的子类，类或者函数可以根据需要使用相应的子类来创建所需要的对象。就好像是一个工厂根据消费者的需要进行定制化生产一样。

以下提供一个工厂方法的实现示例，在实际编程中，可以参考这个示例来编写实际的代码。

class Cake:
	def __init__(self):
		self.name = "cake"
		
	def whoami(self):
		return self.name

	
class Waffle:
	def __init__(self):
		self.name = "waffle"
	
	def whoami(self):
		return self.name
	

def food_factory(need="cake"):
	bakers = {"cake": Cake, "waffle": Waffle}
	return bakers[need]()


product = food_factory("waffle")
print(product.whoami())

构造者

一个复杂系统中的对象，往往都十分复杂。这种复杂对象在进行创建时，总是十分麻烦的。尤其是使用构造函数进行初始化，需要传递很长的参数，这常常会使人忘记每一个参数的用途和目的。将一个复杂对象的构建和表示分离，是构造者模式最主要的目标。

以下提供一个构造者模式的示例。

class Cake:

	__name = ""
	__taste = "sweet"
	
	def __init__(self):
		pass
	
	@property
	def taste(self):
		return self.__taste
	
	@taste.setter
	def taste(self, value):
		self.__taste = value
	
	@property
	def name(self):
		return self.__name
	
	@name.setter
	def name(self, value):
	self.__name = value
	
	def __str__(self):
		return "{0} taste {1}".format(self.__name, self.__taste)


class CakeBuilder:
	
	def __init__(self):
		self.__cake = Cake()
	
	def name(self, value):
		self.__cake.name = value
		return self
	
	def taste(self, value):
		self.__cake.taste = value
		return self
	
	def build(self):
		return self.__cake


waffle = CakeBuilder().name("Waffle").taste("sweet").build()
print(waffle)

适配器

适配器用于将一个类暴露出的接口转换成所希望的接口，主要用于使原本因为接口不兼容的类能够协同工作。

假如有以下一个类。

class Car:
	def __init__(self):
		self.name = "car"
	
	def horn(self):
		return "WoWo"

但是我们希望像下面这样进行调用。

def main():
	print("{0} can {1}".format(something.name, somgthing.make_noise()))

但是可以看到，类Car中是没有make_noise()方法的，所以需要定义下面这样一个适配器类来完成所期望的使用方式。

class Adapter(object):
	def __init(self, obj, adapted_method):
		self.obj = obj
		self.__dict__.update(adapted_methods)
	
	def __getattr__(self, attr):
		return getattr(self.obj, attr)


def main():
	vehicle = Car()
	something = Adapter(vehicle, dict(make_noise=horn))
	print("{0} can {1}".format(something.name, somgthing.make_noise()))

代理

代理模式可以为其他对象提供一个代理对象来实现对目标对象的访问。代理模式常用于是用比较通用和复杂的对象替代简单的指针时使用。

代理模式与适配器模式十分的相似，都可以将目标对象转换为另一种访问模式。但是代理类相较适配器类，拥有更高的权限，它甚至可以决定是否要调用目标对象的方法，或者组合目标对象的方法来解决一个功能调用。而适配器类则只是完成接口的转换功能。

读者可以在适配器类的基础上增加更高权限的处理代码来将一个适配器类改变为代理类以体会其中的区别。

观察者

观察者模式号称是其他设计模式之母，所以可以看出其地位的重要。观察者模式主要用于定义对象间的一对多关系，当一个对象的状态发生变化时，其他所有对其依赖的对象都将获得通知并自动更新。观察者模式可以演变出许多常见的设计模式，例如生产-消费模式等。

以下给出一个观察者模式的示例。

class Subject:
	def __init__(self):
		self._observers = []
	
	def attach(self, observer):
		if not observer in self._observers:
			self._observers.append(observer)
	
	def detach(self, observer):
		try:
			self._observers.remove(observer)
		except ValueError:
			pass
	
	def notify(self, modifier=None):
		for observer in self._observers:
			if modifier != observer:
				observer.update(self)


class Data(Subject):
	def __init__(self, name=""):
		Subject.__init__(self)
		self.name = name
		self._data = 0
		
	@property
	def data(self):
		return self._data
	
	@data.setter
	def data(self, value):
		self._data = value
		self.notify()


class Viewer1:
	def update(self, subject):
		print("In view 1: {0}".format(subject.data))
	

class Viewer2:
	def update(self, subject):
		print("In view 2: {0}".format(subject.data))


def main():
	data1 = Data('Data 1')
	view1 = Viewer1()
	view2 = Viewer2()
	data1.attach(view1)
	data1.attach(view2)
	
	data1.data = 10
	data1.data = 15

组合

组合模式主要用于表示对象的部分-整体层次的结构。组合后的对象与单个对象并无什么不同，组合结构中的所有对象将被统一的使用。

以下举一个简单的示例。

class Component:
	def __init__(self, name):
		self.str_name = name
	
	def add(self, com):
		pass
	
	def display(self, depth):
		pass


class Leaf(Component):
	def add(self, com):
		print("Leaf cannot add anything")
	
	def display(self, depth):
		strtemp = "-" * depth
		strtemp = strtemp + self.str_name
		print(strtemp)


class Branch(Component):
	def __init__(self, name):
		self.str_name = name
		self.c = []
	
	def add(self, com):
		self.c.append(com)
	
	def display(self, depth)
		strtemp = "-" * depth
		strtemp = strtemp + self. str_name
		print(strtemp)
		for com in self.c:
			com.display(depth+2)


root = Branch("root")
root.add(Leaf("leaf-1"))
root.add(Leaf("leaf-2"))
branch = Branch("branch-1")
branch.add(Leaf("dead leaf"))
root.add(branch)
root.display()

单例

当一个类只能有一个实例，并且需要提供一个全局访问点时，就可以使用单例模式来定义类。

在Python中单例有多种定义方式，这里选取最简单的一种定义和使用修饰器的线程安全的定义方式进行举例。

首先看最简单的定义方式。

class Singleton(object):
	def __new__(cls, *args, **kwargs):
		if not hasattr(cls, '_instance'):
			org = super(Singleton, cls)
			cls._instance = org.__new__(cls, *args, **kwargs)
		return cls._instance


class Factory(Singleton):
	def __init__(self, name):
		self.name = name
	
	def __str__(self):
		return self.name


obj1 = Factory("Fac1")
print(id(obj1))
obj2 = Factory("Fac2")
print(id(obj2))

最简单的定义方式定义出的单例类面临最大的问题就是线程安全，当有两个或以上的线程同时对单例类实例进行操作时，就可能会出现不可预知的潜在问题。所以使用线程安全的单例定义会更加稳妥。这里会先使用后文才会介绍到的线程，具体多线程处理的内容可参考后面的章节。

import functools
import threading


def singleton(cls):
	""" 用于标记单例类的修饰器 """

	cls.__new_original__ = cls.__new__

	@functools.wraps(cls.__new__)
	def singleton_new(cls, *args, **kw):
		it = cls.__dict__.get('__it__')
		if it is not None:
			return it

		cls.__it__ = it = cls.__new_original__(cls, *args, **kw)
		it.__init_original__(*args, **kw)
		return it
	
	cls.__new__ = singleton_new
	cls.__init_original__ = cls.__init__
	cls.__init__ = object.__init__
	
	return cls


def synchronized(func):
	""" 为普通函数增加线程同步功能的修饰器 """

	func.__lock__ = threading.Lock()
	
	def synced_func(*args, **kwargs):
		with func.__lock__:
			return func(*args, **kwargs)
	
	return synced_func


@singleton
class ProgramState:
	
	__activated = False
	
	def __init__(self):
		self.__activated = False
	
	@property
	def activated(self):
		return self.__activated
		
	@synchronized
	@activated.setter
	def activated(self, value):
		self.__activated = value

原型

当程序中需要实例化的类是在运行时才能确定时，就可以使用原型来创建新的对象。原型实例可以持有多种种类的对象，并可以通过拷贝这些对象来创建新的对象。在Python中实现原型模式十分简单，可参考以下示例。

import copy


class Prototype:
	def __init__(self):
		self._objects = {}
	
	def register_object(self, name, obj):
		self._objects[name] = obj
	
	def unregister_object(self, name):
		del self._objects[name]
	
	def clone(self, name, **attr):
		obj = copy.deepcopy(self._objects.get(name))
		object.__dict__.update(attr)
		return obj


class Cake:
	def __str__(self):
		return "This is a cake."


cake = Cake()
prototype = Prototype()
prototype.register_object("cake", cake)
another_cake = prototype.clone("cake", taste="sweet")

print(cake)
print(cake.taste)

状态

状态模式允许一个对象在其内部状态改变时，改变其行为，看起来其内部实现像是被修改了一样。状态模式适用于一个操作中含有庞大的多分支条件语句，并且这些分支依赖于对象的状态。这些状态通常都使用一个或者多个枚举常量表示。状态模式将每一个条件分支放入一个独立的类中，这就使得你可以根据对象自身的情况将对象的状态作为一个对象，使对象可以不依赖于其他对象而独立变化。

以下给出一个状态模式的示例。

class State(object):
	"""这是一个基本状态，用于在状态间共享功能"""
	
	def scan(self):
		self.pos += 1
		if self.pos == len(self.stations):
			self.pos = 0
		print("Scanning...")


class AMState(State):
	def __init__(self, radio):
		self.radio = radio
		self.stations = ["15", "38", "96"]
		self.pos = 0
		self.name = "AM"
	
	def toggle_am_fm(self):
		print("Swtich AM -> FM")
		self.radio.state = self.radio.fmstate


class FMState(State):
	def __init__(self, radio):
		self.radio = radio
		self.stations = ["81", "99", "106"]
		self.pos = 0
		self.name = "AM"
	
	def toggle_am_fm(self):
		print("Swtich AM -> FM")
		self.radio.state = self.radio.amstate


class Radio(object):
	def __init__(self):
		self.amstate = AMState(self)
		self.fmstate = FMState(self)
		self.state = self.amstate
	
	def toggle_am_fm(self):
		self.state.toggle_am_fm()
	
	def scan(self):
		self.state.scan()


radio = Radio()
actions = [radio.scan] * 2 + [radio.toggle_am_fm] + [radio.scan] * 2
actions = actions * 2

for action in actions:
	action()

中介

中介模式用于解除各个对象间的显式相互引用，松开紧耦合，从而使它们之间的交互可以变得更加独立。中介模式尤其适用于一组对象以定义好的复杂方式通信，或者一个对象引用其他很多对象并直接与它们进行通信的情况。

中介类作为统领其他各个对象的核心，对其他所有相关的对象进行引用和依赖，其他各个对象仅需要处理自己的任务。组合这些对象来完成复杂问题的任务由中介类组织和执行，被统领的类不必关心其他相邻类的情况。

该模式比较容易理解和编写，读者可自行设想一下其实际的应用场景。

责任链

责任链模式用于解除请求事件发送者与处理者之间的关系，能够处理请求的对象会连成一条链，并且沿着这条链来传递请求，直到有一个对象获取并处理了请求为止。可以想象一下击鼓传花游戏的场景。

以下给出一个简单的示例。

class Handler:
	def handle(self, request):
		pass
	
	def next(self, next):
		self.next = next
		return self.next
	
	def forward(self, request):
		self.next.handle(request)


class HandlerOne(Handler):
	def handle(self, request):
		if request.type == 'type1':
			print("Handler 1 process")
		else:
			self.forward(request)


class HandlerTwo(Handler):
	def handle(self, request):
		if request.type == 'type2':
			print("Handler 1 process")
		else:
			print("end of chain")


requests = ["type1", "type2", "type3"]
h1 = HandlerOne()
h1.next(HandlerTwo())
for request in requests:
	h1.handle(request)

装饰

装饰模式可以动态的给一个对象添加职责，尤其是在不能大量添加子类的情况下。相对于使用子类来扩展功能，装饰模式更加灵活。并且装饰模式可以在不影响其他对象的前提下，动态、透明的给单个对象添加功能，并且可以处理可撤销的功能。

下面给出一个装饰模式的示例。

class foo(object):
	def f1(self):
		print("fucntion 1")
	
	def f2(self):
		print("function 2")


class foo_decorator(object):
	def __init__(self, decoratee):
		self.__decoratee = decoratee
	
	def f1(self):
		print("decorated funciton 1")
		self._decoratee.f1()
	
	def __getattr__(self, name):
		return getattr(self._decoratee, name)


u = foo()
ud = foo_decorator(u)
ud.f1()
ud.f2()

享元

享元模式用于对大量细粒度对象的支持。一个应用中如果使用了大量的对象，会造成很大的存储开销。由于享元对象可以被共享，所以可以使用相对较少的享元对象来替代组对象。

以下给出一个享元模式的示例，读者可以在交互式解释器中实验来体会享元模式的用途。

import weakref


class Card(object):
	_CardPool = weakref.WeakValueDictionary()
	
	def __new__(cls, value, suit):
		obj = Card._CardPool.get(value + suit, None)
		if not obj:
			obj = object.__new__(cls)
			Card._CardPool[value + suit] = obj
			obj.value, obj.suit = value, suit
		return obj
	
	def __str__(self):
		return "Card: {0} {1}".format(self.value, self.suit)


c1 = Card('1', 'h')
c2 = Card('2', 'h')
print(c1 == c2)
print(id(c1), id(c2))

库的使用

一门语言自身所能提供的不可能是覆盖方方面面的功能，Python也是如此。但是Python能够完成的功能却是方方面面的，这全部都是Python的各种功能库的功劳。通过挂载不同的功能库，Python能够完成不同的功能。

Python自身也提供了一个标准库，来提供一些功能的默认实现，大部分情况下这个标准库已经够用。但是其他的功能库则提供了更加专业和精确的功能。

功能库的安装

功能库的安装方法曾经有多种方式，目前最为常用的方式是通过pip进行安装。pip会自动将功能库安装到Python安装目录的指定目录下，一般为安装目录的site-packages目录中。其中pip的常用命令已经在前面介绍过，有需要可以到前面去参考。

库功能的查询

Python提供了dir()函数，可以用来列出模块内定义的全部名称，它会以字符串列表形式返回结果。dir()在使用前，需要先使用import引入。例如：

import collections

dir(collections)

对于详细文档内容的查询，可以使用help()来完成。在help()查询界面，可以按Q键退出。help()函数可以列出目标包、模块的docstring。

所以在编写代码时，可以在交互式解释器中使用以上函数来做文档的查询。

此外访问Python Docs也可以查看详细的Python标准库功能以及语言功能。

标准库功能概表

Python的标准库覆盖的功能十分广泛，这里没有具体的空间进行详述。所以这里仅给出一个常用列表，用以说明标准库中各个模块的功能，以方便读者在使用时查询使用。标准库各个功能的详细文档可在Python标准库索引查询。

1. 文字处理服务
   1. string，普通字符串操作
   2. re，正则表达式操作
   3. difflib，增量运算辅助操作
   4. textwrap，文本包装与填充
   5. unicodedata，Unicode数据处理
   6. stringgrep，互联网字符串预处理
   7. readline，GNU readline接口
   8. rlcompleter，GNU readline接口的完整实现
2. 二进制数据服务
   1. struct，将字节数组解释为打包的二进制数据
   2. codecs，编码器注册和基础类
3. 数据类型
   1. datetime，日期时间
   2. calendar，日历相关操作
   3. collections，集合数据类型
   4. collections.abc，抽象集合类型
   5. heapq，堆队列算法
   6. bisect，数组分割算法
   7. array，高效数值数组
   8. weakref，弱引用
   9. types，动态类型创建与内部类型名称
   10. copy，浅拷贝与深拷贝
   11. pprint，美化后的数据输出
   12. reprlib，附加的repr实现
   13. enum，枚举类型支持
4. 数字与数学
   1. numbers，抽象数字类
   2. math，数学计算功能
   3. cmath，复数计算功能
   4. decimal，精确浮点计算功能
   5. fractions，分数计算功能
   6. random，随机数功能
   7. statistics，统计数学计算功能
5. 函数式编程
   1. itertools，迭代器功能
   2. functools，高级函数功能
   3. operator，标准运算符号
6. 文件存取
   1. pathlib，面向对象的文件系统路径
   2. os.path，通用文件路径处理
   3. fileinput，打开多个文件的处理
   4. stat，解析stat()的结果
   5. filecmp，文件与目录的比较
   6. tempfile，临时文件与目录的处理
   7. glob，Unix式路径通配符扩展
   8. fnmatch，Unix式文件通配符扩展
   9. linecache，文件行的随机存取
   10. shutil，高级文件操作
   11. macpath，macOS 9路径处理功能
7. 数据持久化
   1. pickle，对象序列化
   2. copyreg，注册pickle支持的功能
   3. shelve，对象持久化
   4. marshal，Python内部对象序列化
   5. dbm，Unix数据库接口
   6. sqlite3，SQLite数据库的DB-API 2.0接口
8. 数据压缩与打包
   1. zlib，gzip兼容压缩
   2. gzip，gzip文件支持
   3. bz2，bzip2压缩支持
   4. lzma，LZMA压缩算法
   5. zipfile，zip压缩包操作
   6. tarfile，tar压缩包操作
9. 文件格式
   1. csv，csv文件操作
   2. configparser，配置文件解析
   3. netrc，netrc文件处理
   4. xdrlib，xdr文件编解码
   5. plistlin，生成与解析macOS的.plist文件
10. 加密
    1. hashlib，散列支持
    2. hmac，键控散列算法
    3. secrets，密钥生成
11. 操作系统服务
    1. os，通用操作系统接口
    2. io，流操作核心工具
    3. time，时间转换
    4. argparse，命令行解析
    5. getopt，C样式命令行处理
    6. logging，日志功能
    7. logging.config，日志配置
    8. logging.handlers，日志处理
    9. getpass，密码输入支持
    10. curses，终端输出控制
    11. curses.textpad，curses输入组件
    12. curses.ascii，curses的ASCII工具
    13. curses.panel，curses面板扩展
    14. platform，操作系统识别及专属功能
    15. errno，标准系统错误码
    16. ctypes，外接功能库支持
12. 并行操作
    1. threading，线程基础的并行处理
    2. multiprocessing，进程基础的并行处理
    3. concurrent，并行任务库
    4. concurrent.futures，并行任务启动
    5. subprocess，子进程管理
    6. sched，事件控制器
    7. queue，并行队列
    8. dummy\_threading，线程的替换类
    9. \_thread，低级别线程API
    10. \_dummy\_thread，低级别线程API替换类
13. 网络交互
    1. socket，套接字接口
    2. ssl，TLS/SSL接口
    3. select，IO等待处理
    4. selectors，高级IO等待处理
    5. asyncio，异步IO、事件循环、协程、任务
    6. asyncore，异步套接字处理
    7. asynchat，异步套接字命令/回复处理模型
    8. signal，异步事件处理
    9. mmap，内存映射文件支持
14. 互联网数据处理
    1. email，Email与MIME处理
    2. json，JSON编解码器
    3. mailcap，Mailcap文件处理
    4. mailbox，mailboxes处理
    5. mimetypes，文件对MIME类型映射处理
    6. base64，Base16、Base32、Base64、Base85编码器
    7. binhex，binhex4文件编解码器
    8. binacsii，ASCII与二进制转换
    9. quopri，MIME可打印数据的编解码
    10. uu，uuencode文件编解码器
15. 标记文本处理
    1. html，HTML文件支持
    2. html.parser，HTML文件解析
    3. html.entities，HTML内容实体
    4. xml，XML文件支持
    5. xml.dom，XML DOM支持
    6. xml.sax，XML SAX解析器
16. 互联网协议支持
    1. webbrowser，浏览器控制器
    2. cgi，通用网关接口支持
    3. wsgiref，WSGI工具
    4. urllib，URL处理工具
    5. urllib.request，URL请求处理
    6. urllib.response，URL回应处理
    7. urllib.parser，URL解析
    8. urllib.error，URL请求错误
    9. urllib.robotparser，robot.txt解析器
    10. http，HTTP模块
    11. http.client，HTTP客户端
    12. ftplib，FTP客户端
    13. imaplib，IMAP客户端
    14. nntplib，NNTP客户端
    15. smtplib，SMTP客户端
    16. smtpd，SMTP服务器
    17. telnetlib，Telnet客户端
    18. uuid，RFC 4122 UUID对象支持
    19. socketserver，网络服务器框架
    20. http.server，HTTP服务器
    21. http.cookies，HTTP状态管理
    22. http.cookiejar，HTTP Cookies处理
    23. xmlrpc，XML-RPC处理模块
    24. xmlrpc.client，XML-RPC客户端
    25. xmlrpc.server，XML-RPC服务器
    26. ipaddress，IPv4/IPv6处理库
17. 多媒体服务
    1. audioop，RAW音频处理
    2. wave，WAV文件处理
    3. colorsys，颜色系统转换
    4. imghdr，图像类型判断
    5. sndhdr，音频文件类型判断
    6. ossauiodev，OSS兼容音频设备存取
18. 国际化
    1. gettext，多语言国际化服务支持
    2. locale，国际化服务
19. 编程框架
    1. turtle，Turtle图形支持
    2. cmd，命令行解析
    3. shlex，基本词法支持
20. GUI框架
    1. tkinter，Tcl/Tk接口
    2. tkinter.ttk，主题化Tk组件
    3. tkinter.tix，Tk扩展组件
    4. tkinter.scrolledtext，滚动文本组件
21. 开发者服务
    1. pydoc，文档生成系统
    2. unittest，单元测试框架
    3. unittest.mock，mock对象库
    4. 2to3，Python2到Python3的自动代码转换器
22. 运行时服务
    1. sys，系统功能访问
    2. sysconfig，Python配置信息访问
    3. builtins，内置对象访问
    4. __main__，顶级脚本环境
    5. warnings，警告管理
    6. contextlib，with语句工具
    7. abc，抽象基础类
    8. atexit，退出控制器
    9. gc，垃圾回收器接口

常用库列表

这里收集了一些网络上可以获取到的常用库名称，可以在网上搜索查看这些库的使用方法。后文将拣选一些开发中比较常用的库做详细介绍。

1. algotithms，常用算法组合模块
2. virtualenv，虚拟运行环境
3. flask-oauthlib，用于Flask的OAuth 1.0，OAuth 2.0的实现
4. pandas，高性能数据分析器
5. matplotlib，2D绘图库
6. psycopg2，PostgreSQL驱动
7. pymysql，MySQL驱动
8. pymssql，SQL Server驱动
9. redis-py，Redis驱动
10. moment，类似于Moment.js的日期处理库
11. pendulum，日期时间处理库
12. TensorFlow，Google的深度学习库
13. PyTorch，深度学习框架
14. Theano，快速数字计算库
15. Keras，基于TensorFlow和Theano的深度学习库
16. PyInstaller，跨平台可执行程序转换器
17. curses，ncurses封装，用于创建终端图形界面
18. PyQT，QT框架的Python绑定
19. kivy，多平台NUI应用支持
20. PyGObject，GTK+ 3绑定
21. wxPython，wxWidget的Python绑定
22. pyglet，游戏开发框架
23. PySDL2，SDL2库的Python绑定
24. pillow，PIL图像处理库实现
25. python-qrcode，QR码实现
26. nude.py，裸体检测
27. SQLAlchemy，ORM库
28. Django，HTTP Web框架
29. Tornado，HTTP Web框架
30. Flask，轻型HTTP Web框架
31. NumPy，科学计算库
32. SciPy，科学、工程计算库
33. pyexcel，csv、ods、xls、xlsx文件处理库
34. openpyxl，用于读写Excel xlsx文件的的库
35. python-docx，用于读写Word docx文件的库
36. PyYAML，YAML解析器
37. NLTK，自然语言处理平台
38. jieba，中文分词工具
39. requests，人性化HTTP请求处理库
40. pickleDB，轻量级键值存储数据库
41. BeautifulSoup，Python风格HTML与XML文件处理库
42. gevent，基于协程的Python网络库

并行计算

现代操作系统都是支持多任务的操作系统，也就是说操作系统可以同时运行多个任务。而且目前多核CPU已经非常普及，即便是以前的单核CPU也可以执行多任务。

操作系统执行多任务的原理就是轮流让各个任务交替执行，术语称为时间片轮转。这样在CPU高速的执行下，我们就感觉所有任务都在同时执行一样。真正的并行执行只能在多核CPU上实现，但是任务数量远远多于CPU核心数量，所以在每个CPU核心上依旧是采用轮转的运行方式。

对于操作系统来说，一个任务就是一个进程。但是一个进程不见得同时只做一件事，进程内的子任务就称为线程。所以一个进程至少有一个线程。我们之前编写的Python程序都是单任务的，也就是只有一个线程。如果需要执行多个任务就有三种解决方案：

• 启动多个进程，由多个进程同时执行并行任务。
• 启动多个线程，由多个线程同时执行并行任务。
• 启动多个进程，每个进程再启动多个线程。

第三种解决方案一般过于复杂，很少采用。Python既支持多进程，也支持多线程，如何选择取决于我们的程序设计。但是始终要记得，如何调度进程和线程，完全由操作系统决定，程序自己不能决定什么时候执行，以及执行多长时间。

多进程的最大优点是稳定性高，一个子进程的崩溃不会影响主进程和其他子进程。但多进程的缺点就是进程创建代价较高，操作系统中进程总数还是有上限的。多线程的模式通常会比多进程快一些，但也只是有限的一点儿，而且任何一个线程出现问题，都可能造成整个进程的崩溃。

所以采用并行处理的形式是受任务类型影响的，计算密集型和IO密集型是不一样的。计算密集型任务主要消耗CPU的资源，所以需要高效的利用CPU，通常会选择C语言编写并且使并行计算任务数量等于CPU的核心数量。IO密集型则相反，消耗CPU资源少，但需要等待网络和磁盘等操作完成，所以此时Python是首选，并且可以选择多线程来完成。

多进程

Unix/Linux 系统提供了一个fork()的系统调用。这个调用比较特殊，普通的函数调用一次，返回一次。但是fork()调用一次，返回两次，因为操作系统自动把当前进程（父进程）复制了一份（子进程），然后分别在父进程和子进程中返回。

其中子进程中始终返回 0，而父进程中返回子进程的进程 ID。这是因为父进程可以通过返回的子进程 ID 来对子进程进行控制。Python 的os模块封装了这个系统调用，可以在 Python 中轻松的创建子进程。

但是需要注意的是，Windows 系统没有fork()调用，所以在 Windows 上是不能使用这个调用的。

Python 的multiprocess模块提供了跨平台的多进程功能，其中也包括了 Windows 的多进程支持。multiprocess模块中提供的 Process 类代表一个进程对象。以下示例演示了multiprocess模块的使用。

from multiprocess import Process
import os

def run_proc(name):
	print('Run child process %s (%s)' % (name, os.getpid()))

if __name__ == '__main__':
	print('Parent process %s' % os.getpid())
	p = Process(target=run_proc, args=('test',))
	p.start()
	p.join()
	print('Child process end')

.start()方法可以启动 Process 实例，.join()可以等待子进程结束后继续执行。这里要注意的是由于 Windows 下没有fork()，所以 Python 需要模拟一个fork()，这就需要先使用pickle序列化所有对象再传递到子进程中，所以在 Windows 上出现子进程创建失败，要优先考虑pickle失败的情况。

要启动大量的子进程，可以使用进程池的方式批量创建子进程，这需要用到multiprocess模块提供的 Pool 类。以下示例演示了进程池的使用，读者可以自行试验其效果。

from multiprocess import Pool
import os, time, random

def long_time_task(name):
	print('Run task %s (%s)' % (name, os.getpid()))
	start = time.time()
	time.sleep(random.random() * 10)
	end = time.time()
	print('Task %s runs %0.2f seconds' % (name, (end - start)))

if __name__ == '__main__':
	print('Parent process %s' % os.getpid())
	p = Pool(4)
	for i in range(5):
		p.apply_async(long_time_task, args=(i,))
	print('Waiting for all subprocess done')
	p.close()
	p.join()
	print('All done')

对 Pool 对象调用.close()方法会等待所有子进程运行完毕，调用.join()之前需要先调用.close()结束向 Pool 中添加新的 Process。

前面提到过，父进程需要对子进程进行控制，这不仅包括启动和结束的控制，还包括输入和输出的控制。subprocess模块提供了启动一个子进程，之后控制其输入输出的能力。例如：

import subprocess

print('> nslookup www.baidu.com')
r = subprocess.call(['nslookup', 'www.baidu.com'])
print('Exit code %d' % r)

如果子进程需要输入，可以通过.communicate()方法输入。

进程间的通信是通过multiprocess模块提供的 Queue、Pipes 等方式来交换数据的。

多线程

由于线程是操作系统直接支持的最小执行单元，所以一般的高级语言都内置线程的支持。Python标准库提供了_thread和threading两个模块，其中_thread是低级模块，threading是高级模块，大部分情况下只需要使用threading模块即可。

启动一个线程就是将一个函数传入并创建Thread实例，然后调用.start()开始执行。具体可参考以下示例。

import time, threading

def loop():
	print('thread %s is running' % threading.current_thread().name)
	n = 0
	while n < 5:
		n += 1
		print('thread %s >> %s' % (threading.current_thread().name, n))
		time.sleep(10)
	print('thread %s ended' % threading.current_thread().name)

print('thread %s is running' % threading.current_thread().name)
t = threading.Thread(target=loop, name='LoopThread')
t.start()
t.join()
print('thread %s ended' % threading.current_thread().name)

数据同步

多线程和多进程最大的不同在于多进程中，同一个变量各自有一份拷贝在每个进程中，互不影响；而多线程中，所有变量都由所有线程共享。所以这就导致了一个问题，任何一个变量都可以被任何一个线程修改，因此线程使用中最大的危险在于多个线程同时操作一个变量造成的内容混乱。

解决这个问题的一种方案是使用锁。threading模块中就提供了Lock类来完成这个操作。具体使用可参考以下示例。

import time, threading

balance = 0
lock = threading.Lock()

def change(n):
	global balance
	balance += n
	balance -= n

def run_thread(n):
	for i in range(100000):
		lock.acquire()
		try:
			change(n)
		finally:
			lock.release()

t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

当多个线程同时执行lock.acquire()时，只有一个线程能够得到锁，然后继续执行代码。获得锁的线程在结束的时候必须释放锁，即调用lock.release()，否则其他未获得锁的线程将永远等待，造成死锁。锁的使用实际上降低了执行效率，在实际使用中需要仔细考虑数据同步的问题。

在一个线程中，使用自己的局部变量肯定比使用全局变量要好，因为局部变量只有自己可见，而全局变量还需要加锁，但是局部变量也存在调用时参数传递繁琐的问题。threading模块中提供的ThreadLocal类就提供了在全局为每个线程保存数据的功能。具体使用可参考以下示例。

import threading

local_school = threading.local()

def process_student():
	std = local_school.student
	print('Hello, {} (in {})'.format(std, threading.current_thread().name))

def process_thread(name):
	local_school.student = name
	process_student()

t1 = threading.Thread(target=process_thread, args=('Kate',), name='Thread-t1')
t2 = threading.Thread(target=process_thread, args=('Michael',), name='Thread-t2')
t1.start()
t2.start()
t1.join()
t2.join()

分布式进程

在Thread和Process中，应该首选Process，其中不止因为Process更加稳定，而且Process可以分布到多台机器上，而Thread只能局限在一台机器上。Python的multiprocess模块中managers子模块支持把多进程分布到多台机器上，一个服务进程可以作为调度器将任务依靠网络通信分布到其他多个进程中。

首先看服务进程的示例。

import random, time, queue
from multiprocess.managers import BaseManager
# 设置发送和接受的队列
task_queue = queue.Queue()
result_queue = queue.Queue()

class QueueManager(BaseManager):
	pass

# 注册两个队列
QueueManager.register('get_task_queue', callable=lambda: task_queue)
QueueManager.refister('get_result_queue', callable=lambda: result_queue)
# 绑定端口并设置验证
manager = QueueManager(address=('', 5000), authkey=b'abc')
# 启动队列
manager.start()
# 获取网络访问的对象
task = manager.get_task_queue()
result = manager.get_result_queuq()
# 部署任务
for i in range(10):
	n = random.randint(0, 10000)
	print('Put task {}'.format(n))
	task.put(n)
# 从接受队列读结果
print('Try get result')
for i in range(10):
	r = result.get(timeout=10)
	print('Result {}'.format(r))
manager.shutdown()
print('master exit')

之后可以在另一台机器或者本机运行以下子进程。

import time, sys, queue
from multiprocess.managers import BaseManager

class QueueManager(BaseManager):
	pass

QueueManager.register('get_task_queue')
QueueManager.register('get_result_queue')

server_addr = '127.0.0.1'
print('Connect to {}'.format(server_addr))

m = QueueManager(address=(server_addr, 5000), authkey=b'abc')
m.connect()

task = get_task_queue()
result = get_result_queue()

for i in range(10):
	try:
		n = task.get(timeout=1)
		print('run task {0} * {0}'.format(n))
		r = '{0} * {0} = {1}'.format(n, n * n)
		time.sleep(n)
		result.put(r)
	except Queue.Empty:
		print('task queue is empty')

print('worker exit')

此时就可以在两个进程上观察任务的分配和运行结果了。

协程

协程是比线程更加微小的结构，称为Coroutine。一般的函数调用是通过栈实现的，一个线程就是执行一个函数，函数的调用总是一个入口，一个返回，调用顺序是明确的。而协程则不同，协程看上去也是函数，但在执行过程中在函数内部可以中断，转而执行其他的函数，在适当的时候在返回来继续执行。

协程的特点是在一个线程执行，其优势就是有极高的执行效率。因为函数切换不是线程切换，因此没有线程切换的开销，和多线程相比，线程数越多，协程的性能优势就越明显。此外，协程不需要线程锁的机制，因为只有一个线程，所以也不存在写变量冲突。

在利用多核CPU方面，可以采用多进程+协程的方式，充分利用多核并且发挥协程的高效率。Python对协程的支持是通过生成器实现的。

Python的yield不仅可以返回一个值，还可以接收调用者发出的参数。

以下示例使用生产者-消费者模式演示了协程的使用。

def consumer():
	r = ''
	while True:
		n = yield r
		if not n:
			return
		print('[CONSUMER] Consuming {}'.format(n))
		r = '200 ok'

def produce(c):
	c.send(None)
	n = 0
	while n < 5:
		n += 1
		print('[PORODUCER] Producing {}'.format(n))
		r = c.send(n)
		print('[PRODUCER] Consumer return {}'.format(r))
	c.close()

c = consumer()
produce(c)

这里需要注意以下几点：

1. consumer是一个生成器，将其传入producer后，调用c.send(None)启动生成器；
2. 一旦产生了内容，通过c.send(n)切换到consumer的执行；
3. consumer通过yield拿到消息，处理后又通过yield传回结果；
4. producer拿到consumer处理的结果，继续产生下一条消息；
5. producer结束生产时，调用c.close()关闭consumer结束整个过程。

这整个运行过程中是不需要锁的，而且在同一个线程中执行。

IO编程

文件读写是最常见的IO操作，Python标准库中内置了读写文件的函数，用法与C语言是相兼容的。除此之外还提供了字符串、字节数组等非文件内容的IO操作，可以允许用户像读写文件一样操作这些资源。

下面对IO相关的内容进行简单的介绍。

开域资源管理

在开始介绍IO操作之前，先介绍一个Python提供的语句：with（开域语句）。在之前的异常处理一节，我们提到了可以使用try...finally来进行出现异常之后的资源清理操作。但是每次这样书写都十分繁琐，例如：

try:
	f = open('/path/file', 'r')
	print(f.read())
finally:
	if f:
		f.close()

所以Python就提供了with语句，它与try...finally语句的效果是一致的，会自动调用其打开的资源的关闭方法。例如：

with open('/path/file', 'r') as f:
	print(f.read())

当然并不是只有open()函数返回的对象才可以使用with语句，任何对象只要正确的实现了上下文管理，就可以使用于with语句。上下文管理是通过__enter__和__exit__两个方法实现的。例如：

class AutoCloseable:
	def __init__(self):
		pass
	
	def __enter__(self):
		return self
	
	def __exit__(self, exc_type, exc_value, traceback):
		self.close()
	
	def query(self):
		pass
	
	def close(self):
		pass

或者还可以使用contextlib中的contextmanager来实现。例如：

from contextlib import contextmanager

class AutoCloseable:
	def __init__(self):
		pass
		
	def query(self):
		pass
	
@contextmanager
def create_autocloseable():
	a = Autocloseable()
	yield a

with create_autocloseable() as a:
	a.query()

如果希望在某段代码前后自动执行特定代码，也可以使用@contextmanager实现。例如：

@contextmanager
def tag(name):
	print("<%s>" % name)
	yield
	print("</%s>" % name)

with tag("h1"):
	print("hello")

上述代码的执行顺序为：

1. with首先执行yield之前的语句。
2. yield执行with内部的所有语句。
3. 执行yield之后的所有语句。

因此，@contextmanager可以通过编写生成器来简化上下文管理

文件读写

前面的示例已经提到了open()函数，这个函数可以以指定的模式打开一个文件对象，要使用这个函数，只需要传入文件名和标识符。如果要打开的文件不存在，open()函数会抛出一个IOError并给出详细的错误码和错误信息。open()的使用格式是open(文件路径, 标识符)。

打开的文件可以使用.read()方法一次性读取其中的数据，或者使用read(n)来读取指定文件长度，还可以使用.write()来向文件中写入数据，最后需要使用.close()方法关闭文件对象。为了操作的简便，可以使用with语句来完成文件的操作。

标识符是一个可以组合的字符串，其中使用几个字母来表示打开的模式。常见的组合有以下若干：

open()函数还可以接受一个encoding参数，用于指示打开的文件的编码，以及一个errors参数，用于指示出现错误后的处理方式，例如直接忽略（errors='ignore'）。

StringIO

数据的读写不一定全都是文件，也可能是字符串或者字节数组。这跟Java等语言中的流的概念很相似。Python的io模块提供了StringIO类来提供在内存中读写字符串的功能。

StringIO提供使用StringIO()来创建一个可操作的字符串对象，并且可以像读写文件那样对其进行操作。最后可以使用.getvalue()方法来获取最后的字符串。

具体操作可以参考以下示例：

from io import StringIO
f = StringIO()
f.write('hello\n')
f.write(' \n')
f.write('world\n')
print(f.getvalue())
g = StringIO(f.getvalue())
while True:
	s = g.readline()
	if s == '':
		break
	print(s.strip())

BytesIO

StringIO提供的是对字符串的操作，要操作二进制数据，就需要使用BytesIO类。其具体使用与StringIO类似。

from io import BytesIO
f = BytesIO()
f.write("你好".encode('utf-8'))
print(f.getvalue())

文件和目录

文件和目录的操作都是由操作系统完成的，Python中的os模块可以直接调用操作系统提供的接口函数来完成目录和文件的操作。这里需要注意的是，os模块提供的功能是操作系统相关的，有些操作系统例如Windows会不支持Linux提供的一些功能，所以在使用之前，要注意操作系统的区别。

调用os.name()可以获得操作系统类型，返回值为'posix'表示系统可能为Linux或者macOS，如果返回值为'nt'，则表示系统为Windows。

操作文件和目录的函数一部分放在os模块中，一部分放在os.path模块中。常用的函数有一下这些。

例如列出当前目录中的所有子目录，可以使用一行代码完成：[x for x in os.listdir('.') if os.path.isdir(x)]。

Python没有直接提供复制文件的函数，如果需要对文件进行复制，只能分别打开源文件和目标文件两个句柄，然后对其中内容进行复制。操作可参考以下示例。

with open(sourceFile, "rb") as source:
	with open(destinationFile, "wb") as destination:
		destination.write(source.read())

序列化

把变量的内容从内存中变成可存储或者可传输的过程称为序列化，反之，将序列化的内容读入内存称为反序列化。

二进制序列化

Python通过pickle模块来实现二进制的序列化。其使用十分简单：

import pickle
d = dict(name='Bob', age=20)
f = pickle.dump(d) # 导出内容
rd = pickle.load(f) # 导入内容

JSON

要在不同的语言之间传递对象，需要把对象序列化为标准格式，例如XML。目前更为流行的格式是JSON。Python内置的json模块提供了完善的Python对象到JSON格式的转换。其使用与pickle相似。

import json
d = dict(name='Bob', age=20)
f = json.dump(d)
rd = json.loads(f)

Python的dict对象可以直接序列化为JSON的{}。如果需要将其反序列化为类实例，需要定义转换方法。例如有以下类：

class Student:
	def __init__(self, name, age, score):
		self.name = name
		self.age = age
		self.score = score

json.dump()接受一个default参数，接收一个转换函数，可以用来将对象转换为dict。例如：

def student2dict(std):
	return {'name': std.name, 'age': std.age, 'score': std.score}

或者还可以有个偷懒的办法：json.dump(object, default=lambda obj: obj.__dict__)。通常类的实例都有一个__dict__属性，用来存储实例变量，但是使用了__slots__的类就不能使用这个办法。

在反序列化的时候，loads()方法首先将其转换出一个dict对象，然后再传入一个函数将其转换为我们需要的实例即可。

异步IO

asyncio是Python 3.4引入的标准库，内置了异步IO的支持。asyncio的编程模型就是一个消息循环，可以从asyncio模块中直接获取一个Eventloop的引用，然后把需要执行的协程放入Eventloop中执行就实现了异步IO。

以下是一个asyncio的简单示例：

import asyncio

@asyncio.coroutine
def hello():
	print('hello world.')
	r = yield from asyncio.sleep(1)
	print('hello again')

loop = asyncio.get_event_loop()
loop.run_until_complete(hello())
loop.close()

@asyncio.coroutine把一个生成器标记为coroutine类型，然后就把这个coroutine放入Eventloop中执行。yield from可以让我们方便的调用另一个生成器，由于示例中asyncio.sleep()也是一个协程，所以线程不会等待，而直接去执行下一个消息循环了。在此期间，主线程并未做任何等待操作，而是直接去执行Eventloop中其他可以执行的协程，因此就实现了并发执行。

在实际应用中，只需要把yield from这里抛出真正消耗时间的IO操作就可以实现多个协程由一个线程执行。

async/await模型

上一节使用asyncio提供的@asyncio.coroutine把一个生成器标记成了coroutine类型，并在coroutine内部使用yield from调用另一个coroutine实现异步操作。这个代码并不容易阅读，所以在Python 3.5引入了async/await语法。

接触过C#和Javascript ES7、Typescript的读者可能会对这个语法比较熟悉。在这些语言中，async/await是典型的异步操作语法。在Python中使用这个语法也很简单，下面用这个新语法来重新写一遍上面的示例。

async def hello():
	print('hello world.')
	r = await asyncio.sleep(1)
	print('hello again')

示例中其余的代码可以保持不变。读者可以对比一下两段代码，是不是简洁了许多。

基本数据库访问

Python对于数据库的访问提供了一套通用的API，称为DB-API。任何数据库只要提供符合这套API的驱动，就能够让Python连接到数据库并完成操作。所以各个数据库之间仅有引入的模块与数据库连接语句不同，其他操作都是共通的。

使用DB-API访问数据库，一般会使用以下几个步骤。

1. 连接到输出，获得数据库连接；
2. 打开游标（Cursor）；
3. 通过游标执行SQL语句，获得执行结果；
4. 关闭游标；
5. 关闭连接。

由于SQLite的驱动直接内置在Python的标准库中，所以这里以SQLite 3的操作为例来说明DB-API的使用。

import sqlite3

conn = sqlite3.connect('test.db')
cursor = conn.cursor()
cursor.execute('select * from user where name=%s', ('Kate',))
print(cursor.rowcount)
values = cursor.fetchall()
cursor.close()
conn.close()

示例中演示了向SQL语句中传递参数，Cursor是按照参数出现位置来绑定参数的，有几个占位符就需要多少个参数。占位符可以参考使用字符串格式化中的占位符。额外的规则是，%s表示顺序占位，顺序占位需要传入一个元组；%(name)s表示名称占位，可以传入一个字典来归置参数。

DB-API返回的数据结构是一个列表，其中每行数据以元组类型出现。如果需要以类来表示每行数据，则需要后文介绍的ORM框架来实现。

虚拟环境的使用

在同时开发多个应用的时候，可能每个应用都需要各自拥有一套独立的Python运行环境。virtualenv就是用来为一个应用创建一套隔离的Python运行环境的工具，

首先在使用pip install virtualenv后，在项目根目录中使用以下命令创建一个独立的Python运行环境，名为venv：virtualenv --no-site-packages venv。

新建的Python环境被放置到当前目录的venv目录下，之后可以使用命令来激活这个环境：source venv/bin/activate，Windows系统的环境启动命令是：venv/Scripts/activate。

此时可以看到命令提示符已经发生变化，表示Python环境已经切换。从这里开始就可以正常安装各种第三方包以及运行Python命令了。

如果需要退出venv环境，可以使用deactivate命令。

virtualenv可以解决不同应用间多版本冲突问题。

对于Python 3.5以上版本已经内置了venv功能库，不需要再安装virtualenv功能库了，可以直接在命令行执行命令python3 -m venv .env来将虚拟环境创建在.env目录中。这时要启动虚拟环境，针对不同的命令行环境，可以使用以下不同的启动方式（以虚拟环境安装至venv目录为例）。

对于一个项目来说，需要一种能够记录其安装过的依赖库的方法来方便项目的迁移。pip使用requirements.txt文件提供了这个功能。requirements.txt文件中记录了项目中所安装的全部依赖库及其版本，能够在项目迁移时通过一条命令直接恢复项目的运行环境。在建立requirements.txt文件时，尽量在虚拟环境中完成，这样可以防止不被依赖的库被误加入requirements.txt中。

在项目环境已经建立好后，可以在虚拟环境下通过pip freeze > requirements.txt命令来将目前环境中安装的全部依赖库列表导出至requirements.txt中。之后可以使用pip install -r requirements.txt来完成全部依赖库的安装。

使用pipenv进行集成化虚拟环境管理

前面介绍了使用pip进行Python项目的包管理，而使用virtualenv来给项目运行提供一个虚拟环境。在多数情况下，综合使用这两种工具就已经能够满足项目基础环境管理的需求。但是，使用多种工具毕竟是复杂的，pipenv的出现就将pip和virtualenv两个工具的功能集合在了一起。

如果你了解NodeJS的npm包管理器，那么恭喜你，你会很容易的上手pipenv。

安装

Pipenv也是Python的一个库，可以直接使用pip完成安装，其命令是pip install pipenv。

安装结束后，就可以直接在命令行下使用pipenv命令来进行项目的环境创建、依赖管理等功能了。

基本概念

Pipenv是Pipfile的主要倡导者、requests库的作者Kenneth Reitz开发的一个命令行工具，主要包含了Pipfile、pip、click、requests和virtualenv几个库。Pipfile是社区拟定的依赖管理文件，用来替代过于简陋的requirements.txt文件。

Pipfile是一个TOML格式文件，而不是与requirements.txt一样的纯文本文件。每个项目对应一个Pipfile，并且支持区分开发环境和生产环境。对其管理的依赖提供了版本锁功能，并保存为Pipfile.lock文件。

使用方法

Pipenv通过pipenv命令搭配子命令以及参数来完成项目创建和依赖管理功能，其通用的命令格式为pipenv [选项] 子命令 [参数]。以下通过完整的创建一个项目来说明pipenv的常见命令使用。

建立项目文件目录

在命令行中新建一个项目目录（例如project），并进入到这个目录中（即cd project）。

创建项目虚拟环境

执行命令pipenv --three可以使用当前系统的Python 3创建环境，或者还可以使用pipenv --python 版本号来创建指定版本Python的环境。

激活虚拟环境

保持位于项目目录下，执行命令pipenv shell可以激活项目虚拟环境，在虚拟环境下执行命令exit可以退出虚拟环境。

依赖库管理

安装依赖库并不需要激活虚拟环境，只需要保持在项目目录下，执行命令pipenv install 库名称，即可安装第三方库。pipenv会自动按照Pipfile区分所在虚拟环境。使用install命令安装第三方库，会自动将第三方库及其版本号加入到Pipfile中。

依赖库默认会安装到生产环境中，但是通常有些库在生产环境中并不需要，这时可以使用带参数的install --dev命令，来将第三方库安装到开发环境中，例如pipenv install --dev django。--dev参数可以帮你在一个虚拟环境中区分开发环境和生产环境。

如果当前目录中没有建立虚拟环境，那么pipenv install命令（注意，该命令不带任何第三方库名称）将会自动建立一个新的虚拟环境。如果当前目录中没有虚拟环境，但是存在Pipfile，则将会使用已有Pipfile文件的内容创建一个虚拟环境。

如果需要卸载第三方库，也是十分容易的，只需要执行命令pipenv uninstall 库名称即可。

运行脚本

运行指定脚本同样也不需要激活虚拟环境，但是需要用虚拟环境中的Python解释器。调用虚拟环境中的Python解释器的命令格式为pipenv run python [参数]。

所以如果需要运行项目脚本，可以使用命令pipenv run python foo.py。

常用子命令

下表中列出了常用的子命令的功能。

常用选项

一般来说pipenv命令的选项并不常用，但是如果需要一些额外的功能，就需要在命令中加入选项，选项一般书写在子命令前面。下表中列出了常用的选项及其功能。

更换pipenv的源

在使用pipenv的时候，有时第三方库的安装会变得很慢，这是因为pipenv的源的问题。这时可以打开项目的Pipfile文件，将其中[source]部分中url一项内容更改为以下地址，可以更换项目所使用的源。

• https://pypi.tuna.tsinghua.edu.cn/simple，清华源；
• http://mirrors.aliyun.com/pypi/simple/，阿里源；
• https://pypi.mirrors.ustc.edu.cn/simple/，中国科学技术大学源。

熟悉TOML的人应该知道，[source]这种标记是代表列表的，所以可以在Pipfile里列举多个源

常用内建模块使用

日期处理

datetime是Python处理日期和时间的标准库。以下通过示例来说明常用的功能的用法。

from datetime import datetime, timedelta

now = datetime.now() # 获取当前时间
dt = datetime(2018, 6, 4, 23, 59) # 用指定时间创建datetime
timpstamp = dt.timestamp() # 获取指定时间的Unix时间戳，Python中的时间戳为浮点数
dt2 = datetime.fromtimestamp(timestamp) # 从时间戳转换回datetime，默认使用本地时区
cday = datetime.strptime('2018-6-4 23:08:59', '%Y-%m-%d %H:%M:%S') # 用指定格式解析文本时间串
print(now.strftime(%a, %b %d %H:%M)) # 用指定格式输出时间
print(now + timedelta(hour=6)) # 时间加减运算，timedelta代表时间段

集合

collections是Python内建的集合模块，提供了许多有用的集合类。

namedtuple

命名元组之前已经介绍过了，这里不再赘述。

deque

使用list存储数据的时候，按照索引访问元素很快，但是数据量大的时候，插入和删除的效率很低。deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈。

defaultdict

当使用dict时，如果引用的键不存在，就会抛出KeyError，defaultdict可以在键不存在的时候返回一个默认值。

OrderedDict

使用dict时，键是无序的，在对dict做迭代时，键的顺序无法确定。OrderedDict可以保持键的顺序。

Counter

Counter是一个简单的计数器，可以用来进行简单的统计。

Base64编码

Base64是一种用64个字符来表示任意二进制数据的方法。Base64的原理很简单，首先准备一个包含64个字符的数组，然后对二进制数据进行处理，每3个字节一组，划分为4组，每组6个bit。这样可以得到4个数字作为索引，然后查表获得相应的4个字符，这就是编码后的字符串。所以Base64编码会将3字节的二进制数据编码为4字节的文本数据，长度增加33%，但好处是编码后的文本可以在邮件正文、网页等位置直接显示。如果要编码的二进制数据不是3的倍数，Base64会使用\x00字节在末尾补足后，再在编码的末尾加上1个或2个=号，表示补了多少字节，解码时会自动去掉。

Python内置的base64可以直接进行Base64的编解码。

import base64
base64.b64encode(b'binary\x00string')
base64.b64decode(b'YmluYXJ5AHN0cmluZw==')

字节数据打包

Python中没有专门处理字节的数据类型，但由于字节数组可以由二进制字符串表示。而在C语言中，可以很方便的使用struct和union来处理字节，以及字节和int，float的转换。

Python提供了一个struct模块来解决bytes和其他二进制数据类型的转换。struct的pack函数把任意数据类型变成bytes。pack()方法接收两种参数，第一个参数是处理指令，后面是要打包的数据，数据的个数和顺序要与处理指令一致。例如：

import struct
struct.pack('>I', 1024000)

与pack()功能相反的方法是unpack()，它接收两个参数，第一个参数依旧是处理指令，第二个参数是要处理的bytes。

处理指令由两部分组成，第一部分是字节序、长度以及对齐标记。默认情况下，C类型会使用机器的原生格式和字节序表示，但是在不同设备之间传递可能就需要变更这些配置。第一部分的控制标记如下：

剩下的控制字符可以根据编解码内容顺序，选择以下内容。

除s和p以外的字符，前面添加数字表示重复次数，例如4h表示hhhh。s和p前的数字表示其内容长度。

散列算法

Python的hashlib提供了常见的散列算法，如MD5、SHA1等。以下示例以MD5算法演示了hashlib的使用。

import hashlib

md5 = hashlib.md5()
md5.update('hello'.encode('utf-8'))
md5.update('world'.encode('utf-8'))
print(md5.hexdigest())

对于较短的文本，使用一次update()即可，对于较长的内容，则可以分块进行计算。

由于基本的散列算法可以根据彩虹表反推原始内容，所以一般在使用散列算法时都会加盐（salt）。例如md5.update(message + salt)。这样就必须要提供盐值才能完成验证，这就形成了Hmac算法。

Hmac通过标准算法将盐值混入计算过程，可以使得散列后的内容更加安全。Python提供了hmac模块来支持Hmac算法，具体使用可参考以下示例。

import hmac
message = b'Hello world'
key = b'secret'
h = hmac.new(key, message, digestmod='MD5')
print(h.hexdigest())

辅助迭代操作

对于迭代操作，Python提供了itertools模块来提供用于辅助迭代操作的功能。

首先itertools模块提供了几个用于创建无限迭代器的函数。

• count()，生成自然数序列；
• cycle()，将传入的序列循环重复下去；
• repeat()，将一个元素无限循环发送，可以使用第二个参数指定循环次数。

此外，itertools还提供了一些额外的函数来组合迭代对象的内容。

• takewhile(条件函数, 迭代器)，从迭代中根据条件获取一个序列；
• chain()，将多个迭代对象串联形成更加强大的迭代器；
• groupby()，将迭代器中的重复元素放在一起，形成字典，其中值形成序列，重复值形成键。

其他itertools中的功能可参考Python文档。

URL

urllib模块提供了一系列的用于操作URL的功能。其中常用的是Get操作和Post操作，这在爬虫应用中是十分常用的。对于HTML的解析，建议使用Beautiful Soup库，因为这个功能库有中文文档，所以这里不再赘述。

Get操作

urllib中的request模块可以非常方便的抓取URL内容，也就是通过GET请求获取相应的HTTP响应。具体使用可参考以下示例。

from urllib import request

with request.urlopen('http://www.baidu.com') as f:
	data = f.read()
	print('Status: {} {}'.format(f.status, f.reason))
	for k, v in f.getheaders():
		print('{}: {}'.format(k, v))
	print('Data: {}'.format(data.decode('utf-8')))

如果需要模拟浏览器发送的GET请求，就需要使用Request对象。Request对象可以添加HTTP头，这样就可以伪装成浏览器了。

将上例改写一下，改成模拟浏览器请求的方式。

from urllib import request

req = reqeust.Request('http://www.baidu.com')
req.add_header('User-Agent', 'xxxxxxxx')

with request.urlopen(req) as f:
	data = f.read()
	print('Status: {} {}'.format(f.status, f.reason))
	for k, v in f.getheaders():
		print('{}: {}'.format(k, v))
	print('Data: {}'.format(data.decode('utf-8')))

Post操作

要发送POST请求，同样是使用request模块，但是需要将要提交的参数以bytes形式传入。例如：

from urllib import request, parse

email = input('Email: ')
passwd = input('Password: ')
login_data = parse.urlencode([
	('username', email),
	('password', passwd),
	('entry', 'mweibo'),
	('client_id', ''),
	('savestate', '1'),
	('ec', '')
])

req = request.Request('https://passport.weibo.cn/sso/login')
req.add_header('Origin', 'https://passport.weibo.cn')
req.add_header('User-Agent', 'Mozilla/6.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')

with request.urlopen(req, data=login_data.encode('utf-8')) as f:
	print('Status:', f.status, f.reason)
	for k, v in f.getheaders():
		print('%s: %s' % (k, v))
	print('Data:', f.read().decode('utf-8'))

调用动态链接库

Python被称为胶水语言，就是因为其强大的调用功能，在功能库的支持下，Python可以调用其他语言的功能。但在实际应用中，Python更多的还是调用C语言编写的动态链接库，因为这会给Python提供强大的计算性能和低级别操作的补充。

对于动态链接库的调用是通过标准库ctypes模块实现的。ctypes可以调用以下几种动态链接库：

• CDLL，一般共享库，常用于Linux，例如libc.so；
• WinDLL，Windows动态链接库，只用于Windows系统；
• OleDLL，Windows系统中的OLE动态练级库，只用于Windows系统；
• PyDLL，与CDLL类似，但是会抛出Python的异常。

假设现在有一个stdcall格式定义的动态链接库test.dll，其定义为：

extern "C"
{
	int _stdcall test(void* p, int len)
	{
		return len;
	}
}

那么在Windows系统中可以按照以下方式调用：

import ctypes
dll = ctypes.windll.LoadLibrary('test.dll')
buf = 'abcdefg'
pStr = ctypes.c_char_p()
pStr.value = buf
ret = dll.test(ctypes.cast(pStr, ctypes.c_void_p).value, pStr.value)
print(ret)

如果动态链接库test.dll（Linux中为test.so）的定义是使用cdecl格式定义的，如：

extern "C"
{
	int _cdecl test(void* p, int len)
	{
		return len;
	}
}

则需要使用相应的类型去调用：

import ctypes
dll = ctypes.cdll.LoadLibrary('test.so')
buf = 'abcdefg'
pStr = ctypes.c_char_p()
pStr.value = buf
ret = dll.test(ctypes.cast(pStr, ctypes.c_void_p).value, pStr.value)
print(ret)

老牌ORM：SQLAlchemy

在Python的世界里，最著名的ORM框架就是SQLAlchemy。

假设现在有数据表user和role，这里将主要以这两个表为例来说明SQLAlchemy的使用。

CREATE TABLE user (
	id varchar(200) not null primary key,
	name varchar(200) not null,
	pass varchar(50) not null,
	age int default 0
)

CREATE TABLE role (
	id int not null primary key,
	user_id varchar(200) not null,
	role varchar(20) not null
)

使用SQLAlchemy主要有以下几步。

• 导入SQLAlchemy，并初始化DBSession；
• 完成具体表的结构定义；
• 使用具体表来进行具体数据的操作。

下面来详细介绍每一步的具体实现。

连接数据库

SQLAlchemy的数据库连接是先定义engine，再由engine定义session。engine的定义可以使用以下语句。

from sqlalchemy import create_engine
engine = create_engine('mysql+mysqlconnector://root:password@localhost:3306/test')

create_engine()接受一个连接串作为参数，连接串的格式为：数据库类型+数据库驱动名称://用户名:口令@服务地址:端口号/数据库名。如果需要连接池支持，可以在create_engine()中使用pool_size来定义连接池大小；此外还可以使用max_overflow、pool_recycle、pool_timeout等来定义相关的连接池特性。如果需要更换连接池实现需要用poolclass来指定使用何种特性的连接池，连接池的实现可以从sqlalchemy.pool中寻找。

定义engine之后，可以使用以下语句建立适用的Session类。

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)

之后就可以使用session = Session()来获得用于数据库操作的连接会话了。连接会话是用来缓存所有数据库操作的缓存区，在其中对数据表的修改，会在会话提交时采用事务完成数据的更新。

表映射定义

表的映射定义有两种模式：声明式定义（SQLAlchemy ORM）和经典式定义（SQLAlchemy Core）。

声明式定义

声明式定义的表映射需要继承一个基类，这个基类是固定的，可以使用以下语句获得。

from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()

之后就可以用来定义映射类了。

from sqlalchemy import Column, String, Integer

class User(Base):
	__tablename__ = 'user'
	
	id = Column(String(200), primary_key=True, nullable=False)
	name = Column(String(200), nullable=False)
	password = Column('pass', String(50), nullable=False)
	age = Column(Integer)

Column()的第一个参数是指定要映射的数据表列名，这里可以允许映射类的属性与数据表列名不一致。如果不指定列名，则会使用映射类属性名作为数据表列名。

映射类中还可以存在一个__mapper_args__属性，这个属性的类型是一个字典，用以对映射进行配置。这个属性常用的配置项有：

• column_prefix，指定列名前缀。
• include_properties，列表类型，用来指定要映射的属性。
• exclude)properties，列表类型，用来指定不进行映射的属性。
• primary_key，列表类型，用来指定表的主键列。
• polymorphic_identity，字符串类型，用来指定区分值，用于单表存储按照类型区分的多个映射类，每个子类都需要指定。
• polymorphic_on，Column类型，用来指定用于区分多个映射的列，只需要在基类中指定。

经典式定义

经典式定义的表映射则是需要将表描述与映射类手工绑定，上一节的映射示例使用经典式定义则是下面这样的景象。

from sqlalchemy import Table, MetaData, Column, Integer, String
from sqlalchemy.orm import mapper

metadata = MetaData()

user = Table('user', metadata, 
	Column('id', String(200), primary_key=True, nullable=False),
	Column('name', String(200), nullable=False),
	Column('pass', String(50), nullable=False),
	Column('age', Integer)
)

class User(object):
	def __init__(self, id, name, pass, age):
		self.id = id
		self.name = name
		self.password = pass
		self.age = age

mapper(User, user)

在表映射定义上，声明式定义已经简洁了很多，这里就不再对经典式定义过多介绍了，后文也主要以声明式定义为主。

计算列

计算列有两种定义方式，一种是使用修饰器，一种是使用column_property。

以下使用修饰器定义了一个用户表示字段。

from sqlalchemy.ext.hybrid import hybrid_property

class User(Base):
	__tablename__ = 'user'
	
	id = Column(String(200), primary_key=True, nullable=False)
	name = Column(String(200), nullable=False)
	password = Column('pass', String(50), nullable=False)
	age = Column(Integer)
	
	@hybrid_property
	def standardname(self):
		return "[{}]{}".format(self.id, self.name)

而使用column_property则更加简单一些。

from sqlalchemy.orm import column_property

class User(Base):
	__tablename__ = 'user'
	
	id = Column(String(200), primary_key=True, nullable=False)
	name = Column(String(200), nullable=False)
	password = Column('pass', String(50), nullable=False)
	age = Column(Integer)
	standardname = column_property("[{}]{}".format(id, name))

一对多映射

SQLAlchemy中的关联映射并不复杂，只需要逐项定义关联项即可。前面给出的两个表，即是一个一对多的经典关联，下面就利用这两个表来演示一对多映射的定义方法。

from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
	__tablename__ = 'user'
	
	id = Column(String(200), primary_key=True, nullable=False)
	name = Column(String(200), nullable=False)
	password = Column('pass', String(50), nullable=False)
	age = Column(Integer)
	roles = relationship("Role")

class Role(Base):
	__tablename__ = 'role'
	
	id = Column(Integer, primary_key=True, nullable=False),
	user_id = Column(String(200), nullable=False, ForeignKey('user.id'))
	role = Column(String(20), nullable=False)

使用relationship()可以定义指定属性为关联属性，建立单向的关联关系，示例中使用back_populates参数将关联关系指向了对向的属性，从而就建立了双向关联关系。这个参数可以根据需要选择使用。当relationship()只关联单一的字段时，可以使用backref参数来指定逆向关联，该关联是在内存中实现的，使用backref可以不必在被映射的对方定义关联字段。

ForeignKey()函数给映射列指出了其参考的外键列，外键列使用表名.列名的方式表示。外键列不需要在数据库中声明为外键，这里只需要虚拟的设定外键即可。

在一对多映射中，外键一般都放置在子表中，来与主表建立关联。relationship()放置在主表来代表子表的实例集合。

对于关联常用的级联操作，可以使用cascade参数在relationship()函数中定义，需要级联的功能使用英文逗号隔开连接成字符串即可，例如cascade=""save-update, merge, delete"。对于使用backref定义的逆向关联，可以使用cascade_backrefs来定义是否使用逆向级联操作。

常用的级联操作有：

• save-update
• delete
• delete-orphan
• merge
• refresh-expire
• expunge

多对一映射

其实在形成一对多映射时，子表对于主表的关联就可以同时形成多对一的映射关系。多对一的映射通常将外键设置在主表中，relationship()也在主表声明，来定义对子表的关联。

同样使用back_populates可以建立双向的关联，这与一对多的关系是相同的。

一对一映射

realtionship()默认会创建使用列表的“多”映射，如果是一对一映射，就需要在不需要出现列表的一方的relationship()中使用uselist参数来将其转换成单一属性。

也就是说，谁那一方的属性应该是单数，就在谁的relationship()中添加uselist=False参数。

多对多映射

多对多映射通常会用到中间表来定义关联关系，这在映射定义时，就需要在relationship()中定义secondary参数。例如以下关联映射的定义：

association_table = Table('association', Base.metadata,
	Column('left', Integer, ForeignKey('left.id')),
	Column('right', Integer, ForeignKey('right.id'))
)

class Left(Base):
	__tablename__ = 'left'
	
	id = Column(Integer, primary_key=True)
	right = relationship('Right', secondary=association_table, backref="left")

class Right(Base):
	__tablename__ = 'right'
	
	id = Column(Integer, primary_key=True)

其中Left中的secondary参数指定了多对多映射使用的中间表，并且使用了backref在Right中定义了映射字段left来完成双向映射。

当中间表中还有其他要使用的字段时，可以将中间表也定义为一个类，此时上例就变成了下面这样。

class Association(Base):
	__tablename__  = 'association_table'
	
	left_id = Column('left', Integer, ForeignKey('left.id'), primary_key=True)
	right_id = Column('right', Integer, ForeignKey('right.id'), primary_key=True)
	extra_data = Column(String(200))
	right = realationship('Right')

class Left(Base):
	__tablename__ = 'left'
	
	id = Column(Integer, primary_key=True)
	right = realtionship('Association')

class Right(Base):
	__tablename__ = 'right'
	
	id = Column(Integer, primary_key=True)

自关联映射

在数据表设计的时候，经常会使用数据表自己与自己关联来产生级联数据，这种情况下就不能使用前面的关联方法。如果使用前面的一对多的映射方法，就会得到一个异常。这时就需要relationship()函数的另一个参数remote_side来定义循环映射主键。

class Node(Base):
	__tablename__ = 'node'
	
	id = Column(Integer, primary_key=True),
	parent_id = Column(Integer, ForeignKey('node.id'))
	data = Column(String(100))
	children = relationship('Node', remote_side=[id])

示例中定义了一个单向的映射，如果需要改为双向映射，只需要将关联映射一句改为children = relationship('Node', backref=backref('parent', remote_side=[id]))。

如果存在多个键的复杂自关联映射，则需要将关联键都列举在remote_side中。

自定义关联条件

在默认情况下，关联条件都是采用相等的处理方式。但是个别情况下可能会使用其他的关联方式，比如like或者是数组包含（PostgreSQL支持的操作）等。在这种情况下可以使用relationship()的primaryjoin参数来指定关联条件。

primaryjoin接受一个布尔表达式。

from sqlalchemy.orm import foreign, remote

class Host(Base):
	__tablename__ = 'host'
	
	id = Column(Integer, primary_key=True)
	ip_address = COlumn(INET)
	content = Column(String(50))
	
	parent_host = relationship('Host', primaryjoin=remote(ip_address) == cast(foreign(content), INET))

如果是使用PostgreSQL的特殊比较操作符，则需要使用op方法，格式为属性名.op('操作符', is_comparision=True)(外表字段)。例如：

class IPA(Base):
	__tablename__ = 'ip_address'
	
	id = Column(Integer, primary_key=True)
	v4address = Column(INET)
	
	network = relationship('Network', 
		primaryjoin="IPA.v4address.op('<<', is_comparision=True)(foreign(Network.v4representation))",
		viewonly=True
	)

class Network(Base):
	__tablename__ = 'network'
	
	id = Column(Integer, primary_key=True)
	v4representation = Column(CIDR)

数据查询

进行数据查询之前，需要先按照前文的方法获取一个数据库连接会话，在Web服务等需要并行数据库操作的情况下建议使用连接池进行操作。

Query对象代表着一个查询，这是由Session的query()方法创建的。query()方法中可以列举要查询的类名称，或者类属性名称，例如session.query(User)或者session.query(User.id)。如果是采用经典式模型定义，则Query对象是由模型的查询方法创建的。Query对象返回的查询结果都是命名元组类型的，命名元组的键都是各个类中定义的字段。如果排列了多个查询内容，则会使用类名称或者属性名称。具体可参考以下示例：

for row in session.query(User, User.name).all():
	print(row.User, row.name)

使用sqlalchemy.orm模块中的aliased()函数可以为查询目标定义别名，定义之后需要使用别名在查询中进行访问。

查询筛选

筛选条件是查询中的主要内容，也是最常用的内容。Query对象使用filter()方法来对查询目标进行过滤，filter()方法接受一个布尔表达式。多个filter()方法连续使用表示各个筛选条件之间以and连接。此外还可以从sqlalchemy模块中引入and_()和or_()方法来组装and和or条件。

大部分条件都定义在Column对象上，常用的有：

• query.filter(User.id == id)，判断相等；
• query.filter(User.id != id)，判断不相等；
• query.filter(User.name.like('%th%'))，区分大小写的LIKE判断；
• query.filter(User.name.ilike('%th%'))，不区分大小写的LIKE判断；
• query.filter(User.name.in_(['jack', 'kate']))，是否在列表或者子查询中的判断；
• query.filter(~User.name.in_(['jack', 'kate']))，是否不在列表或者子查询中的判断；
• query.filter(User.name.is_(None))，判断是否为空；
• query.filter(User.name.isnot(None))，判断是否为非空；
• query.filter(and_(User.name == 'a', User.age < 20))，AND条件联合；
• query.filter(User.name == 'a', User.age < 20)，AND条件联合；
• query.filter(User.name == 'a').filter(User.age < 20)，AND条件联合；
• query.filter(or_(User.name == 'a', User.age < 20))，OR条件联合。

还可以直接使用原生SQL文字来书写比较繁琐的查询条件，如果其中需要参数，可以使用params()方法传递相应的参数进去。例如：

session.query(User).filter(text('age>:minage and age<:maxage')).params(minage=10, maxage=25).all()

获取查询内容

查询需要使用以下方法来获取查询的结果。

• .all()，获取全部结果，返回一个列表；
• .first()，获取第一条数据，返回一个表示行的命名元组；
• .one()，获取一条数据，如果结果不唯一或者无结果会报错；
• .one_or_none()，获取一条数据，如果结果为空不会报错；
• .scalar()，与.one()类似，但返回第一列的内容；
• .count()，返回结果集长度。

对于排序和分组，可以使用Query对象的.order_by()和.group_by()方法，使用方式很简单，只需要传入要操作的列即可。.order_by()默认采用升序排列，如果需要降序，可以使用Column类中的.desc()方法来声明，当然升序也可以使用.asc()方法来显式声明。例如：query.order_by(User.age.desc())。

关联查询

关联查询是数据库查询的一项重要内容。SQLAlchemy提供了多种方法来完成关联查询。

如果不打算使用显式的.join()方法，可以直接将要关联查询的映射类都放在.query()方法中。SQLAlchemy将返回条件合适的元组供使用。例如：

for u, r in session.query(User, Role).filter(User.id==Role.user_id).all();
	print(u)
	print(r)

如果使用.join()方法，则会将被关联的子表结果放在定义的关联映射里。

for u in session.query(User).join(Role).all():
	print(u)

.join()方法还有若干使用方式，可以自动推断如何建立关联。

• query.join(Role, User.id==Role.user_id)，显式条件关联；
• query.join(User.roles)，从左至右的关联定义；
• query.join(Role, User.roles)，同上，显式指定关联目标；
• query.join('roles')，同上，以字符串指定关联目标。

数据修改

仅能完成数据查询是不够的，数据库连接会话提供了一系列的功能来完成数据修改功能。对于数据的修改，基本上都是针对保存有数据的映射类的实例来操作的。

Session类使用add()来添加一个映射类实例，使用add_all()来添加一个映射类实例列表以完成批量添加功能。

当查询到一个结果后，可以对这个结果进行修改，来完成数据更新的功能。

对一条记录的删除，则是使用.delete()方法提供的。此外还可以使用Query对象的.delete()方法来删除数据。例如：

session.query(User).filter(User.pending_delete == 1).delete()

对Session类实例监管下的映射类实例的任何添加和修改操作，都会使Session类实例进入dirty状态，这意味着Session缓存了全部的修改内容，需要进一步操作来将其同步到数据库。

调用Session类的.commit()方法可以将全部修改内容提交到数据库，而使用.rollback()方法可以撤销全部修改。这与事务操作基本一致。

执行原生SQL语句

原生SQL语句可以通过Engine、Connection、Session类实例中的.execute()方法来执行。由于一般会需要将要执行的方法排入事务，所以建议在Session类实例中执行SQL语句。

SQLAlchemy支持建立动态SQL语句，并在执行时动态绑定参数。要完成这个功能，首先要文本SQL模板，这是由sqlalchemy.sql模块中的text()函数提供的。文本SQL模板可以直接在.execute()方法中执行，并使用一个字典来向其中传递参数。执行原生SQL语句时，要尽量使用文本SQL模板和绑定参数的方式，这种方式可以在一定程度上避免SQL注入攻击。

以下示例给了一个执行原生SQL语句的参考。

from sqlalchemy.sql import text

sql_cmd = text("SELECT user_id, user_name FROM users WHERE user_id=:id")
rows = db.session.execute(sql_cmd, {'id': 1})

文本SQL模板中使用“:param_name”的格式来声明参数，注意在书写时不要丢掉冒号。在.execute()方法传递参数时，参数名需要作为键名，但不要加入冒号。SQLAlchemy会在执行时自动判定传递参数的类型。

.execute()方法会返回一个ResultProxy类的实例，其中可以使用.fetchone()、.fetchall()、.fetchmany()、.first()等方法返回RowProxy实例或者RowProxy实例序列。RowProxy实例可以直接通过使用数据表列名作为键名来访问其中的数据，也可以直接使用dict()将其转换为字典实例，或者使用list()、tuple()来转换成值列表或者值元组。

例如继续上例的内容对返回的结果集进行处理。

# 将整个结果集转换为字典序列
results = [dict(row) for row in rows.fetchall()]

# 只将指定列的内容取出作为序列
usernames = [row["user_name"] for row in rows.fetchall()]


# 取出第一行结果，之后关闭结果集
# .scalar()在结果集为空的时候，会返回None
user = dict(rows.scalar())

ResultProxy实例中是否包含数据库返回的记录，可以使用.returns_rows属性判断，这个属性是只读的。ResultProxy实例在使用完毕后，要记得使用.close()方法关闭，直接关闭数据库连接或者会话并不能使ResultProxy关闭，它还会继续返回空白结果集。

调用存储过程

虽然存储过程已经不再是推荐选项，但是很多时刻依旧会使用到，在SQLAlchemy中调用存储过程不是一件十分容易的事情，因为SQLAlchemy主要的目标是ORM，但存储过程返回的内容并不像数据表那样固定。所以在SQLAlchemy中调用存储过程更多的是使用原生数据库连接去完成。以下给出一个使用原生连接执行存储过程的示例。

connection = engine.raw_connection()
try:
	cursor = connection.cursor()
	cursor.callproc("my_procedure", ['x', 'y', 'z'])
	results = list(cursor.fetchall())
	cursor.close()
	connection.commit()
finally:
	connection.close()

注意，.callproc()方法调用存储过程时，不能使用OUTPUT返回数据。如果需要返回数据，需要使用原生SQL来调用存储过程，即使用db.session.execute()完成调用。

对于原生数据库功能DBAPI的使用，可以参考相关的Python文档。

操作Redis

Redis是一个key-value（键值）存储系统，与Memcache类似，常用于对数据进行缓存以提高数据存取命中率，降低数据的存取时间。相比Memcache，Redis支持更多的数据类型，主要包括：string（字符串）、list（列表）、set（集合）、zset（有序集合）和hash（键值表）。Redis在很多场合中可以对关系型数据库起到很好的补充作用，并在常用的主流语言中都提供客户端，使用十分方便。

在Python中操作Redis可以直接使用redis库，只需要运行pip install redis即可完成redis库的安装并在程序中使用。

连接数据库

redis库提供了StrictRedis和Redis两个类来建立Redis数据库的连接，但是请注意，在新版的redis库中，StrictRedis类已经被废弃并成为了Redis类的别名，所以这两个类现在是执行相同的功能。

建立数据库连接可以使用以下两种方式：

import redis


# 以默认方式连接到数据库
connection = redis.Redis(host='localhost', port=6379, db=0)
# 以URL方式连接到的数据库
connection = redis.Redis.from_url('redis://@localhost:6379/0')

Redis类提供的数据库连接本身是线程安全的，可以将连接放到程序自身的一个模块中来引用使用。除此之外redis库还提供了连接池，同样是线程安全的，可以按照以下方式来使用。

import redis


# 以默认方式建立连接池
pool = redis.ConnectionPool(host='localhost', port=6379, db=0)
# 以URL方式建立连接池
pool = redis.ConnectionPool.from_url('redis://@localhost:6379/0')

# 使用连接池建立数据库连接
connection = redis.Redis(connection_pool=pool)

redis库在每次执行请求时都会创建和断开一次连接操作，这在进行多次请求时效率不高，所以redis库提供了管道（pipline）功能来一次性指定全部请求命令。使用格式示例如下：

import redis


pool = redis.ConnectionPool(host='localhost', port=6379, db=0)
connection = redis.Redis(connection_pool=pool)
pipe = connection.pipline()

# 进行请求操作
pipe.set('name', 'jack')
# 管道可以执行链式操作
pipe.set('role', 'admin').sadd('foo', 'boo')

# 提交全部操作
pipe.execute()

操作数据的键

对于Redis的操作可以与在Python中操作字典相比较，同样都是以操作数据的键和值为主。在redis库中的Redis类中，对于各种数据的操作都是对标准Redis函数的实现，在使用时只需要直接调用相应的函数即可完成操作，所以这里针对不同的操作，都以表格方式列举函数来说明。

以下函数可以用来操作数据的键。

字符串及整型数据操作

字符串与整型是Redis中比较基本的数据类型。以下方法可以用来操作这些类型的值。

列表类型数据操作

一个键中除了可以存放基本数据类型以外，还可以存放列表、集合等符合数据类型，以下方法可以用来操作列表类型的值。其基本上都有一个共同的特征，方法名中都包含l字母或者r字母。

集合类型数据操作

集合类型中不能存在重复的值，并可以进行集合运算。集合通常有无序集合和有序集合两种，无序集合的方法通常以字母s开头，而有序集合的方法通常以字母z开头。以下方法常用来操作集合类型数据。

键值表数据操作

键值表类型在Redis中称为hash类型，可以理解为Python中的字典类型。操作键值表的方法通常以字母h开头。以下方法常用来操作键值表类型数据。

科学计算：NumPy和SciPy

NumPy是Python的开源数值计算扩展，可以用来存储和处理大型矩阵，并且比Python内置数据结构要高效的多。它主要提供了许多高级数值编程工具，例如：矩阵计算、矢量处理、精密运算等，专门为进行严格的数字处理而生，在很多大型金融公司以及科学计算组织（如NASA）中大规模使用。

SciPy建立在NumPy基础上，提供了大量科学算法，例如：特殊函数、积分、最优化、傅里叶变换、信号处理、线性代数等。

数据类型

NumPy支持比Python更多的数据类型，详细可见下表。

NumPy的数据类型一般采用np.float32的格式使用。

数据类型对象描述了应用于数组的固定内存块的解释，主要包括以下几个方面的内容：

• 数据类型；
• 数据大小；
• 字节序；
• 结构化类型的字段名称，每个字段的数据类型以及每个字段占用的内存块部分；
• 子序列的形状和数据类型。

数据类型对象，可以由numpy.dtype(object, align, copy)方法构造，其中，align参数表示是否像C的结构体一样在字段间添加间隔，copy参数表示是否要生成object的新副本，否则将使用引用。

Ndarray

NumPy中定义的最重要的类就是Ndarray，这是一个N维数组类型，用以描述相同类型的元素集合，其索引起始于0，可以认为Ndarray表示的是一个矩阵。Ndarray中的每个元素在内存中都使用相同大小的块。从Ndarray中提取的任何元素都是由一个数组标量类型的Python对象表示。Ndarray的实例可以通过不同的数组创建函数来构造，最基本的是使用numpy.array()方法。

numpy.array()可以从任何暴露数组接口的对象以及从返回数组的任何方法创建Ndarray。其完整格式为：

numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)

其各项参数的含义是：

• object，用于构造Ndarray的原始序列；
• dtype，数组内存储的数据的数据类型，可选；
• copy，是否复制对象，可选，默认为True；
• order，元素在内存中的排列方式，可以指定C（按行排列，C语言风格）、F（按列排列，Fortran和MATLAB的风格）、A（任意，默认风格）；
• subok，返回数组被强制为基类数组，否则返回子类；
• ndmin，返回数组的最小维数。

除了numpy.array()之外，还有以下函数可以快速的创建常用的或者经典的数组。

• numpy.empty(shape, dtype, order)，创建未初始化数组；
• numpy.zeros(shape, dtype, order)，创建零值数组；
• numpy.ones(shape, dtype, order)，创建1值数组；
• numpy.asarray(object, dtype, order)，将Python序列转换为Ndarray；
• numpy.frombuffer(buffer, dtype, count, offset)，将缓冲区内容转化为一维数组；
• numpy.fromiter(iterable, dtype, count)，从迭代对象构建一个Ndarray；
• numpy.arange(start, stop, step, dtype)，构建一个等间隔值的一维数组；
• numpy.linspace(start, stop, endpoint, retstep, dtype)，构建一个均匀间隔的指定间隔数量的一维数组；
• numpy.logspace(start, stop, num, endpoint, base, dtype)，构建一个对数刻度。

Ndarray也支持Python中的切片和索引操作，但稍有不同的是，NumPy提供一个slice()函数，允许在Python传统方法之外创建一个切片对象，并以此来进行切片操作。slice()函数可以接受三个参数，分别对应切片中的起始、终止和步长三个值。以下示例中的几种切片用法的效果都是等同的。

import numpy as np
a = np.arange(10)
s = slice(2, 9, 2)
print(a[s])
print(a[2:9:2])

Ndarray对象中的元素遵循基于零的索引，并且其切片功能是Python中切片概念延伸到多维的扩展。对于多维数组的切片，Numpy提供了更多的功能。在多维数组中，Ndarray可以在[]中使用逗号分隔的索引来选择获取多维数组中的指定位置的元素，并且也支持在指定位置使用切片语法。

import numpy as np
a = np.array([1, 2, 3], [3, 4, 5], [4, 5, 6])

print(a[1:]) # 输出[[3, 4, 5], [4, 5, 6]]，普通切片操作
print(a[..., 1]) # 输出[2, 4, 5]，取的是第二列的元素
print(a[1, ...]) # 输出[3, 4, 5]，取的是第二行的元素
print(a[..., 1:]) # 输出[[2, 3], [4, 5], [5, 6]]，取的是第二列及其剩余元素

使用省略号（...）进行切片的操作，可以选择出与数组维数相同长度的元组。如果在行位置使用省略号，将会选出包含行中元素的Ndarray。

如果在索引位置使用布尔表达式，则会使用比较运算来对元素进行筛选，例如a[a > 5]将选出全部大于5的元素并组成新的Ndarray对象。

广播

广播是指NumPy在算术运算期间处理不同形状矩阵的能力。对矩阵的算术运算通常在相应的元素上进行，如果两个矩阵具有完全相同的形状，则算术操作会被直接执行。但是如果两个数组的维数不相同，则元素到元素的操作是不可能的。此时较小的数组会广播到较大数组的大小，以便形状可以兼容。

广播需要满足以下规则：

• 维度较小的数组会在前面追加一个长度为1的维度。
• 输出数组的每个维度的大小是输入数组该维度大小的最大值。
• 如果输入在每个维度中的大小与输出大小匹配，或其值为1，则在计算中可广播。
• 如果输入的某个维度大小为1，则该维度中的第一个数据将用于该维度的所有计算。

简而言之，如果两个数组从末尾开始算起的维度的轴长度相等，或者其中一方的长度为1，则它们是广播兼容的，广播会在缺失或者长度为1的轴上进行。

最简单的广播是一维数组与常量数字之间的运算，读者可在交互式解释器中试验以下示例来观察广播运算结果。

import numpy as np
arr = np.array([1, 2, 3])
arr += 4
print(arr)

在这个示例中，虽然执行的是运算： $$ \begin{bmatrix} 1 & 2 & 3 \end{bmatrix} + 4 = \begin{bmatrix} 5 & 6 & 7 \end{bmatrix} $$

NumPy实际上进行了以下运算： $$ \begin{bmatrix} 1 & 2 & 3 \end{bmatrix} + \begin{bmatrix} 4 & 4 & 4 \end{bmatrix} = \begin{bmatrix} 5 & 6 & 7 \end{bmatrix} $$

常量数字4被自动扩展成了一个长度为3的一维数组。

对于二维数组（矩阵）与一位数组相加的操作，则会出现以下效果： $$ \begin{bmatrix} 0 & 0 & 0 \\ 1 & 1 & 1 \\ 2 & 2 & 2 \\ 3 & 3 & 3 \end{bmatrix} + \begin{bmatrix} 1 & 2 & 3 \end{bmatrix} = \begin{bmatrix} 1 & 2 & 3 \\ 2 & 3 & 4 \\ 3 & 4 & 5 \\ 4 & 5 & 6 \end{bmatrix} $$

根据广播的原则，第一个数组的形状为\((4,3)\)，第二个数组的形状为\((3,)\)，所以会在较小的轴向上发生广播，一维数组\(\bigl[\begin{smallmatrix} 1 & 2 & 3\end{smallmatrix}\bigr]\)就被扩展为了\(\bigl[\begin{smallmatrix} 1 & 2 & 3 \\ 1 & 2 & 3 \\ 1 & 2 & 3 \\ 1 & 2 & 3 \end{smallmatrix}\bigr]\)。这样就可以完成形状不同的矩阵之间的运算了，对于更高维度的数组的计算，也同样适用于这个原则。

对于在多个轴向上进行广播的情形，例如： $$ \begin{bmatrix} 0 \\ 1 \\ 2 \\ 3 \end{bmatrix} + \begin{bmatrix} 1 & 2 & 3 \end{bmatrix} = \begin{bmatrix} 1 & 2 & 3 \\ 2 & 3 & 4 \\ 3 & 4 & 5 \\ 4 & 5 & 6 \end{bmatrix} $$

读者可自行在交互式解释器中进行试验来观察广播的操作规律。

数组操作

对于Ndarray，常用的操作是迭代。除此之外还有位操作、字符串操作、算数计算、统计、排序等等。下面将选择几个比较常用的操作进行简单介绍。对于其他操作可以参考NumPy的文档，根据需要进行选择。

元素操作

操作数组时最基础的操作当属针对数组内的元素进行增删的操作，Ndarray在增删元素时没有采用Python列表的常用操作，而是提供了一系列的方法来完成相关操作。

• numpy.resize(arr, shape)，返回指定大小的新数组，如果新数组较原数组大，则原数组的一部分元素将会被重复以填充空位。
• numpy.append(arr, values, axis)，向指定数组的指定轴向上添加元素。
• numpy.insert(arr, obj, values, axis)，向指定数组的指定轴向上的指定值之前插入值。如果未提供axis参数，则输入数组会被展开。
• numpy.delete(arr, obj, axis)，返回从输入数组中删除指定子数组之后的新数组。

迭代

NumPy提供了numpy.nditer()函数用来创建一个多维迭代对象，可以使用Python的迭代操作访问。

如果两个数组都是可广播的，那么nditer组合对象就可以同时迭代它们。

变换操作

NumPy提供了以下针对Ndarray的常用变换操作。

• numpy.reshape(arr, newshape, order)，不改变数据的条件下修改形状。
  • arr参数表示要修改形状的数组；
  • newshape参数表示用于描述新形状的整数或者整数数组；
  • order参数表示元素在内存中的出现顺序，可取'C'、'F'、'A'。
• ndarray.flat，数组上的一维迭代器。
• ndarray.flatten(order)，返回折叠为一维的数组副本。
• numpy.ravel(arr, order)，返回连续的展开数组。
• numpy.transpose(arr, axes)，翻转数组维度。
  • axes接受一个整数的列表，用于对应转置的维度。
• numpy.rollaxis(arr, axis, start)，向后滚动指定轴。
  • axis参数表示要向后滚动的轴，其他轴的相对位置不会改变；
  • start参数表示滚动到的特定位置。
• numpy.swapaxes(arr, axis1, axis2)，互换数组的两个轴。
  • axis1参数表示第一个轴；
  • axis2参数表示第二个轴。
• numpy.broadcast(arr1, arr2)，产生模仿广播的对象。
  • arr1参数表示广播来源；
  • arr2参数表示广播接收目标。
• numpy.broadcast_to(arr, shape, subok)，将数组广播到新形状。
• numpy.expand_dims(arr, axis)，扩展数组的形状。
  • axis表示新轴插入的位置。
• numpy.squeeze(arr, axis)，从数组的形状中删除一个维度。
  • axis表示要删除的维度，接收一个整数或者一个整数列表。

连接与分隔

对于数组的连接，NumPy也提供了常用的几种连接方法来将多个数组连接成为一个新的数组。这里需要注意的是Ndarray是一个多维数组，在进行数据连接时需要关注连接的轴向。

• numpy.concatenate((arr1, arr2, ...), axis)，沿着指定轴向或者现有轴向连接数组。
• numpy.stack([arr1, arr2, ...], axis)，沿着指定轴向堆叠相同形状的数组序列。
• numpy.hstack(arrays)，沿水平轴堆叠相同形状的数组序列。
• numpy.vstack(arrays)，沿竖直轴堆叠相同形状的数组序列。

数组之间可以进行连接，那么也可以对一个数组进行拆分。对于数组的拆分，Numpy只提供了一个函数来实现拆分功能，另有两个衍生的快捷拆分函数，只是节省了拆分轴向的指定。

• numpy.split(arr, indices, axis)，沿指定轴向将数组分隔为子数组，返回数组列表。
  • indices可以是整数，表示要拆分成的等大小子数组数量；也可以是一维整数数组，表示进行切割的索引位置。
• numpy.hsplit(arr, indices)，水平切割数组。
• numpy.vsplit(arr, indices)，竖直切割数组。

算数运算

NumPy的算数运算功能与Python标准库中math库的一部分功能是存在重复的，可以根据喜好来使用。但是需要注意的是NumPy中提供的运算功能都是可以直接应用于Ndarray并且直接返回逐元素处理后的Ndarray的，这是Python标准库所不能企及的。

• 全部标准三角函数。
• numpy.around(arr, decimal)，逐元素进行四舍五入，decimal参数表示要保留的小数位数。
• numpy.floor(arr)，逐元素返回不大于输入参数的最大整数。
• numpy.ceil(arr)，逐元素返回输入值的上限整数。
• numpy.add(arr1, arr2)、numpy.subtract(arr1, arr2)、numpy.multiply(arr1, arr2)、numpy.divide(arr1, arr2)，加减乘除运算，要求输入的数组必须具有相同的形状或者符合数组广播规则。
• numpy.reciprocal(arr)，返回逐元素的倒数。
• numpy.power(arr, pow)，返回以逐元素为底数，pow为指数的幂。
• numpy.mod(arr1, arr2)，返回两个数组逐元素相除的余数。

统计

作为数据计算的扩展库，NumPy必然也提供了全面的统计计算功能。这里对常用的一些统计功能进行列举，具体这些统计功能的实际用途与意义还需要参考专门的统计类书籍。

• numpy.amin(arr, axis)，沿指定轴向返回最小值。
• numpy.amax(arr, axis)，沿指定轴向返回最大值。
• numpy.ptp(arr, axis)，沿指定轴向返回值的范围。
• numpy.percentile(arr, q, axis)，百分位数是统计中使用的度量，表示将数组从小到大排序，并将样本值区间划分为100等分，某一百分位所对应的数据就成为这一百分位的百分位数。q值表示要计算的百分位数。
• numpy.median(arr, axis)，获取将数组的上半部分与下半部分分开的中值。
• numpy.mean(arr, axis)，获取数组的算术平均值。
• numpy.average(arr, weights, returned, axis)，计算数组的加权平均值，其中weights是与数组相同长度用于表示数组元素权重的权重数组。returned参数用于指示是否返回权重的和。
• numpy.std(arr, axis)，计算标准差，即\(\sigma=\sqrt{\frac{\sum_{i=1}^{N}(x_{i}-\overline{x})^{2}}{N}}\)。
• numpy.var(arr, axis)，计算方差，即\(\sigma^{2}=\frac{\sum_{i=1}^{N}(x_{i}-\overline{x})^{2}}{N}\)。

排序

排序也是对数组中的元素经常要做的一种操作，NumPy提供了三种排序算法可供使用，这三种算法都具有不同的性能和稳定性。

NumPy提供了以下排序函数来对数组进行排序。

• numpy.sort(arr, axis, kind, order)，其中kind用于指定要使用的排序算法，默认会使用quicksort。
• numpy.argsort(arr, axis, kind)，沿给定轴向进行间接排序，并使用指定排序算法返回数据的索引数组。
• numpy.lexsort(arr, axis)，使用键序列执行间接排序，返回一个索引数组。

搜索

搜索是NumPy中较为神奇的一个功能。Ndarray可以使用numpy.where()函数返回的索引序列来获取满足条件的元素，并形成一个新的Ndarray。

numpy.where()接受一个布尔表达式来形成索引序列。具体可见以下示例。

import numpy as np
arr = np.arange(9.)
condi = np.where(arr > 3)
print(arr[condi])
# 以下使用索引的语法也可以达到同样的效果
print(arr[arr > 3])

线性代数

线性代数的计算也是NumPy中的一个重要功能，这里仅针对常用的矩阵计算列举常用的重要功能。线性代数计算功能一般都包含在numpy.linalg模块中，如果有实际使用需要可以参考相关模块文档。

• numpy.dot(arr1, arr2)，计算两个数组的点积，对于矩阵等效于矩阵乘法，对于一维数组是向量的内积。
• numpy.vdot(arr1, arr2)，计算两个向量的点积。如果第一个参数是复数，则会使用其共轭复数进行计算；多维数组会被展开。
• numpy.inner(arr1, arr2)，计算一维数组的向量内积。对于多维数组，只返回最后一个轴上的向量内积。
• numpy.matmul(arr1, arr2)，计算两个数组的矩阵乘积。对于大于二维的数组，会将其视为存在于最后两个索引的矩阵的栈并进行广播。对于一维数组会自动进行升维，并在计算后降维。
• numpy.linalg.det(arr)，计算矩阵的行列式，对于矩阵\(\bigl[\begin{smallmatrix} a & b \\ c & d \end{smallmatrix}\bigr]\)，其行列式计算为\(ad-bc\)。较大的矩阵会被认为是\(2\times 2\)矩阵的组合。
• numpy.linalg.inv(arr)，计算矩阵的逆。
• numpy.linalg.solve(a, b)，计算矩阵形式线性方程的解。例如有以下线性方程组：

$$ \begin{cases} x+y+z=6 \\ 2y+5z=-4 \\ 2x+5y-z=27 \end{cases} $$

可以转化为矩阵形式：

$$ \begin{bmatrix} 1 & 1 & 1 \\ 0 & 2 & 5 \\ 2 & 5 & -1 \end{bmatrix}\begin{bmatrix} x \\ y \\ z \end{bmatrix}=\begin{bmatrix} 6 \\ -4 \\ 27 \end{bmatrix} $$

也即是\(AX=B\)的形式，求解即是根据\(A\)和\(B\)来求出\(X\)。

SciPy各子包功能

SciPy中面对不同科学计算领域的功能被组织成了不同的子包。

SciPy在使用时，其基础数据结构依然为NumPy提供的Ndarray。与NumPy相比，SciPy中有一些基本代数功能是有重复的，但是实际功能并不相同，这点需要注意。

积分

SciPy提供了许多用于执行数值积分（定积分）的函数，其中大部分都位于scipy.integrate子包中。以下介绍几个比较常用的积分函数。

• scipy.integrate.quad(f, a, b)，单定积分函数，其公式形式为\(\int_{a}^{b}f(x)dx\)。

其中f是要积分的函数名称，可以是Lambda表达式；a和b分别是定积分的下限和上限，传递给单积分函数的上限与下限可以是正无穷和负无穷。例如计算以下定积分

$$\int_{0}^{1}e^{-x^{2}}dx$$

可以参考以下示例。

import scipy.integrate
from numpy import exp
f = lambda x: exp(-x ** 2)
i = scipy.integrate.quad(f, 0, 1)
print(i)

quad()函数返回两个值，其中第一个值是积分值，第二个值为积分值绝对误差的估计值。

• scipy.integrate.dblquad(f, a, b, g, h)，双重定积分函数，其公式形式为\(\int_{a}^{b}dy\int_{g(y)}^{h(y)}f(x,y)dx\)。

其中f是要积分的函数名称，a和b是变量$x$的下限和上限，而g和h则是定义变量$y$的下限和上限的函数名称。

例如计算双重定积分\(\int_{0}^{\frac{1}{2}}dy\int_{0}^{\sqrt{1-4y^2}}16xydx\)可以使用以下例程。

import scipy.integrate
from numpy import exp
from math import sqrt
f = lambda x, y: 16 * x * y
g = lambda x: 0
h = lambda y: sqrt(1 - 4 * y ** 2)
i = scipy.integrate.dblquad(f, 0, 0.5, g, h)
print(i)

• scipy.integrate.tplquad()，三重定积分函数。
• scipy.integrate.nquad()，多重定积分函数。

三重定积分和多重定积分两个函数的使用方法可以参考SciPy的文档，其基本使用方法与单定积分和双重定积分相似，只是参数更多。

数据分析：Pandas

Pandas是基于Numpy的一种用于解决数据分析任务的数据分析包，最初是作为金融数据分析工具而存在的。Pandas纳入了大量库以及标准数据模型，并提供了高效操作大型数据集所需的工具，还有大量能使我们快速处理数据的函数和方法，这使得Pandas为Python添加了强大而高效的数据分析能力。

核心数据结构

Pandas的核心数据结构有两个，Series和DataFrame。

其中Series是一个带标签的一维同构类型数组。而DataFrame是一个二维表格结构可以包含异构数据列的类型。可以认为DataFrame是Series的容器。

Series

Series是能够保存任何类型数据的一维数组，其轴标签统称为索引。Series可以通过pandas.Series(data, index, dtype, copy)构造函数来创建。构造函数中的各个参数的含义及使用方法如下：

• data，Series中存储的数据，可以采用各种格式如Numpy的ndarray、list、常量值等。
• index，数据的索引列表。索引值必须是唯一和散列的，索引列表的长度与数据的长度要相同。
• dtype，数据的类型，如果未显式声明类型，则自动推断数据的类型。
• copy，是否复制数据，默认为False。

以下示例从Numpy的ndarray中创建了一个Series。

import pandas as pd
import numpy as np
data = np.array(['a', 'b', 'c', 'd'])
s = pd.Series(data, index=[101, 102, 103, 104])
print(s)

字典也可以被用来创建Series，如果没有指定索引，则按照字典中内容的排列顺序取得字典的键来构造索引，如果传递了索引，则按照索引的顺序拉取字典中对应键的值来组建数据。可在交互式解释器中执行以下两段代码以观察区别。

# 不传递索引，使用字典默认顺序
import pandas as pd
data = {'a': 0., 'b': 1., 'c': 2.}
s = pd.Series(data)
print(s)

# 传递索引，使用索引顺序构建数据
import pandas as pd
data = {'a': 0., 'b': 1., 'c': 2.}
s = pd.Series(data, index=['b', 'c', 'd', 'a'])
print(s)

使用常量值来创建Series时，必须提供索引，Series将按照索引的长度，重复常量值来填充数据。例如s = pandas.Series(4, index=[0, 1, 2, 3])。

Series中的数据可以使用与列表相似的下标来访问，并且也支持切片。在指定索引之后，还支持使用索引来访问指定位置的数据，但并不局限于获取单一的一个数据。例如：

from pandas import Series
s = Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
# 获取单一元素，返回元素本身
print(s['a'])
# 获取多个元素，返回一个新的Series
print(s[['a', 'c', 'd']])

如果试图获取不存在的索引，Pandas将会抛出KeyError异常。

DataFrame

DataFrame是一个数据以行和列方式排列的二维表格数据结构。在DataFrame中，各列可以是不同的数据类型，并且行列大小都是可变的。DataFrame可以对其中的行和列进行算术运算。DataFrame可以使用构造函数pandas.DataFrame(data, index, columns, dtype, copy)来创建，该函数中大部分参数都与Series相同，其参数的主要含义如下：

• data，DataFrame中的储存的数据，可以采用ndarray、Series、map、lists、dict、DataFrame或者是常量值来定义。
• index，行标签定义，用于定义行索引。其长度要与数据中行总数相同。默认会使用数字序列索引。
• columns，列标签定义，用于定义列索引。其长度要与数据行中的元素数量相同。默认会使用数字序列索引。
• dtype，定义每列的数据类型。
• copy，是否复制数据，默认为False。

DataFrame的创建要较Series复杂许多，一般常用列表、字典、Series、ndarrays和DataFrame来创建。

使用列表来创建DataFrame时，列表的每一个元素都对应DataFrame中的一个数据行。例如以下示例。

import pandas as pd
data = [1, 2, 3, 4, 5]
df = pd.DataFrame(data)
print(df)

其输出的结果是下面这个样子。

	0
0	1
1	2
2	3
3	4
4	5

使用比较复杂的二维列表可以创建比较复杂的DataFrame，例如下面这样的表格。

import pandas as pd
data = [['Kate', 95], ['Lily', 90], ['May', 89]]
df = pd.DataFrame(data, columns=['Name', 'Score'])
print(df)

这个示例则会输出以下表格的样子。

	Name	Score
0	Kate	95
1	Lily	90
2	May		89

示例中使用columns参数给数据行中的每个列都建立了标签，并且形成了熟悉的表格样式数据结构。

除此之外，列标签还可以使用字典来设定，下面使用以上数据来看一下使用字典如何创建DataFrame。

import pandas as pd
data = {'Name': ['Kate', 'Lily', 'May'], 'Score': [95, 90, 89]}
df = pd.DataFrame(data)
print(df)

这个示例会得到与前一个示例同样的结果。读者可以自行比较其异同点。使用字典来创建DataFrame还有一种更为复杂的方法，但是在一些情况下可能更为适用，那就是使用字典列表来作为数据源。同样使用以上数据，来看以下使用自点列表作为数据源的示例。

import pandas as pd
data = [{'Name': 'Kate', 'Score': 95}, {'Name': 'Lily', 'Score': 90}, {'Name': 'May', 'Score': 89}]
df = pd.DataFrame(data)
# 或者可以指定更加详细的参数
df = pd.DataFrame(data, index=['1st', '2nd', '3rd'], columns=['Name', 'Score'])
print(df)

前面的所有示例中都没有给定index参数，所以所有数据列的行索引都是采用自增长整型数值的默认索引的，赋予index参数一个与数据行长度相同的列表，可以为每个数据行建立行标签，也就是自定义行索引。这个语法与columns参数的使用是相同的，可参考上例中指定详细参数的用法。

如果Columns参数指定了字典中不存在的键值，那么DataFrame将会将此列的数据记为NaN，表示这里没有任何数字内容。如果数据行之间键值也不相同，那么DataFrame将会采用所有数据行中出现的列的并集作为DataFrame的列标签，并且在每个数据行缺失的列上使用NaN补齐。这里需要注意的是，DataFrame并不是使用None来补齐数据，而是使用NaN。

除了可以使用列表的列表、字典列表、字典以外，还可以使用字典的Series、字典的ndarray等相似的数据结构来创建DataFrame，读者可以自行尝试不同的创建DataFrame的方法。

与Series类似，DataFrame可以通过dataFrame[column]的格式来访问某个数据列，并且可以对一个不存在的列标签进行赋值来创建一个新列。而删除一个数据列则需要使用.pop(column)函数或者直接使用del dataFrame[column]。

对于数据行的操作，DataFrame则提供了.loc(index)和.iloc(index)两个方法来获取数据列，其中.loc()函数使用DataFrame中实际的行标签来选择行，而.iloc()则是使用数字索引来选择行。对DataFrame使用切片操作是操作数据行，而不是数据列。要向DataFrame中增加一行数据，需要使用.append()函数，删除使用.drop(index)函数。如果DataFrame中有重名的行标签，则会全部被删除掉。

除了使用构造函数来创建DataFrame以外，Pandas还提供了以下用于读取固定格式数据源来直接创建DataFrame的函数（仅包含常用函数，非全部函数）。

以上函数的具体使用方法可参考Pandas的文档，这里不再赘述。

基本数据结构方法

Series和DataFrame中有一些共同的基本方法，主要是用来获取其存储的数据的一些内容的，这里通过一个表格来说明其功能。

统计方法

Pandas是一个专门用于数据分析的库，所以其最强大的功能在于对数据统计的支持。由于一般进行数据分析时，通常采用表格方式，所以这里主要以DataFrame为主列举常用的统计方法。

大部分统计方法都有一个参数axis，其默认值为0。在默认情况下，在DataFrame上调用统计方法，会对全部内容进行计算操作，但是可以通过指定参数axis的值来指定只需操作的列，axis参数既可以接受数字索引，也可以接受列标签名称索引。

下表中列出了常用的重要统计函数，其具体含义和使用方法可参考统计类书籍。

数据控制方法

多数情况下，对于采样的原始数据，需要进行变化、分组、排序等多种操作，来获得符合要求的采样数据。针对对原始采样数据的整理需求，Pandas也提供了一系列方法来实现。以下同样以DataFrame为主列举常用的方法。

变换函数

变换函数有管道函数.pipe()、行列变换函数.apply()和元素变换函数.applymap()三个。

.pipe()可以通过给定一个变换函数和一定数量的参数作为变换函数的参数来执行自定义变换操作，这个变换操作是针对整个DataFrame进行的。自定义的变换函数将被应用于DataFrame的每一个元素上。.pipe()函数所接收的第一个参数是自定义的变换函数，其后的参数是自定义变换函数所需的除第一个参数以外的剩余参数。.pipe()会将DataFrame中的元素作为自定义变换函数的第一个参数传递给变换函数，并使用变换函数的返回值替换相应位置的元素，并最终更新DataFrame中的全部元素。

.apply()可以沿DataFrame的任意轴上执行自定义变换函数，默认操作是按列执行，可以通过指定axis参数为1来指定按行执行。.apply()的使用与.pipe()类似，可以仿照使用。

不是所有的自定义变换函数都能够使用.pipe()应用于DataFrame的每一个元素，除了.pipe()之外，Pandas还提供了.applymap()来对DataFrame中的每一个元素应用普通变换函数，针对Series中的元素是使用.map()。.applymap()接受任何Python函数，并返回单个值。

迭代

DataFrame和Series都是支持迭代的。对于Series来说，迭代将直接输出其索引标签，而迭代DataFrame则较为复杂。

直接使用for...in...对DataFrame进行迭代，将会从DataFrame中取得其全部列名。如果需要遍历DataFrame中的行，则需要使用以下函数。

• .iteritems()，迭代键值对，格式为(key, value)。
• .iterrows()，将行迭代为键值对，格式为(key, Series)。
• .itertuples()，使用命名元组的形式迭代行。

排序

Pandas有两种排序方式，一种是按标签排序，一种是按照实际值排序。

使用.sort_index()可以按照标签进行排序，默认情况下将按照升序对行标签进行排序操作。可以通过指定axis参数来变更排序轴，ascending参数（可取True或者False）来变更排序方向。

而使用.sort_values()可以按照实际值来进行排序。.sort_values()可以接受by参数来指定参加排序的列，kind参数来指定排序算法。由于Mergesort是Pandas中比较稳定的排序算法，所以一般情况下不必特殊指定算法。

窗口

窗口（Window）用于将原始采样数据进行动态分组，使其能够组合成一定数量的样本来应用统计函数。Pandas提供了滚动、展开、指数移动等函数来建立窗口。窗口函数主要用于通过平滑曲线来以图形方式查找数据内的趋势。

滚动窗口使用.rolling()函数来建立，需要指定window参数来指定窗口中统计样本的大小。

展开窗口使用.expanding()函数来建立，需要指定min_periods参数来指定窗口中最小统计样本的大小。

.ewm()函数可以建立指数权重窗口，需要通过com、span、halflife等参数来定义权重。

聚合

聚合较为简单，主要是每列的数据进行合并操作，形成一个有代表性的统计数据的过程。聚合可以应用于DataFrame或者列，主要使用.aggregate()来完成，也可以使用其简短形式.agg()。

.aggregate()可以接受一个聚合函数，或者一个聚合函数列表。.aggregate()会使用每一个聚合函数建立一列聚合数据。例如df['A'].aggregate([np.sum, np.mean])。

.aggregate()还可以对多个列执行聚合操作，例如df[['A', 'B']].aggregate([np.sum, np.mean])。亦或者针对不同的列执行不同的聚合操作，例如df.aggregate({'A': np.sum, 'B': np.mean})，但是需要注意的是，.aggregate()中使用字典进行聚合的列，必须是DataFrame中存在的列。如果使用列表，则可以通过lambda表达式创建新的列，但是此时创建的列名称为<lambda>，需要使用.rename()进行改名。

分组

在许多情况下，需要对采样数据分成多个集合，并在每一个子集上应用统计函数。{\color{red} 需要注意分组与窗口的不同。}通常在执行分组后，还会继续执行的操作是聚合、变换以及过滤。

对采样数据进行分组拆分主要通过.groupby()函数来进行，.groupby()函数返回的结果是可以迭代为(key, DataFrame)结构的数据。.groupby()常用的拆分方式有以下几种。

• .groupby(key)，按照指定列标签来拆分。
• .groupby([key1, key2])，按照指定列标签的组合来拆分。
• .groupby(key, axis=1)，按照指定行标签来拆分。

.groupby()可以接受一个as_index参数，这个参数的默认值为True。当as_index为True时，所有参与分组的列将变为索引。如果需要继续保留参与分组的列，并且按照原先的列名进行访问，则需要将此参数设置为False。

完成分组的数据，可以通过.get_group(key)来获取一个分组的数据。而进行聚合操作，则是使用.agg()函数，而不是.aggregate()函数。

对于分组数据的转换则比较复杂，转换应该返回与组块大小相同的结果。转换使用.transform()函数完成。

.filter()函数可以接受一个函数来对已经分组的数据进行过滤，并返回符合要求的数据。

连接

Pandas具有功能全面的内存连接操作，这与关系型数据库中的连接十分相似，由于是在内存中操作，所以性能较高。对于连接操作，Pandas只提供了一个函数.merge()来实现。

.merge()的完整格式为.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=True)。以下针对出现的参数及其功能进行一个简要的说明，读者可根据SQL语言中的JOIN子句的语法特性来体会.merge()函数的功能。

• left，位于左侧的DataFrame。
• right，位于右侧的DataFrame。
• on，列的连接，指定列名必须在左右两侧的DataFrame中都存在。
• left_on，指定左侧DataFrame中的列用于键。
• right_on，参考left_on。
• left_index，如果为True，则使用左侧DataFrame中的行标签作为连接键。
• right_index，参考left_index。
• sort，按照字典顺序通过连接键对结果进行排序，默认为True。
• how，确定合并时哪些键将被包含在结果表中，如果组合键没有出现在左侧或者右侧表中，则连接表中的值为NaN。可以取以下值：
  • left，左侧外连接，使用左侧对象的键。
  • right，右侧外连接，使用右侧对象的键。
  • outer，全外连接，使用键的联合。
  • inner，内连接，使用键的交集，此项为默认值。

与SQL语法的对比

从上面几节的内容可以看出，Pandas在DataFrame上的操作与SQL十分相似。在实际应用中，DataFrame的一些特性也的确能够完成与SQL类似的查询。这里仅针对一些相似度较高的操作进行简要的介绍。

假设有一个DataFrame，其中有如下几列数据：id，client_code，type，bill，time。下面的对比都针对这几列数据来进行查询操作。

选择列查询

SQL： SELECT id, client_code, bill FROM df;

DataFrame： df[['id', 'client_code', 'bill']]

选择全部列，并只取前5行记录

SQL： SELECT * FROM df LIMIT 5;

DataFrame： df.head(5)

Where条件子句

SQL： SELECT * FROM df WHERE type='0' LIMIT 5;

DataFrame： df[df['type'] == '0'].head(5)，该语句将一系列True/False对象传递给DataFrame，并将符合条件的所有行返回True。参与筛选的条件可以使用&、|、.isin()等来表示条件联合、条件或，以及列表包含等。

GroupBy分组

SQL： SELECT type, count(*) FROM df GROUP BY type;

DataFrame： df.groupby('type').size()

带聚合的GroupBy分组

SQL： SELECT client_code, max(time) FROM df GROUP BY grade;

DataFrame： df.groupby('client_code').agg({'time': np.max})

Join

SQL： SELECT * FROM df1 LEFT JOIN df2 ON df2.id=df1.id

DataFrame： pd.merge(df1, df2, how='left', left_on='id', right_on='id')

Distinct

SQL： SELECT DISTINCT client_code, time FROM df

DataFrame： df.drop_duplicates(subset=['client_code'], keep='first', inplace=True)，其中keep表示保留哪一个值，可取first、last和False，分别表示第一个、最后一个和全部不保留。inplace参数默认为False，表示返回一个新的DataFrame，否则会在原来的DataFrame上进行修改。subset表示对哪些列进行排重。

可视化图表：Matplotlib

Matplotlib是Python中常用的数据可视化工具库，这个工具库能够创建多种数据类型的图表，比如：条形图、散点图、饼图等等。

Matplotlib可以直接使用pip完成安装，如果在导入模块时报错，需要考虑是否缺少了名为six的模块，如果是这样，就需要单独安装six模块。

以下示例应该弹出一个简单的带有坐标图形的窗口。

# macOS需要添加以下两句来配置Matplotlib使用Tk框架
import matplotlib
matplotlib.use('TkAgg')
# 以上为macOS系统使用的语句
import matplotlib.pyplot as plt
plt.plot([1,2,3], [5,7,4])
plt.show()

Matplotlib默认的视图窗口中是带有图形浏览功能的，读者可以自行探索一番。

图例和标题

在之前的例子中，通过给.plot()函数传入两个序列来给定线条的位置。但是当图形中有多条线条时，往往需要使用图例来对线条进行标记。此时可以使用.plot()的命名参数label来为线条指定名称。最后在使用.show()函数显示图形之前，要使用.legend()函数生成图例。

大部分的图形都会使用标题，Matplotlib中的图形标题使用.title()函数进行设定。标题同样要在显示图形之前设定。

条形图

前面示例中所使用的.plot()是创建折线图的函数，Matplotlib通过提供不同的图形函数来产生不同的图形。对于生成条形图，Matplotlib提供了.bar()函数。

.bar()函数常用的参数有：

• x，x轴坐标数据，序列类型。
• height，y轴数据，序列类型。
• width，形状宽度。
• color，填充颜色。

直方图

直方图与条形图类似，但是主要用来显示一组数据在指定区间中的分布情况。直方图使用.hist()函数来生成。

.hist()函数常用的参数有：

• x，输入数据。
• bins，数据分隔区间，可认为是x轴。
• histtype，条形图形状。
• rwidth，条形图的相对宽度。
• color，条形图填充颜色。
• label，图例名称。

散点图

散点图通常用于比较两个变量来寻找相关性或者分组。散点图使用.scatter()函数来生成。

.scatter()函数常用的参数有：

• x，数据x轴位置。
• y，数据y轴位置。
• s，标记的大小。
• c，标记的颜色。
• marker，标记的形状。

堆叠图

堆叠图通常用于表示部分与整体之间随时间变化的关系。堆叠图使用.stackplot()函数来生成。

.stackplot()函数常用的参数有：

• x，x轴数据。
• y，y轴数据，可包含多个序列。
• labels，每条y轴的图例名称，序列类型，要对应y轴数据数量。
• colors，每条y轴的填充颜色，序列类型，要对应y轴数据数量。

饼图

饼图通常用于显示部分对于整体的情况，通常以百分比为单位。Matplotlib在处理饼图时，会自动计算百分比，所以只需要传入实际数据即可。饼图使用.pie()函数生成。

.pie()函数常用的参数有：

• x，输入数据，序列类型。
• labels，每个数据的标签，序列类型。
• colors，每个数据对应的颜色，序列类型。
• explode，指示哪个数据从饼图中分离，并且指示分离距离，元组类型，例如(0.1,0,0,0)将分离第一个数据。
• shadow，是否绘制饼图下的阴影，布尔类型。
• autopct，饼图上绘制百分比的格式。
• startangle，绘制起始角度。

样式

样式使得自定义图形时不必书写大量的代码，只需要载入指定样式就可以直接改变图形的外观。

要使用样式，需要先导入样式模块：from matplotlib import style，之后就可以使用style.use()来指定要使用的样式了。Matplotlib已经内置了一些样式，可以通过print(plt.style.available)来查看。

样式是可以自定义的，自定义样式的方法较为繁琐，可直接参考Matplotlib的文档，这里不再赘述。

子图

子图用来在图表上创建多个图表。子图的创建有两种方式。第一种是通过add_subplot()方法，第二种是通过subplot2grid()方法。但在首先，需要先获得整个图形的实例，来对其进行操作。

要获得整个图形的实例，可以使用fig = plt.figure()来获取。

.add_subplot()方法接受一个整型数字作为参数，其工作原理是使用3个数字来指定要创建的子图位置，这3个数字分别代表行数、列数和绘图编号，例如fig.add_subplot(221)表示两行两列的第一个位置。如果行列数大于10，这三个数字需要使用逗号分开传入。

.subplot2grid()方法则更加强大，它可以使用网格来排列图表。它首先接受一个元组参数，作为网格形状，例如(6, 1)表示6行1列的网格。之后传递一个图表左上角的起始点，例如(0, 0)表示最左上角的网格。之后可以使用rowspan和colspan来定义图表所占的行数和列数。最后，subplot2grid()还可以接受一个名为sharex的参数用来指示图表共享指定图表的x轴。

实时图表

实时图表是使用了Matplotlib的动画功能，这需要引入Matplotlib的动画模块，即：import matplotlib.animation as animation。

之后与创建子图一样，需要获得图表实例并且创建子图。然后创建一个绘图函数，但是这个绘图函数中需要做子图清除以及子图绘制的动作。最后将这个绘图函数放置到动画中并启动显示。例如：

import matplotlib.pyplot as plt
import matplotlib.animation as animation

fig = plt.figure()
ax1 = fig.add_subplot(1, 1, 1)

def animate(i):
	ax1.clear() # 清除子图
	ax1.plot(x, y) # 重绘子图

ani = animation.FuncAnimation(fig, animate, interval=1000) # 设置动画
plt.show()

添加文本

向图表中添加文本主要有两种方式，第一是将文本放置在图表的某个位置上，另一个是注解图表上的绘图。

添加文本同样要使用到子图功能，文本通过.text()方法绘制到图上。首先要使用传入图标的数据来给文本指定坐标，之后可以用fontdict参数来定义文本的字体、颜色和大小。

注解文本是通过.annotate()方法来创建。注解创建函数接受的参数首先是要注解的文本，其次是注解指向的坐标。接下来要使用xytext参数来指定文本所在的坐标位置，这个坐标可以是轴域或者小数比例（代表百分比）。最后可以使用arrorprops参数来绘制箭头。注解在图表上的位置是固定的，不会随着图表的拖移而移动，但是箭头会随着变换。

内置GUI模块：Tkinter框架

Tkinter模块时Python的标准Tk GUI工具包的接口，Tkinter可以在大多数Linux系统、Windows系统和macOS系统中使用。并且可以根据所运行系统的不同，使用系统原生界面风格，兼容性十分优越。

Tkinter内置在Python的安装包中，对于简单界面和略复杂界面Tkinter可以应付自如。

最小应用

Tkinter可以直接使用import tkinter引入。以下代码显示了一个空白的窗口，是一个Tkinter的最小应用。

import tkinter
master = tkinter.Tk()
master.mainloop()

示例中，tkinter.Tk()建立了个窗口，而.mainloop()使应用进入了Tkinter的主事件循环。

另外一个略微复杂一些的最小应用是采用了类来统领窗口内容。

import tkinter as tk

class Application(tk.Frame):
	def __init__(self, master=None):
		tk.Frame.__init__(self, master)
		self.grid()
		self.create_widgets()
	
	def create_widgets(self):
		self.button_quit = tk.Button(self, text='Quit', command=self.quit)
		self.button_quit.grid()

app = Application()
app.master.title('Sample application')
app.mainloop()

示例中使用了网格布局，并且在其中添加了一个能够执行退出功能的退出按钮。在这个示例中，Application实例并不是顶级窗口，要在其中获取顶级窗口，需要调用.winfo_toplevel()。

基础概念

在开始使用Tkinter开发GUI程序之前，需要先了解以下几个基础概念。

顶级窗口

由系统桌面管理器管理的，在桌面上独立存在的窗口。

组件

GUI应用中的功能零件，例如按钮、标签，框架等。

框架

用于组织复杂布局的基础功能单元，可以用来盛放其他组件。

计量单位

如果在程序中使用一个整型值作为长宽等维度值，那么它的单位将是“点”（Pixel）。除此之外还可以在字符串中使用以下单位。

• c，centimeter，厘米。
• i，inch，英寸。
• m，millimeter，毫米。
• p，打印机的点，约\(\frac{1}{72}\ inch\)。

坐标系

Tkinter采用原点位于左上角的直角坐标系，坐标向右向下为正值。

锚点

根据组件的上下左右以及斜向的八个方位，加上中心点，组件共有9个锚点，除中心点外，分别以东南西北的缩写命名，即：N、NE、E、SE、S、SW、W、NW。

网格布局

Tkinter中有多种组件布局方式，其中网格布局是目前最为推荐的组件布局方式。要将组件加入到网格布局，需要在组件上调用.grid()方法。.grid()方法接受以下参数来定义网格布局。

参数sticky可以影响组件的大小，其取值可参考以下方式。

• 不给定sticky的值，组件以原始大小在所在网格中居中放置。
• 赋值sticky=tk.NE等单一固定值，组件将放置在所在网格的相应锚点位置。
• 赋值sticky=tk.N+tk.S将会使组件垂直方向拉伸贴近锚点并居中放置。
• 赋值sticky=tk.E+tk.W将会使组件水平方向拉伸贴近锚点并居中放置。
• 赋值sticky=tk.N+tk.E+tk.S+tk.W将会使组件在四个方向上拉伸以填满网格。
• 赋值sticky=tk.N+tk.W将会使组件在相应方向上拉伸。

在容器组件上调用.columnconfigure()和.rowconfigure()可以对指定行列进行配置。这两个方法接受的第一个参数是行列的索引，用来指定其后的配置应用在哪里。行列的配置主要由以下三项内容构成。

• minsize，最小大小，以像素值描述。
• pad，周围的留白大小。
• weight，定义行列在缩放时的缩放比例权重。

组件内容的承载

Tkinter通常使用一个控制变量来承载组件的内容以及内容的变化。Tkinter提供了三种变量的类型：DoubleVar、IntVar、StringVar，分别用于承载浮点型、整型和字符型的内容。

控制变量类提供了两个方法来获取和设置组件的内容：

• .get()，用来获取当前控制变量的值，也就是组件的值。
• .set(s)，用来设置当前控制变量的值，相关组件的内容也会同时发生改变。

常用组件

Tkinter有两种组件来源，一种是传统的来自于Tkinter模块的组件，另一种是来自ttk模块的带主题的组件。其中ttk模块中的组件兼容Tkinter模块的原生组件，但又扩展了几个新的组件。在应用设计中，可以尽量使用ttk模块的组件以获得更好的外观和功能。

通用属性

组件都具有一些通用的属性这些属性可以直接在所有组件中直接配置使用。

• text，组件上需要显示的文本内容。
• height，组件的高度，单位通常使用文字行高或者像素，ttk模块中的部分组件不支持此属性。
• width，组件的宽度，单位通常使用字母宽度或者像素。
• background或者bg，设定背景色，ttk模块中的组件不支持此属性。
• foreground或者fg，设定前景色，ttk模块中的组件不支持此属性。
• font，设定字体名称，ttk模块中的组件不支持此属性。
• cursor，鼠标指向组件时的指针样式。
• padx，额外的内部水平留白，ttk模块中的组件不支持此属性。
• pady，额外的内部垂直留白，ttk模块中的组件不支持此属性。
• padding，ttk模块中组件用于设定留白的属性。
• takefocus，控制聚焦行为。
• relief，组件的显示样式，默认是tk.FLAT，ttk模块中的组件不支持此属性。
• style，ttk模块组件中指示组件样式的属性。
• class_，ttk模块组件中组件的样式类名称。

按钮

按钮是最常用的组件，其创建格式为w = tk.Button(parent, option=value, ...)。其常用的配置属性有：

• bitmap，按钮上的标准位图，用以替代文字。
• image，按钮上的图片，用以替代文字。
• command，按钮点击后执行的函数或者方法。
• state，用以设定按钮状态，可取tk.DISABLED来禁止点击。
• textvariable，设定用于控制按钮文本的StringVar类型控制变量。

画布

画布是一个用来显示图片或者展示其他复杂布局的方形区域，在其上可以放置图片、文字、组件甚至是框架。画布的创建格式为w = tk.Canvas(parent, option=value, ...)。常用配置属性有：

• scrollregion，创建一个比可视范围更大的滚动区，使用一个元组来定义，格式为(w, n, e, s)。
• confine，设为True将不能滚动到滚动区之外。

画布能够容纳多种元素，并且支持在其上绘画，所以画布的使用较为复杂，读者可在需要使用画布时参考相关的文档。

输入框

输入框是典型的信息收集组件，允许使用者在其中输入内容。输入框的创建格式为w = tk.Entry(parent, option=value, ...)。常用的配置属性有：

• show，在输入时，输入框内显示的文字，使用show='*'可以创建密码框。
• validate，指定何时指定输入框内容的验证，可以取focus、focusin、focusout、key、all、none。
• validatecommand，指定用于验证输入框内容的方法。
• textvariable，指定用于控制输入框内容的StringVar类型控制变量。

输入框常用的方法有：

• .get()，取回输入框当前的内容。
• .delete(first, last=None)，删除输入框中指定位置或范围内的内容。

复选框

复选框用于让用户进行多项选择。其创建格式为w = tk.Checkbutton(parent, option=value, ...) 。常用的配置属性有：

• command，当用户改变复选框时执行的动作。
• indicatoron，当设为0时，整个复选框变为可切换状态的按钮。
• offvalue，当不被选中时的值。
• onvalue，当被选中时的值。
• variable，指定关联控制变量，可以是StringVar或者IntVar类型。

在使用复选框时建议使用一个类型为IntVar的控制变量来控制和获取复选框的状态。

框架

框架是最基础的组件容器，每个框架都拥有独立的网格布局管理器。并且应用可以通过继承框架来组织功能相关的组件，以实现应用的模块化。框架的创建格式为w = tk.Frame(parent, option=value, ...)。

标签

标签是用于在窗口上显示一行或者多行文字、图片的组件。标签的创建格式为w = tk.Label(parent, option=value, ...)。常用的配置属性有：

• anchor，内容的对齐位置。
• bitmap，加载标准位图，用以替代文字。
• image，加载图片，用以替代文字。
• textvariable，指定用于控制内容的控制StringVar类型控制变量。

命名框架

命名框架是一个特殊框架，其边框上可以附带一个标签。命名框架的创建格式为w = tk.LabelFrame(parent, option=value, ...)。常用的配置属性有：

• labelanchor，标签放置位置。
• labelwidget，使用非内部定义的标签组件。

列表

列表是用来按行列出数据的组件，通常用来提供用户进行单项选择或者多项选择使用。列表的创建格式为w = tk.Listbox(parent, option=value, ...)。常用的配置属性有：

• activestyle，激活行的显示样式，可选值有underline、dotbox、none。
• listvariable，指定一个用于关联全部列表内容的StringVar类型变量。
• selectmode，设定用户可选择内容的数量，可选值有tk.BROWSE、tk.SINGLE、tk.MULTIPLE、tk.EXTENDED。

常用的方法有：

• .activate(index)，激活指定行。
• .curselection()，返回当前选择的行，没有已选择的行返回空白元组。
• .delete(first, last=None)，删除指定行。
• .get(first, last=None)，返回指定行。
• .index(i)，滚动指定索引内容到列表顶端。
• .insert(i, *elements)，插入内容到指定索引位置。
• .itemconfig(index, option=value, ...)，改变指定索引内容的配置，如前景、背景等。

列表组件不包含滚动条，所以在需要滚动条的时候需要将其与滚动条连接起来。以下给出一个可以参考的示例。

self.yScroll = tk.Scrollbar(self, orient=tk.VERTICAL)
self.yScroll.grid(row=0, column=1, sticky=tk.N+tk.S)

self.listbox = tk.Listbox(self, yscrollcommand=self.yScroll.set)
self.yScroll['command'] = self.listbox.yview

消息

消息是一个类似于标签的多行文本组件，其中的内容会保持一致的字体样式。消息的创建格式为w = tk.Message(parent, option=value, ...)。常用的配置属性有。

• aspect，宽高比，取值100时为正方形，取值200时，宽为高的2倍。
• textvariable，指定用于控制消息文本的控制变量。

单选框

单选框用于提供用户在一组选项中做出选择。将多个单选框组成一个功能组的方法是将其绑定到一个控制变量上，控制变量可以是IntVar或者StringVar类型。单选框的创建格式为w = tk.Radiobutton(parent, option=value, ...)。常用的配置属性有。

• command，指定当用户改变单选框状态时执行的函数。
• variable，指定单选框的控制变量。

刻度条

刻度条允许用户在一定的值区间内选择一个值。刻度条的创建格式为w = tk.Scale(parent, option=value, ...)。其常用的配置属性有。

• digits，指定数字位数。
• from_，浮点型，指定刻度条的区间起始值。
• orient，指定刻度条的绘制方向，可选tk.HORIZONTAL、tk.VERTICAL。
• resolution，指定用户可以移动的最小步进值。
• to，浮点型，指定刻度条的区间终止值。

滚动条

Tkinter中的组件都是不带滚动条的，在需要滚动条的位置需要手工建立并绑定。滚动条的创建格式为w = tk.Scrollbar(parent, option=value, ...)。常用的配置选项有。

• command，当滚动条滚动时调用的函数。
• orient，指示滚动条的放置方向。

大部分支持滚动条的组件都带有.xview()或者.yview()方法，将此方法绑定到相应滚动条的command属性上就可以实现组件对滚动动作的支持。但滚动条一般还需要跟随组件自身的滚动产生状态变化，这就需要将组件的xscrollcommand或者yscrollcommand绑定为滚动条的set方法，使两者之间保持联系。

转轮数字框

转轮数字框常用于让用户在一个指定区间或者值群内选择一个数字。其创建格式为w = tk.Spinbox(parent, option=value, ...)。常用配置属性有。

• format，数字显示格式。
• from_，区间的起始值。
• increment，增长步进值。
• to，区间的终止值。
• values，列表类型，可以是字符串列表，提供固定的可选值。

文本框

文本框是用来编辑多行文本的组件，常用来做编辑器使用。其创建格式为w = tk.Text(parent, option=value, ...)。常用配置属性有。

• autoseparators，当设置了Undo选项，该选项会自动控制编辑栈。
• maxundo，最大Undo次数。
• tabs，指定Tab键代表的空格数量。
• undo，指示是否启用Undo功能。

文本框支持使用索引来对其中的内容进行访问。具体索引的格式及使用方法可以参考Python的官方文档。利用这些基于索引功能的方法可以做出一套功能比较全面的编辑器。

组合框

组合框是由输入框和下拉菜单组成的选择框。组合框由ttk模块提供，创建格式为w = ttk.Combobox(parent, option=value, ...)。常用的配置属性有。

• values，下拉菜单中的可选项列表。
• validate，输入框的验证时机。
• validatecommmand，输入框的验证函数。
• textvariable，指定控制输入框内容的控制变量

进度条

进度条是用来提示用户工作进度或者程序状态的组件，其创建格式为w = ttk.Progressbar(parent, option=value, ...)。常用的配置属性有。

• length，组件的长度。
• maximum，指示器的最大值，默认为100。
• mode，指示器的工作模式，'indeterminate'模式为循环状态工作模式，'determinate'模式为进度提示模式。
• orient，进度条的放置方向。
• variable，指定用于设置和获取当前值的控制变量。

常用的方法有。

• .start([interval])，启动进度条自动前进，定时移动进度条。
• .step([delta])，使进度条的值增加delta。
• .stop()，停止自动进度条。

分割线

分割线就是在界面上划出的一道线，用来将组件进行视觉隔开。其创建格式为w = ttk.Separator(parent, option=value, ...)。常用的配置属性有。

• orient，分割线的放置方向。

标签页

标签页用于在同一块位置盛放多页内容，并像卡片一样切换。创建格式为w = ttk.Notebook(parent, option=value, ...)。常用方法有。

• .add(child, **kw)，用于添加一个Frame，kw为新Frame页面的属性。
• .forget(child)，永久性移除一个页面。
• .hide(tabId)，临时隐藏一个页面。
• .insert(where, child, **kw)，在指定位置插入一个页面。
• .select(tabId)，获取当前页面，或者指定显示某个页面。
• .tab(tabId, option=None, **kw)，设置指定页面的属性。

标签页中每个页面都有以下属性可供访问和设置。

• compound，图片或者文字的放置位置。
• padding，四周的留白。
• sticky，设定页面四边贴近的位置。
• image，设置在标签上显示图片。
• text，设置在标签上显示的文字。

树形列表

树形列表是一个强大的组件，不仅可以创建树形的内容，还可以作为表格组件使用。要建立一个树形列表，一般可以使用以下步骤。

• 使用构造器建立组件，并且使用columns属性指定要显示的列的数量，并指定每一列的名称。
• 使用.column()和.heading()方法建立列表头，并且配置各列的属性和宽度。
• 从顶级内容开始添加，用.insert()方法建立整个树形结构。用.open()方法决定每个分支的展开或者收缩状态。

树形列表的创建格式为w = ttk.Treeview(parent, option=value, ...)。常用的配置属性有。

• columns，由字符串组成的列识别标识序列，定义需要显示哪些列。
• displaycolumns，定义要显示的列的顺序。
• height，每行的高度。
• padding，树形列表内部留白。
• selectmode，内容选择方式，可取值有'browse'、'extended'、'none'。

常用的方法有。

• .column(cid, option=None, **kw)，用于配置逻辑列的外观，逻辑列的cid可以使用列索引或者列标识。图标列需要使用cid为'#0'。每个逻辑列有以下配置项。
  • anchor，列中内容的对齐位置，使用锚点名设置。
  • id，列名。
  • minwidth，列最小宽度。
  • stretch，缩放时是否拉伸列，默认值为1，可以设为True。
  • width，指定初始宽度，默认值为200。
• .delete(*item)，删除并销毁符合指定iid的行。
• .detach(*item)，删除符合指定iid的行。
• .exists(iid)，检索指定iid是否于列表中存在。
• .heading(cid, option=None, **kw)，配置指定列的标头，图标列的cid使用'#0'。可以用的配置项有。
  • anchor，内部文字的对齐位置，使用锚点位置。
  • command，设定当用户点击操作时的处理函数。
  • image，设定显示图片。
  • text，设定显示文本。
• .set_children(item, *newChildren)，为指定元素设定新的字内容。
• .insert(parent, index, iid=None, **kw)，插入一个进的元素，如果插入顶级元素，parent需要保持为空白字符串。
• .item(iid[, option[, **kw]])，获取元素或者设置指定元素的属性。
• .move(iid, parent, index)，移动指定元素。
• .selection_add(items)，向选中内容中添加指定元素。
• .selection_remove(items)，从选中内容中去除指定元素。
• .selection_set(items)，将指定元素设为选中状态。
• .selection_toggle(items)，切换指定元素的选中状态。

使用菜单

菜单是由两个元素一个是菜单按钮，另一个是菜单列表。菜单列表是用户点击菜单按钮之后出现的，而菜单按钮是应用中始终显示的内容。

菜单按钮的创建格式为w = tk.Menubutton(parent, option=value, ...)。常用的配置属性有。

• direction，指示菜单列表出现在菜单按钮的那个方向上。
• menu，指定菜单按钮点击后对应的菜单列表。
• textvariable，指定菜单按钮的控制变量，StringVar类型。

菜单列表的创建格式为w = tk.Menu(menubutton, option=value, ...)。菜单列表中的内容可以有文字或图片指令、复选框、单选框以及子菜单选项。菜单列表常用的方法有。

• .add(kind, coption, ...)，向菜单列表中添加指定类型的新元素，元素类型可以是cascade（子菜单列表，相当于调用.add_cascade()）、checkbutton（复选框，相当于调用.add_checkbutton()）、command（普通菜单项，相当于调用add_command()）、radiobutton（单选框，相当于调用.add_radiobutton()）、separator（分隔线，相当于调用add_separator()）。

创建菜单时的coption配置可以使用以下常用属性。

• accelerator，快捷键设置。
• command，点击是要执行的函数。
• label，菜单文字内容。
• image，菜单图片内容。
• menu，子菜单内容。
• variable，复选框和单选框使用的控制变量设置。

对于macOS来说，菜单一般是显示在顶级窗口上的，也就是桌面顶部的共享菜单栏。这种需求下，可以将菜单的parent设置为顶级窗口，即调用.winfo_toplevel()的返回结果。Windows和Linux中使用这样设置菜单列表，可以获得应用全局菜单栏。

对话框

对话框功能是由tkinter.messagebox模块提供的。其中提供了以下函数用来显示一个对话框，并可以返回相应类型的值。tkinter.messagebox模块中的函数其功能都非常容易识别。

• .askyesno(title, message)，返回布尔类型，显示问号图标，按钮为“是”、“否”。
• .askquestion(title, message)，返回字符串，显示问号图标，按钮为“是”、“否”。
• .askokcancel(title, message)，返回布尔类型，显示问号图标，按钮为“确定”、“取消”。
• .askyesnocancel(title, message)，返回布尔类型，显示问号图标，按钮为“是”、“否”、“取消”，其中取消返回None。
• .askretrycancel(title, message)，返回布尔类型，显示三角图标，按钮为“重试”、“取消”。
• .showinfo(title, message)，返回字符串，显示蓝色圆形图标，按钮为“确定”。
• .showwarning(title, message)，返回字符串，显示三角图标，按钮为“确定”。
• .showerror(title, message)，返回字符串，显示红色圆形图标，按钮为“确定”。

文件选择对话框

文件选择对话框是由tkinter.filedialog模块提供的。这个模块主要提供了打开文件和保存文件的对话框。

• .askopenfilename()，打开文件选择对话框，并返回一个文件的完整路径，选择取消则返回空字符串。
• .askopenfilenames()，打开文件选择对话框，并返回一个元组，其中包括所有已选择的文件完整路径。
• .asksaveasfilename()，打开文件选择对话框，可以创建文件，返回要创建的文件的完整路径。

文件选择对话框可以使用以下共用的参数配置。

• defaultextension，指定文件后缀。
• filetypes，指定筛选文件类型的下拉框选项。
• initialdir，指定默认路径。
• parent，指定显示在哪个窗口之上。

SDL游戏库：pygame

Pygame是一个利用SDL库编写的游戏库。SDL全名是Simple Direct Media Layer，是使用C语言编写的，也可以使用C++进行开发，Pygame就是在SDL库基础之上建立的使用Python来开发SDL应用的库。相比于其他的游戏库，pygame虽然可以利用OpenGL进行3D游戏的开发，但是其更加专长于2D游戏的开发。就游戏开发而言，底层的内容永远是相通的。

Pygame可以直接使用pip install pygame进行安装，但是在使用过程中，需要注意pygame运行所需要的支持库是否完备，如果pygame报错，那么就需要去安装相应的支持库。

模块列表

Pygame中提供了众多的模块来完成不同的功能，以下给出一张概览表，方便在开发时查阅相关文档。

某些模块在不同的系统平台上可能是不可用的，所以在使用前可以使用if pygame.font is None:来测试一下。

最小应用

一下通过一个最小应用来看一下pygame的运行效果，在执行以下代码之前，请先准备一张图片。

import sys
import math
import pygame
import pygame.locals


# 初始化pygame
pygame.init()

# 创建一个800×600的窗口
screen = pygame.display.set_mode((800, 600), 0, 32)
# 设置窗口标题
pygame.display.set_caption('Hello World')

# 加载一张图片
background = pygame.image.load('sample.jpg').convert()
# 对图片进行缩放处理
(b_width, b_height) = background.get_size()
ratio = b_width / 800 if b_width >= b_height else b_height / 600
scaled_background = pygame.transform.scale(
	background, 
	(math.floor(b_width / ratio), math.floor(b_height / ratio))
)

while True:
	for event in pygame.event.get():
		# 对应用中出现的事件进行处理，如果出现退出事件则结束程序
		if event.type == pygame.locals.QUIT:
			sys.exit()
	
	# 将图片绘制到窗口中，居中绘制
	(sb_width, sb_height) = scaled_background.get_size()
	screen.blit(
		scaled_background, 
		(math.floor((800 - sb_width) / 2), math.floor((600 - sb_height) / 2))
	)
	
	# 刷新整个画面
	pygame.display.update()

一些基础概念

精灵

精灵是游戏开发中的一个重要概念，它代表游戏画面中的一个最小的图像元素单元。比如一个人物，或者一串文本。

渲染

绘制游戏画面并将其显示在屏幕上的整个过程，一般称为“渲染”。

碰撞检测

游戏在处理精灵交互时，常常需要判断两个或多个精灵是否产生了接触。使用游戏开发的术语，这种接触就称为碰撞。碰撞检测一般有多种方法，其检测的精度也不尽相同。在进行碰撞检测的方法选择时，需要平衡考虑碰撞检测的精度和计算效率，如果计算过于复杂，可能会拖累画面的渲染。

双缓冲

按照一般的处理循环，画面的绘制是采用“绘制-更新”的流程来完成的，当画面的绘制没有完成时，不会向屏幕上更新画面。这在一些绘制任务繁重的画面处理过程中，可能会导致帧速严重下降，也就是常说的“卡顿”。双缓冲是在“绘制-更新”的基础上，将绘制任务提前进行，在每次更新屏幕画面时，下一帧的内容就已经绘制完成并缓存在显存中了。这在一定程度上减少了“卡顿”。双缓冲一般都是与硬件加速搭配使用。

处理循环

游戏的主循环一般是一个无限循环，其处理流程一般是按照以下顺序进行的：

1. 帧速控制；
2. 用户操作事件处理；
3. 游戏规则逻辑处理；
4. 精灵运动及碰撞处理；
5. 绘制画面缓存；
6. 更新画面。

创建基本窗口

Pygame中的基本图像结构是pygame.Surface，它代表着游戏中所需要处理的全部图像对象。前面示例中创建的基本窗口也是一个Surface对象。

在对pygame进行初始化之后，就可以创建基本窗口了。这个窗口是通过pygame.display.set_mode(resolution, flags, depth)来创建的。其中resolution是所创建的窗口的分辨率，是一个由两个整型值组成的元组，分别代表窗口的宽度和高度，计算单位是“像素”。

flags则是表示窗口中渲染所使用的方法，如果不需要特殊的渲染方法和窗口状态，可以传递0值。flags支持使用以下值来指示窗口的渲染和状态。

• pygame.FULLSCREEN，创建一个全屏显示。
• pygame.DOUBLEBUF，创建一个双缓冲显示，一般与硬件加速和OpenGL搭配使用。
• pygame.HWSURFACE，创建一个硬件加速显示，只可以在全屏显示中使用。
• pygame.OPENGL，创建一个使用OpenGL渲染的显示。
• pygame.RESIZABLE，创建一个可变大小的窗口。
• pygame.NOFRAME，创建一个没有边框的窗口。

如果需要使用多个值，可以使用|来将多种状态连接起来，例如：pygame.FULLSCREEN | pygame.HWSURFACE。

depth表示画面的颜色深度，这项一般可以省略不给出，pygame会根据当前系统自动选择一个最有效率的颜色深度来使用。

如果需要在程序运行过程中切换窗口和全屏，可以直接调用.set_mode()来设置新的窗口状态。如果将窗口设置为了可变大小模式，那么就需要在事件处理中响应pygame.locals.VIDEORESIZE事件来重新设置窗口状态，否则窗口虽然大小变化了，但是窗口所对应的Surface对象却没有进行响应的变化，必须让两者同步才能达到缩放窗口的目的。

加载图片

在pygame中，最核心的类就是Surface，加载图片就是将一个图片文件加载成一个Surface对象。pygame支持JPEG、PNG、GIF、BMP、PCX、TGA、TIF等常用的图片文件类型。尽管输入的图像文件格式不同，但是在pygame中都是使用Surface对象来进行操作，整个pygame世界就是由各种Surface对象组成的。

加载图片到Surface可以像前面最小应用中一样，直接使用pygame.image.load('文件名')即可。通常加载完图片后并不需要理会其中的内容，但是将Surface对象转换一下可以获得更好的性能。在前面的最小应用中也进行了这样的转换。

Surface的转换有两个函数，.convert()和.convertAlpha()，它们的区别就是是否携带Alpha通道。如果需要透明内容，那么就需要使用带Alpha通道的转换。

使用字体

Pygame可以直接调用系统字体，也可以使用字体文件。pygame的字体功能是由pygame.font模块提供的。要使用字体，必须要先创建一个Font对象。

pygame.font.SysFont('字体名', 字体大小)可以用来建立一个使用系统字体的Font对象，其中第一个参数是系统中的字体名称，第二个参数是字体的字号大小。字体这个东西，每个人的系统中可能都是不一样的，所以更多的时候还是使用TTF字体文件来建立Font对象。使用TTF字体文件来建立Font对象可以直接使用Font类的构造函数pygame.font.Font('字体文件名', 字体大小)。

创建完Font对象之后，就可以使用Font对象中的.render()函数来生成文字内容对应的Surface对象了。.render()函数可以接受四个参数，其完整调用格式为.render('文字内容', 反锯齿优化, 文字颜色, 背景颜色)。其中反锯齿优化参数为布尔值，开启时字体显示会比较平滑；文字颜色和背景颜色都是一个由三个整型数值组成的元组，分别对应红、绿、蓝三原色的值，如果不需要背景色，那么可以省略第四个参数。

以下示例会将文字Surface保存成一个图片文件。

import pygame
pygame.init()
custom_font = pygame.font.SysFont("arial", 64)
hello_surface = custom_font.render("Hello World", True, (0, 0, 0), (255, 255, 255))
pygame.image.save(hello_surface, "hello.png")

渲染画面

从图片加载到使用字体生成，我们现在手头应该已经有了不少的Surface对象。要将其绘制到屏幕上，就需要对其进行渲染。

从前面的最小应用中可以看到，语句screen.blit()将指定的图片Surface对象绘制在了自身的指定位置，并在最后使用pygame.display.update()刷新了整个画面。在实际的应用中，都是通过.blit()函数来逐一绘制相应的Surface。

在渲染画面时，还是有一定技巧的，通过应用这些技巧，可以对绘制工作进行提速。

分区绘制

在很多游戏中，通常并不需要进行全屏绘制，而是先将屏幕分为不同的显示区，分别显示不同的信息。pygame也支持对屏幕进行分区绘制，这样在绘制的时候只需要绘制出现变化的区域即可。分区绘制会减少很多不必要的绘制工作，从而使绘制过程提速。

对屏幕进行分区是使用.set_clip()函数实现的，这个函数接受四个整型数值参数来定义一个矩形区域。在绘制时，可以通过.get_clip()函数来获得绘制区域。在设定分区之后，其后的绘制操作将只会影响这个区域内的像素，如果需要绘制其他的区域，则需要再次调用.set_clip()来激活相应的绘制区域。

Subsurface

把所有的图像素材都保存成单独的文件是一种十分不合理的行为，连续不断的加载图片会大量消耗内存，最后可能会中会出现的结果就是内存不足。通常处理图片的方式是将相同类型或者内容的素材放置在一个图片里，在加载之后动态进行切割，这样会节省不少的内存。

Pygame中的Subsurface可以通过Surface对象的.subsurface()函数来获取，这个函数接受两个元组作为参数，分别代表左上角和右下角的坐标值，以此来对Surface进行切割并以Surface对象返回指定区域内的内容。

Surface锁定

Pygame在绘制Surface时，会自动对Surface进行锁定，并在绘制结束后自动解锁，以防止多线程操作时其他线程的干扰。但是连续不断的锁定和解锁操作会消耗大量的时间，使得锁定操作十分没有效率。为了解决这个问题，我们可以手动对Surface进行锁定，

锁定可以直接调用Surface对象的.lock()函数，而解锁则是直接调用.unlock()函数。

读取事件

事件是驱动游戏进行和分支的重要部分，没有事件的存在，游戏只会在原地踏步并且不能响应任何玩家的操作，甚至连退出游戏都十分困难。事件不仅会来自于用户，也可能会来自系统，事件随时可能发生，并且量级巨大。pygame支持用户的各种操作，包括键盘、鼠标还有游戏手柄等，并且使用队列来处理这些巨大量级的事件。

在实际开发中，常常用pygame.event.get()这个生成器来读取队列中的事件。pygame.event.get()通常不会阻塞游戏的主循环，而pygame.event.wait()就不一样了，它会让整个程序停下来等待下一个事件的发生。

事件通常可以使用event.type属性来判断这个事件的类型，通过区分不同的事件类型，我们可以在程序中做出响应的处理。pygame中常用的事件类型有以下这些。

键盘事件

键盘事件比较简单，只是对按下的按键进行记录，不同的成员用来记录不同类型的按键。key用来记录按下或者释放的键值，由于键值是一个整型数字，并不方便使用，所以pygame在pygame.locals中提供了一系列的常量来供使用，其中按键采用K_xxx来表示，例如K_a表示按下了字母A键，空格和回车分别是K_SPACE和K_RETURN。

mod用来记录组合键信息，组合键通常使用位运算来判断，例如event.mod & pygame.locals.KMOD_CTRL如果为真，则表示用户按下了Ctrl键。常用的其他按键还有KMOD_SHIFT和KMOD_ALT。

在pygame.key模块中，还提供了一个.get_pressed()函数，可以获得当前所有已经按下的键盘的值。这个函数会返回一个元组，元素的索引是键值，值为是否按下。所以对已经按下的键的判断还可以使用以下方式来完成。

pressed_keys = pygame.key.get_pressed()
if pressed_keys[K_SPACE]:
	# 处理空格键按下的逻辑
	pass

同样，获取组合键信息的函数是.get_mods()。

处理鼠标事件

MOUSEMOTION事件在鼠标动作时产生，会在产生的事件中提供三个成员，其中buttons成员是一个元组，其中有三个整型值，分别代表左、中、右三个键，哪个值为1，就代表对应的哪个键被按下了。pos成员表示目前鼠标的位置。rel成员表示当前事件与上次事件发生时的鼠标位置距离。

MOUSEBUTTONDOWN和MOUSEBUTTONUP两个事件只在鼠标按键点击和释放的时候产生，其中button成员代表哪个按键被操作，pos依旧代表发生事件时的鼠标位置。

阻止事件和自定义事件

通常不是所有的事件都是程序感兴趣的，但是pygame将其排入了队列，即便是不予理睬也会稍微的影响性能。这时可以使用pygame.event.set_blocked([事件类型名称])来对事件进行过滤，所有列在列表中的事件类型，pygame都会不再捕获。相反，使用pygame.event.set_allowed()可以用来设置允许的事件。

Pygame也支持自定义事件，为了使用自定义事件，需要先创建一个事件，再将其发送到pygame的事件队列中。这里的自定义事件并不仅是前表中的USEREVENT，也可以是自定义事件类型，或者是按键、鼠标等事件类型。例如可以使用以下示例来发送键盘事件和自定义事件。

# 创建键盘事件
key_event = pygame.event.Event(KEYDOWN, key=K_SPACE, mod=0, unicode=u' ')
pygame.event.post(key_event)

# 使用字典创建键盘事件
key_event = pygame.event.Event(KEYDOWN, {'key': K_SPACE, 'mod': 0, 'unicode': u' '})

# 创建自定义事件
ANEWUSEREVENT = USEREVENT + 1
custom_event = pygame.event.Event(ANEWUSEREVENT, message='Hello from custom event')
pygame.event.post(custom_event)

控制帧速

帧速永远是游戏和硬件之间的较量，同样的游戏在不同配置的机器上运行帧速肯定是不一样的。在没有对帧速进行控制时，pygame永远是使用最大火力运行。但是我们往往并不需要过高的帧速。对于一般游戏来说，30FPS的帧速已经可以提供流畅的体验了，而目前的LCD显示器一般可以支持60FPS的帧速。帧速高于60FPS已经没有很大的意义了。

Pygame的pygame.time模块中提供了一个Clock对象，可以用来对帧速进行控制。以下例程将最大帧速控制在了30FPS。

clock = pygame.time.Clock()
# 返回一个距离上次调用的时间差，单位是毫秒
time_passed = clock.tick()

while True:
	time_passed = clock.tick(30)

示例中的clock.tick(30)将帧速限制在了30FPS，这是游戏运行的最大帧速。但是需要注意的是，游戏的实际帧速很有可能达不到这个值。

精灵的运动

前面提到游戏中出现的物体一般都成为精灵，精灵在画面上不可能是完全静止不动的。结合前面提到的帧速控制，就会出现一个不得不处理的问题：无论在哪个帧速下，精灵的运动都是与时间相匹配的，不可能在配置较好的机器上精灵的运动是在1秒钟完成，而配置较差的机器上则会大于1秒。

这就要求在帧速较低的机器上，精灵需要有更高的运动速度，反之，在帧速较高的机器上，精灵的运动速度可以较低。针对这种要求，我们可以给精灵定义一个基础运动速度，结合前面clock.tick()函数返回的时间差，来计算精灵的运动距离，之后再进行相应的绘制。这样在不同的机器上看起来，精灵的运动效果就一致了。