本文章主要以黑马程序员的「传智播客 Python 就业班 (ij6g)」、「 Python 从入门到精通教程 」和「 廖雪峰的 Python 教程 」为主线，输出学习笔记，目的是检验自己的学习效果和日常复习之需。作为入门 Python 的参考资料，除了视频的基础内容外，文章还会补充视频中讲解不详细或遗漏的必要知识点。

文章的内容和知识框架，与「廖雪峰的 Python 教程」和「传智播客的视频」大体保持一致：

文章以模块分块阐述：Linux 基础、Python 基础、Python 面向对象、项目实战 ( 实战部分以爬虫、数据分析为主的项目实战 )。

每个模块按知识点区分： 1) Linux 基础部分参考 传智播客 Python 从入门到精通教程； 2) Python 基础部分参考 廖雪峰 Python 教程； 3) 项目实践，即数据分析部分参考书籍 利用 Python 进行数据分析 $^{[5]}$；

最后，正如 Bruce Eckel 所述 Life is short, you need python，Python 的高效只有切身体验才会深有体会，期待您早日加入 Python 队伍中来。

📺 | 视频 | 传智播客. Python 就业班. 2017. BaiduCloud | Pwd: ij6g

本文章的学习笔记是基于此系列教学视频所得的。

仅列举一些项目中常用的命令。

LS 命令与通配符

[a-f]：匹配从 a 到 f 范围内的任意一个字符。

常使用 ls -al 显示当前文件目录所有文件的详细信息。

CD 命令与切换目录

绝对路径：最前面是 / 或 ~，表示从 根目录 / Home 目录 开始的具体目录位置。

Tree 命令：以树状结构显示文件目录结构，若 tree -d 则显示目录，不显示文件。

查看文件内容

Echo 命令与重定向

echo 命令常结合 重定向 使用：

管道符 |

ls 命令与 grep 命令的结合使用，如从 Home 目录下搜索包含 “python” 关键字的文件或者文件夹：

Ifconfig 命令与 Ping 命令

ping 命令一般用于检测当前计算机到目标计算机之间的网络是否畅通。

SCP 即 Secure Copy，是一个在 Linux 下用来进行 远程拷贝文件 的命令。

免密码登录：即客户端访问服务端时，需要密码验证身份登录。

Step.02. 上传公钥到服务器：执行 ssh-copy-id -p port user@remote，让远程服务器记住我们的 公钥。

1) 有关 SSH 配置信息都保存在 /Home/your username/.ssh 目录下。2) 免密登录使用的是非对称加密算法 ( RSA )，即使用公钥加密的数据，需要使用私钥解密；使用私钥加密的数据，需要使用公钥解密。若有兴趣了解 RSA 算法 的原理及计算，可参考引用文章 [1]、[2]。

配置别名：每次输入 ssh -p port user@remote 是非常繁琐重复的工作，配置别名的方式以替代上述这么一串命令代码。

在 /.ssh/config 文件下追加以下内容 ( 需建立 Config 文件 )：

命令输入 ssh mac 即可实现远程登录操作 ( SCP 同样原理 )。

Chmod 命令：可修改 用户/组 对 文件/目录 的权限。

Sudo 命令：使用预设 ( root, 系统管理员 ) 的身份来执行命令。

Linux 系统中，通常使用标准用户登录及使用系统，通常 sudo 命令临时获得权限用于系统的维护与和管理。在执行一些模块的安装过程或者配置过程中，你会经常用到它的。

进程信息

kill：kill [-9] 进程代号，-9 表示强行终止，终止指定代号的进程。

使用 kill 命令时，最好终止当前用户开启的进程，而不是终止 root 身份开启的进程。

查找文件：find 命令功能非常强大，通常在特定目录下搜索符合条件的文件。

find 命令可结合 通配符 一起使用。

软链接：建立文件的软链接，通俗理解即 PC/MacOS 上的 快捷方式。

没有 -s 选项是建立一个硬链接文件。

在 Linux 中，文件名和文件的数据是分开储存的。

tar 是 Linux 中最常用的备份工具 ( 打包并不压缩 )，其命令格式如下：

tar 与 gzip 命令结合可实现文件 打包和压缩，即 tar 只负责打包文件， gzip 负责压缩文件。

当我们编写 Python 代码时，我们得到的是一个包含 Python 代码的以 .py 为扩展名的文本文件。要运行代码，就需要 Python 解释器去执行 xxx.py 文件。

CPython

iPython

CPython 用 >>> 作为提示符，而 IPython 用 In [序号]: 作为提示符。

PyCharm

工欲善其事，必先利其器。为帮助开发者更便捷、更高效来开发 Python 程序，一款集成开发编辑器 ( IDE ) 显得格外重要。IDE 除了快捷键、插件外，重要的是它还支持 调试程序。

当然，支持 Python 程序开发的 IDE 还有很多优秀的产品：如：Eclipse with PyDev

新建并运行 python 程序：vi python_sample.py 开始编写程序；通过 python python_sample.py 执行程序。以下为简单的 Python 示例：

行注释、块注释：行注释的风格与 Linux 中 Shell 脚本的注释相同，即以 # 开头的注释；块注释使用三个单引号 ' 或三个双引号 " 包裹实现。

浮点型：即含有小数点的数，如 1.23，1.23e9 ( 1.23x10$^9$ )，1.23e-5 ( 1.23x10$^{-5}$ )

1) 整数和浮点数在计算机内部存储的方式是不同的；2) 整数运算永远是精确的，而浮点数运算则可能会有四舍五入的误差。

字符型：以单引号 ' 或双引号 " ( 表示方式不同而已 ) 括起来的任意文本。例如 '(1+2)\%3 == 0'，或者 "The 'a' is a lowercase letter of 'A'"。

Python 中的数据类型是没有大小限制的，若想定义无限大，可定义为无限大，即 inf。

变量的输入与输出：

ASCII：127 个字符编码，即大小写字母、数字和一些特殊字符。例如大些字母 A，对应的 ASCII 为 65。

但处理中文显然一个字节是不够的 ( 至少两个字节 )，且还不能与 ASCII 编码冲突，所以中国制定了GB2312 编码。

然而，世界有上百种语言，日本把日文编到 Shift_JIS 里，韩国把韩文编到 Euc-kr 里，各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。

因此，Unicode 应运而生 $^{[3]}$。Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。

Unicode：2 字节及以上。

为节约空间，把 Unicode 编码转化为“可变长编码”的 UTF-8 编码。

UTF-8：根据数字大小编写 1 ~ 6 字节，英文字母 1 字节，汉字 3 字节 ( 生僻字符用到 4 ~ 6 字节 )。

ACSII、Unicode 与 UTF-8 的关系

启示：计算机系统通用的字符编码工作方式，如图 6-2-1 所示。

浏览网页时，服务器会把动态生成的 Unicode 内容转换为 UTF-8 再传输到浏览器。

Python 3 中，字符串是以 Unicode 编码的。

encode() 与 decode()：

中文字符可用 UTF-8 编码，即 "中国".encode("utf-8")。

含有中文的 str 无法用 ASCII 编码，因中文编码的范围超过了 ASCII 编码的范围。强制编码会抛出异常：'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)。

常用数据类型转换，见表 6-2-2 所示：

字符串输入和输出：

组成字符串的方式：

字符串下标与取值：

字符串常见操作

find(s) 与 index(s)：从目标字符串中寻找子串，找到会返回子串的起始下标；若找不到则返回 -1。index() 找到目标的情况和 find() 相同，找不到目标则会抛出异常。

当然还有 rfind(s) 和 rindex()，即从右端开始寻找子字符串。

count(str, start, end)：即在目标字符串 myStr，求得 str 在位置 start 和 end 之间出现的次数。

例如：myStr.count(str, start = 0, end = len(myStr))，

replace(原始字符串, 目标字符串) 或 replace(原始字符串, 目标字符串，替代次数)：

例如：myStr.replace("world", "python")

split(str)：根据 str 把原字符串切开。

splitlines(str)：将字符串中的每一行切割开来。

re.split(正则表达式, 目标字符串)，根据正则表达式切割字符。

capitalize() 与 title()：前者是把字符串中的第一个字符转为大写字母，后者是把字符串中每个单词的首字母转为大写。

join()：例如 str.join(array)，即使用 str 将列表 array 的内容拼接起来。

有序列表元组 ( Tuple )，与 List 不同，Tuple 一旦初始化就不能修改。

定义一些常量参数时可用 Tuple。

定义：tuples = ('A', 'B', 'C')。

事实： Tuple 中存储的是 引用。

再议不可变对象：replace() 并没有改变字符串的内容，我们理解 str 是变量，abc 是字符串对象。replace() 相当于创建了新的字符串对象 Abc。

Set 可看成数学意义上的 无序 和 无重复 元素的集合。

标准条件判断语句：

三元表达式：在 Python 中，可将 if-else 语句放到一行里，语法如下：

For 循环与 While 循环

可变参数：顾名思义，可变参数就是传入的参数个数是可变的。

关键字参数： 可变参数 允许你传入 0 个或任意个参数，这些参数在函数调用时自动组装为一个 元组 ( Tuple )。 关键字参数 允许你传入 0 个或任意个参数，这些关键字参数在函数内部自动组装成为一个 词典 ( Dict )。

参数组合：Python 中定义函数，可多种参数组合使用，但必须满足一下参数定义顺序：必选参数、默认参数、可变参数、命名关键字 和 关键字参数。

结合 tuple 和 dict：即通过类似 func(*args, **kw) 形式调用函数。参数虽可自由组合使用，但不要组合太复杂，以造成可理解性较差的结果。

函数内部可以调用其他函数。若一个函数内部调用了其自身，即该函数为 递归函数。

尾递归优化：解决递归调用栈溢出的方法，即函数返回时调用本身，并且 return 语句不能包含表达式。

这样，编译器 / 解释器就可对尾递归做优化，即使递归本身调用 n 次，都只占用一个栈帧，不会出现栈溢出的情况。

切片操作符：在 List 中指定 索引范围 的操作。 索引范围具体为： 起始位置:结束位置:步进 ，注意步进数 ( 默认为 1，不能为 0 )。

倒数切片：

字符串切片：

迭代：给定一个 List 或 Tuple，通过 For 循环遍历这个 List 或 Tuple。

enumerate 函数可以把一个 list 变成 索引-元素树，这样就可以在 For 循环中同时迭代 索引 和 元素本身。

列表生成式：List Comprehensions，用于创建 List 的生成式。

创建 Generator：把列表生成式的 [] 改成 () 即可。

可用于 for 循环的对象统称为可迭代对象 Iterable。

生成器是 Iterator 对象；List、Dict、Str 虽然是 Iterable 对象，但却不是 Iterator。 我们可以通过 iter() 函数，把 List、Dict、Str 等 Iterable 转换达成 Iterator。

Python 的迭代器 ( Iterator ) 对象表示的是一个数据流，即 Iterator 对象可被 next() 函数调用并不断返回下一个数据，直至没有数据时抛出 StopIteration 异常。

变量可指向函数：

函数名也是变量：函数名其实就是指向函数的变量。

注意：1) 而在实际编码当中，绝对不能这样写，只是为了说明函数名也是变量。2) 若需恢复 abs 函数，请重启 Python 交互环境。

传入函数：一个函数接收另一个函数作为参数，称为 高阶函数。

Map / Reduce 的概念 ：

用户指定一映射函数 map() 处理键/值对，以生成一组中间键/值对；同时也指定 reduce() 函数用以 合并 含相同中间键所关联的所有中间值。

为了更加透彻理解 MapReduce，可研读 Google 关于 MapReduce 的论文：MapReduce: Simplified Data Processing on Large Clusters $^{[4]}$。

map() 函数：其接收 两个参数，第一个是 函数，第二个是 Iterable。即 map 将传入的 函数 依次 作用 到序列的 每个元素，并把结果作为新的 Iterator 返回。

reduce() 函数：其接收 两个参数，第一个是 函数，第二个是 Iterable。即 reduce 把结果继续和序列的 下一个元素 做 累积计算。

reduce(f, [x1, x2, x3, x4]) 等价于 f( f( f(x1, x2), x3 ), x4 )

当然，上述的实例只是为了描述原理而设定，下面将结合 map() 与 reduce() 举例：

filter() 函数：接收 两个参数，一个是 函数，另一个是 序列。即 filter 把传入的函数作用于每个元素，然后根据返回值是 True/False 决定是否 保留/丢弃 该元素。

filter() 函数返回的是一个 Iterator，即一个惰性序列，故需要强迫 filter() 完成计算结果，如 list() 函数获得所有结果。

排序算法：排序的核心是 比较两元素的大小。若是数字则直接比较；但比较的若是字符串或两个字典，则比较过程需通过函数抽象实现。

sorted() 也是一高阶函数，可接收一个 key 函数来自定义排序:

函数作为返回值：高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

注意返回的函数并没有立刻执行，而是调用了 f() 才执行。

返回闭包时牢记一点：返回函数不要引用任何循环变量，或后续会发生变化的变量。

关键字 lambda 表示匿名函数，冒号前面表示传入参数，后面为返回值 ( 一般为表达式运算后的结果 )，如 lambda x, y : x+y

匿名函数有一好处，即不必担心 函数名冲突。此外，匿名函数也是一个函数对象，可把匿名函数赋值给一个变量，再利用变量来调用。

匿名函数作为返回值返回：

提示：对于装饰器，除了廖雪峰老师的教程外 ( 侧重原理讲解 )，还可参考程序员大咖的推文 Python 装饰器的诞生过程 ( 侧重具体实现讲解 )。

引例：假设我们有 time() 函数，我们要增强 time() 函数的功能，比如在函数调用前后自动打印日志，但又不希望修改 time() 函数的定义。

这种在代码运行期间动态增加功能的方式，称之为 装饰器 (Decorator)。

那么装饰器是如何实现的？在实现装饰器之前，我们有必要回顾函数的特性：

函数嵌套及跨域访问：一个函数 (主函数) 内部是可以嵌套另一个函数 (子函数) 的；

Python 中的装饰器是通过闭包实现的，即闭包就是引用了外部变量的内部函数，而闭包的实现正是利用了以上函数特性。具体实现：

解释：closure 实际上是 outer(func)，func 作为参数传进 outer，outer 的子函数 inner 对 func 返回的结果进行了一番装饰，返回了一个装饰后的结果，最后 outer 返回 inner，可以说 inner 就是装饰后的 func，这就是一个函数被装饰的过程，重点在于执行 outer(func) 这个步骤，即执行 closure()。

装饰器语法糖 @：Python 给我们提供了语法糖 @，我们想执行 outer(func)，只需要把 outer 函数 @ 到 func 函数的上即可。具体实现：

例：int() 函数可把字符串转为整数，当且仅当传入字符串时，int() 函数默认按照 10 进制转换。

其实 functools.partial 就是帮助我们创建一个偏函数，即其作用就是把一个函数的某些参数固定住 ( 设置默认值 )，返回一个新函数。

创建偏函数时，实际可接收 函数对象、*args 和 **kw 这三个参数。

一个 .py 文件称之为一个模块 (Module)，模块可避免函数名和变量名冲突。

⚠️ 尽量不与 Python 内置函数名称相冲突，详细可参考 Python 标准函数库 $^{[6]}$。

按目录来组织模块的方法，称为包 (Package)，可避免模块名称的冲突。

⚠️ 创建模块的名称不能和 Python 自带的模块名称相冲突。例如系统自带 sys 模块。

__init__.py 的模块名称为 mypython。

以内建的 sys 模块为例，编写 sample 模块:

作用域：在一模块中，我们可能会定义很多函数和变量。或许我们有这样的需求：有的函数和变量仅希望是在模块内部使用。Python 中通过 _ 前缀实现的。

正常的函数和变量名是公开的 (public)，可被直接引用。例如，abc、x1、PI 等。

非公开的函数和变量 (private)，不应该被直接引用。例如 _xxx、__xxx。

不应该 被直接引用，而不是不能被直接引用，因为 Python 并没有一种方法可以完全限制访问 private 函数或者变量。

使用 private 函数，实现代码封装和抽象的方法：

当然，Python 使用过程中需要安装和使用大量的第三方库，若通过上述方式安装未免太过繁琐，故我们可考虑直接安装 Anaconda。

Anaconda，其是一个基于 Python 的数据处理和科学计算的平台，他已经内置了许多非常有用的第三方库。在完整完 Anaconda 后，重新在命令行中键入 python，出现以下信息即安装成功，可正常导库使用：

当我们试图搜索某一模块，若找不到会报错。

默认情况，Python 解释器会搜索当前目录，所有已安装内置模块和第三方模块，搜索路径 存放在 sys 模块 的 path 变量 中：

面向对象编程，Object Oriented Programming，简称 OOP。是一种程序设计思想。其把对象作为 程序基本单元，且对象中包含了 数据 和 操作的函数。

面向对象的程序设计把计算机程序视为一组对象集合，而每个对象都可接收其他对象发送的消息并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。

面向对象的程序可理解为：程序 = 对象 + 对象；对象 = 成员变量 + 成员函数。

面向过程的程序可理解：程序 = 函数 + 算法。

在 Python 中，所有数据都可视为对象。当然，可以通过类来自定义对象的数据类型。例如，我们定义一个 Student 类型来代表学生的范畴：

通过 class 关键字定义类：

创建类的实例，如 stu = Student()

由于类起到模板的作用，因此可在创建实例时，通过特殊方法 __init__()，把属性绑定进去。

数据封装：访问实例本身的数据，不通过外部函数访问，而是通过类的内部定义访问数据的函数，这样实现数据封装。

私有变量：让内部属性不被外部访问，在 Python 中，通过双下划线 __ 开头，变量变成私有变量。

dir() 函数：若要获得一个对象的 所有属性和方法，可使用该函数。它返回一个包含字符串的 list。例如，获得一个 str 对象的所有属性和方法。

类似 __xxx___ 的属性和方法在 Python 中都有特殊用途。如 __len__() 方法返回长度。调用 len() 函数，在函数内部实际是它自动地去调用该对象的 __len__（) 方法，故下面代码是等价的。

仅仅把属性和方法列出来是不够的，配合 getattr()、setattr() 及 hasattr()，我们可直接操作一个 对象的状态。

给实例绑定属性的方法是通过 实例变量 赋值，或通过 self 变量 赋值。

给类绑定属性，直接在 class 中定义属性即可。

Tips：编写程序时，不要对 实例属性 和 类属性 使用相同名称，若含有相同名称的实例属性，将屏蔽掉同名称的类属性。

引入：在「访问限制」章节中，我们通过 setScore() 和 getScore() 方法实现修改数据和获取数据，以实现数据封装。

那么本节提及 @property 属性，到底是何意图？先看看原始的 Setter 和 Getter 使用方法：

对于定制类，我们让其实现了 __iter__() 和 __next__() 方法，那么它就是一个 Iterator 类型的，这正是动态语言的特性。

这种特性称为 动态语言 的 鸭子类型，动态语言并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。

一个对象实例可以有自己的属性和方法，当我们调用实例方法时，使用 instance.method() 来调用。能不能直接在实例本身上调用呢？

答案是可以的。任何类，只需要定义一个 __call__() 方法，就可以直接对实例进行调用。

而本节介绍的枚举类，通过 Enum 定义一个 class 类型，然后，每个常量都是 class 的一个 唯一实例。例如：定义 Month 类型的枚举类。

若有需求，我们可精确地控制枚举类型，即从 Enum 派生出自定义类：

在操作系统提供的调用中，返回错误码非常常见。比如打开文件的函数 open()，成功时返回文件描述符 (就是一个整数)，出错时返回 -1。同理，我们设计函数时，也可相仿地设置返回代码。

高级语言通常都内置了一套 try...except...finally... 的错误处理机制，Python 也不例外，使用方法见实例：

Python 的异常类型其实也是 class，所有的异常类型都继承自 BaseException，常见的错误类型和继承关系见：Python. Exception hierarchy

故在使用 except 时需要注意的是：它不但捕获该类型的错误，还把其子类也 “一网打尽”，例如：

在函数嵌套调用中，若错误没有被捕获，它就会一直往上抛，直至被 Python 解释器捕获，并打印一个错误信息然后程序退出。因此当发生错误时，一定要分析错误的 调用栈 信息，定位错误的位置，找出 错误根源。

异常类型属于 class，捕获一个异常就是捕获到该 class 的一个实例。因此，异常并不是凭空产生而是 有意 创建并抛出的。Python 的内置函数会抛出很多类型的错误，我们自己编写的函数也可以抛出异常。

如果要抛出错误，首先根据需要定义一个异常的 class，并选择好继承关系，然后用 raise 语句抛出一个异常实例：

为了编写单元测试，我们需要引入 Python 自带的 unittest 模块。以下为一个 单元测试 的示例：

下面是一些常用的断言，也就是校验结果：

I/O：即输入/输出 ( Input/Output )。

I/O 接口：是 主机 与 被控对象 进行 信息交换 的纽带。例如，程序运行时数据是在内存中驻留的，由 CPU 来执行计算、控制，其中涉及到的数据交换则由磁盘、网络等实现。具体地，I/O 接口的功能就是负责选址、传送命令、传送数据等。

I/O 编程：操作 I/O 是由 操作系统 完成的，且操作系统会提供低级 C 接口，即对 I/O 操作进行 封装，高级语言通过调用 (函数) 的方式实现操作 I/O 的目的。Python 也不例外，即面向 I/O 接口编程。

程序完成 I/O 操作会有 Input 和 Output 两个 数据流：

需要知道的是，CPU 的速度远远快于磁盘、网络等 I/O。因此，代码操作 I/O 接口时速度是会产生不匹配的问题，而同步和异步的区别就在于是否等待 I/O 执行的结果，故 I/O 编程有分 同步模型 和 异步模型。

同步 I/O：在一个线程中，CPU 执行代码的速度极快，然而，一旦遇到 I/O 操作，如读写文件、发送网络数据时，就需要等待 I/O 操作完成才能继续进行下一步操作。

引用廖老师的例子，同步 I/O 指：去麦当劳点餐，你说 “来个汉堡”，服务员告诉你，对不起，汉堡要现做需等 5 分钟，于是你站在收银台前面等了 5 分钟，当拿到汉堡再去逛商场。

异步 I/O：当代码需要执行一个耗时的 I/O 操作时，它只发出 I/O 指令并不等待 I/O 结果，然后去执行其他代码。一段时间后，当 I/O 返回结果时，再通知 CPU 进行处理。

异步 I/O 指：你说“来个汉堡”，服务员告诉你，汉堡需要等 5 分钟，你可以先去逛商场，等做好了我们再通知你，这样你可以立刻去干别的事情 (逛商场)，这是异步 I/O。

同步 I/O 与 异步 I/O 模型的实现原理如图 6-10-1 所示：

open() 函数，传入文件名和标示符：

前面的操作是读取文本文件，且是 UTF-8 编码的文本文件。要读取二进制文件，例如图片、视频等，用 rb 模式打开文件即可：

写文件和读文件是一样的，唯一区别是调用 open() 函数时，传入标识符 w 或者 wb 表示写 文本文件 或 写二进制文件：

所有模式的定义及含义可参考 Python 官方文档：Built-in Functions.open()

StringIO 和 BytesIO 是在内存中操作 str 和 bytes 的方法。

StringIO 顾名思义就是在内存中读写 str。要把 str 写入 StringIO，我们需要先创建一个 StringIO，然后像文件一样写入：

BytesIO 实现了在内存中读写 bytes。

若我们要操作文件、目录，可在命令行下面输入操作系统提供的各种命令来完成。例如 dir、cp 等命令。

若要在 Python 程序中执行这些目录和文件的操作怎么办？其实 Python 内置的 os 模块，可以直接调用操作系统提供的 接口函数。

在操作系统中定义的环境变量，全部保存在 os.environ 这个变量中，可直接查看：

查看、创建和删除目录可以这么调用：

文件操作：

利用 Python 的特性操作文件或目录：

在 Python 中，序列化称为 pickling，在其他语言中也被称为 serialization、marshalling、flattening 等。Python 提供了 pickle 模块来实现序列化。

引入：Pickle 的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于 Python，且可能不同版本的 Python 彼此都不兼容。

若我们要在不同的编程语言之间传递对象，就必须把 对象序列化为标准格式，例如 XML，但 XML 需要解析读取。但更好的方法是序列化为 JSON，因为 JSON 表示出来就是一个 字符串，可以被所有语言读取，且方便地存储到磁盘或者通过网络传输。

JSON 表示的对象就是标准的 JavaScript 语言的对象，JSON 和 Python 内置的数据类型对应如下：

Python 内置的 json 模块提供了非常完善的 Python 对象到 JSON 格式的转换：

Python 的 dict = {'key': value} 对象可直接序列化为 JSON 的 {"key": value}。但一般情况，我们常用 class 表示对象 ( 例如 Student 类 )，再序列化该对象：

造成上述错误的原因是：Student 对象不是一个可序列化为 JSON 的对象。

其实，仔细观察 dumps() 的参数列表，可以发现除了第一个必须的 obj 参数外，dumps() 方法还提供了一大堆的 可选参数，这些可选参数可让我们来定制 JSON 序列化：

当然，若我们遇到一个 Teacher 类的实例，照样无法序列化为 JSON。其实可以通过一种 通用方法 将任意 class 的实例变为 dict。

通常 class 的实例都有一个 __dict__ 属性，它本身一个 dict，用来存储实例变量。也有少数例外，比如定义了 __slots__ 的 class。

同理，我们需要把 JSON 反序列化为一个 Student 实例对象，loads() 方法首先转换出一个 dict 对象，然后我们传入的 object_hook 函数，其负责把 dict 转换为 Student 实例对象。

在本章引言部分已讲述 同步 I/O 与 异步 I/O 模型的区别，同步模型即按普通顺序写执行代码：

在 I/O 操作过程中，由于一个 I/O 操作阻塞了当前线程，导致其他代码无法执行，故我们可使用多线程或者多进程来 并发 执行代码。然而，我们通过 多线程和多进程 的模型解决了 并发 问题，但现实情况是系统不能无上限地增加线程，因为系统切换线程的开销很大，一旦线程数量过多，CPU 花在线程切换上的时间就增多，则导致性能严重下降的结果。

CPU 高速执行能力和 I/O 设备的读写速度严重不匹配导致线程阻塞。多线程和多进程只是解决这一问题的一种方法，而另一种解决 I/O 问题的方法就是异步 I/O。

异步 I/O 模型 需要一个 消息循环。在消息循环中，主线程不断地重复 读取消息 / 处理消息 这一过程：

在开始异步 I/O 模型学习前，我们先来了解 协程 的概念。

协程 ( Coroutine )，又称微线程、纤程。协程不是进程或线程，其执行过程更 类似于 子程序，或者说 不带返回值的函数调用。

例如：A 调用 B，B 中又调用了 C。C 执行完毕返回，B 执行完毕返回，最后是 A 执行完毕。

子程序调用是通过栈实现的，一个线程 就是执行 一个子程序。子程序调用总是 一个入口，一次返回，且 调用顺序是明确的。

而协程的调用和子程序是不同的。协程看上去也是子程序，但在执行过程中，调用顺序不固定，在子程序内部可中断转而执行别的子程序，在适当的时再返回来接着执行原子程序。

从上述例子结果可看出，A、B 的执行有点像多线程，但协程的特点在于是一个线程执行，那和多线程比，协程有何优势？

协程极高的执行效率：因为子程序切换不是线程切换，而是由程序自身控制。因此，没有线程切换的开销，和多线程相比，线程数量越多协程的性能优势就越明显。

不需要多线程的锁机制：因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，故执行效率相对多线程要高。

因为协程是一个线程执行，是否可利用多核 CPU 获得更高的性能，若方案可行的话如何操作？最简单的方法是 多进程 + 协程，既充分利用多核，又充分发挥协程的高效率。

Python 对协程的支持是通过 generator 实现的，例如：

若改用协程，生产者生产消息后，直接通过 yield 跳转到消费者开始执行，待消费者执行完毕后切换回生产者继续生产。

asyncio 的编程模型是一个 消息循环。我们从 asyncio 模块中直接获取一个 EventLoop 的引用，然后把需要执行的协程扔到 EventLoop 中执行，就实现了异步 I/O，具体操作实例：

hello() 会首先打印出 Hello world!。然后，yield from 语法可以让我们方便地调用另一个 generator。由于 asyncio.sleep() 也是一个 coroutine，所以线程不会等待 asyncio.sleep()，而是直接中断并执行下一个消息循环。当 asyncio.sleep() 返回时，线程就可以从 yield from 拿到返回值 ( 此处是 None )，然后接着执行下一行语句。

若我们把 asyncio.sleep(1) 看成是一个耗时一秒的 I/O 操作。在此期间，主线程并未等待，而是去执行 EventLoop 中其他可以执行的 coroutine，因此实现了 并发执行。

举一反三：我们尝试用 Task 封装两个 coroutine：

具体应用场景：我们 asyncio 的异步网络连接来获取 sina、sohu 的首页。

为简化并更好地标识异步 I/O，从 Python 3.5 开始引入了新语法 async 和 await，可以让 coroutine 的代码更简洁易读。请注意，async 和 await 是针对 coroutine 的新语法，即只需要做两步简单的替换：

把 yield from 替换为 await.

asyncio 可实现单线程并发 I/O 操作。若仅用在客户端，发挥的威力不大。若在服务器端，例如Web服务器，由于HTTP连接就是 I/O 操作，因此可以用 单线程 + coroutine 实现多用户的高并发支持。

asyncio 实现了 TCP、UDP、SSL 等协议，aiohttp 则是基于 asyncio 实现的 HTTP 框架。