如果你是一名刚刚学完python的基本语法，但仅限于了解基本语法的学生或者爱好者的话，如果时间充足，在正式开发前，或许你可以看看这个合集

错误、调试和测试

错误：程序运行中，会遇到原因导致的各种错误，如：程序编写有问题、用户输入有问题、程序运行过程中无法预测到的特殊情况。python内置了一套异常处理机制，来帮助我们处理错误

调试：在程序运行过程中跟踪变量的值，Python的pdb可以让我们以单步方式执行代码。

测试：有了良好的测试，就可以在程序修改后反复运行，确保程序输出符合我们编写的测试。

错误处理

高级编程语言都会配置"try…except…finally"，错误其实是一个类，因此使用多个except时，要注意把子类放在前面

抛出异常

raise可以抛出异常

为什么要专门抛出异常，不能直接在except里直接print吗？

1. raise的话，会直接return，不然你这个函数会继续执行，发生难以预测的错误（比如错误地写入数据库）
2. raise的话可以把错误交给上层函数处理，它可以携带错误的原始信息
3. web框架等更适合raise，会有统一的全局兜底机制
4. print不会记录日志系统，对于可重复的错误，你也不可能说上线后在终端里看print了什么，更别说还有很多不知道怎么复现的错误
5. 其他

记录错误

python内置logging模块可以记录错误

调试

调试(debug)有多种方法，比如print、断言(assert)、logging、pdb、IDE设置断点单步执行。

我们最常用的是利用IDE或logging

单元测试

pass

文档测试

文档测试采用python内置的doctest模块测试，这个模块能够提取你在文档字符串中的交互式用例

符号	含义
>>>	要执行的代码
下一行	预期输出
…	续行或异常堆栈通配符

通过if __name__ == '__main__' 来保证作为模块被导入时doctest不会被执行

IO编程

IO编程中，Stream（流）是一个很重要的概念，可以把流想象成一个水管，数据就是水管里的水，但是只能单向流动。Input Stream就是数据从外面（磁盘、网络）流进内存，Output Stream就是数据从内存流到外面去。对于浏览网页来说，浏览器和新浪服务器之间至少需要建立两根水管，才可以既能发数据，又能收数据。

但CPU和内存的速度非常快，外设的速度相对慢了不少，可能输出100M的数据只要0.1S，但接收100M的数据要10S，这要怎么办呢？我们可以选择等着，让程序暂停执行后续代码，等这100M的数据全部写入磁盘，再执行；也可以选择利用这个时间去干别的事。前者称为同步IO 后者称为异步IO

异步IO性能优于同步IO，但编程模型复杂

回调模式：服务员来找你

轮询模式：服务员给你发消息，你不停地看手机

操作IO的能力都是由操作系统提供的，每一种编程语言都会把操作系统提供的低级C接口封装起来方便使用，后面详细讨论Python IO编程接口

先用一张图片来梳理一下整体分块

文件读写

读文件

采用python内置的open() 函数以读文件的模式打开一个文件对象，传入文件名和标示符

>>> f = open('/Users/michael/test.txt', 'r')

r 表示以读的方式打开该文件对象。

如果文件不存在，open() 函数会抛出一个IOError (事实上，这是Python2时代抛出的错误，现在会直接抛出更精确的FileNotFoundError)

如果文件打开成功，调用read() 方法，一次读取文件的全部内容，Python将内容读取到内存，用一个str对象表示

另外，你或许需要记得使用close() 方法来关闭文件，因为文件对象会占用操作系统的资源，而且操作系统同一时间能打开的文件数量也是有限的

如果你直接单纯地先open再read再close，那会非常地麻烦，因为文件读写时都有可能产生IOError，这样的话，close()并不会被调用，于是聪明的你想到了try...finally... 但每次都要这样太麻烦了，于是我们采用with 语句来解决

with open('test.txt', 'w') as f:
    f.write('hello')
# 离开 with 代码块时，文件会自动关闭

read() 会一次性读取文件所有内容；如果文件过大，内存可能会爆掉，因此我们又有read(size) 按量读取；另外，还有readline() 会按/n 读取，并返回一个列表这个方法通常用于配置文件，但事实上，在真实的开发中，我们几乎永远不会去用readline（）手写配置文件

file-like Object

file-like Object不要求从特定类继承(这点有别于java/cpp等强类型语言，他们可能会要求你继续某个特定的File类)，只要写个read()方法就行。像open() 函数这样返回一个有read() 方法的对象，就叫file-like Object。除了file外，内存的字节流，网络流，自定义流等等都是file-like Object。

二进制文件

前面讲的都是由utf-8编码的文本文件，要打开二进制文件，如图片、视频，要用rb模式打开文件

示例代码：

>>> f = open('/Users/michael/test.jpg', 'rb')
>>> f.read()
b'\xff\xd8\xff\xe1\x00\x18Exif\x00\x00...' # 十六进制表示的字节

字符编码

要打开非utf-8编码的文本文件，要给open()函数传入encoding 参数，如：

>>> f = open('/Users/michael/gbk.txt', 'r', encoding='gbk')
>>> f.read()
'测试'

写文件

写文件和读文件的唯一区别是传入标识符不同，我们通过传入w 或wb 来写文本或二进制文件。

可以反复调用write()来写入文件，但是务必要调用f.close()来关闭文件。当我们写文件时，操作系统往往不会立刻把数据写入磁盘，而是放到内存缓存起来，空闲的时候再慢慢写入。只有调用close()方法时，操作系统才保证把没有写入的数据全部写入磁盘。忘记调用close()的后果是数据可能只写了一部分到磁盘，剩下的丢失了。所以，还是用with语句一步到位吧

with open('/Users/michael/test.txt', 'w') as f:
    f.write('Hello, world!')

要写入特定编码的文本文件，请给open()函数传入encoding参数，将字符串自动转换成指定编码。

以'w'模式写入文件时，如果文件已存在，会直接覆盖（相当于删掉后新写入一个文件）。如果我们希望追加到文件末尾怎么办？可以传入'a'以追加（append）模式写入。

StringIO和BytesIO

很多时候读写数据不一定是针对文件，而是在内存中读写

StringIO

StringIO，即在内存中读写str。

把str写入StringIO

要进行写操作的话，先创建一个StringIO()，然后像写文件一样操作就好了

>>> from io import StringIO
>>> f = StringIO()
>>> f.write('hello')
5
>>> f.write(' ')
1
>>> f.write('world!')
6
>>> print(f.getvalue())
hello world!

getvalue()方法用于获得写入后的str

读取StringIO

要读取StringIO，可以用一个str初始化StringIO（即示例代码中的f = StringIO('Hello!\nHi!\nGoodbye!') 中的'Hello!\nHi!\nGoodbye!'），然后，像读文件一样读取:

>>> from io import StringIO
>>> f = StringIO('Hello!\nHi!\nGoodbye!')
>>> while True:
...     s = f.readline()
...     if s == '':
...         break
...     print(s.strip())
...
Hello!
Hi!
Goodbye!

或许你会疑惑，"像文件一样读取"和前面的getvalue() 方法到底有什么区别？二者的区别在于有没有游标（指针），前者会记录你移动了多少步，指向了哪个位置，而后者会直接把内容全部呈现给你

BytesIO

StringIO是在内存中读写Str，如果要操作二进制数据，就要使用BytesIO 了

写操作

创建一个BytesIO ，然后写入（写入的不是str，而是UTF-8编码的bytes）

>>> from io import BytesIO
>>> f = BytesIO()
>>> f.write('中文'.encode('utf-8'))
6
>>> print(f.getvalue())
b'\xe4\xb8\xad\xe6\x96\x87'

读操作

和StringIO类似，先用一个bytes 初始化，然后像文件一样读取

>>> from io import BytesIO
>>> f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
>>> f.read()
b'\xe4\xb8\xad\xe6\x96\x87'

操作文件和目录

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

如果要在Python程序中执行这些目录和文件的操作怎么办？其实操作系统提供的命令只是简单地调用了操作系统提供的接口函数，Python内置的os模块也可以直接调用操作系统提供的接口函数。

操作文件和目录的函数，一部分放在os模块中，一部分放在os.path模块中

目录

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

# 查看当前目录的绝对路径（在开发中通常先拿到绝对路径，因为程序运行的文件夹可能不固定）:
>>> os.path.abspath('.')
'/Users/michael'
# 在某个目录下创建一个新目录，首先把新目录的完整路径表示出来:
>>> os.path.join('/Users/michael', 'testdir')
'/Users/michael/testdir'
# 然后创建一个目录:
>>> os.mkdir('/Users/michael/testdir')
# 删掉一个目录:
>>> os.rmdir('/Users/michael/testdir')

不同操作系统路径分隔符不同，类Unix系统是/,而Windows是\,因此我们不直接拼字符串，而是使用os.path.join()函数，同样地，拆分路径时，我们也不直接拆字符串，而是使用os.path.split函数

# 把一个路径拆分为两部分，后一部分总是最后级别的目录或文件名
>>> os.path.split('/Users/michael/testdir/file.txt')
('/Users/michael/testdir', 'file.txt')

os.path.splitext()可以直接让你得到文件扩展名，很多时候非常方便

>>> os.path.splitext('/path/to/file.txt')
('/path/to/file', '.txt')

文件

假定当前目录下有一个test.txt文件：

# 对文件重命名:
>>> os.rename('test.txt', 'test.py')
# 删掉文件:
>>> os.remove('test.py')

但复制文件的函数在os 模块中并不存在，因为复制文件并不在操作系统提供的系统调用的范畴中。但我们可以使用shutil模块提供的copyfile()函数，你还可以在shutil模块中找到很多实用函数，它们可以看做是os模块的补充。

最后看看如何利用Python的特性来过滤文件。比如我们要列出当前目录下的所有目录，只需要一行代码：

>>> [x for x in os.listdir('.') if os.path.isdir(x)]
['.lein', '.local', '.m2', '.npm', '.ssh', '.Trash', '.vim', 'Applications', 'Desktop', ...]

要列出所有的.py文件，也只需一行代码：

>>> [x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py']
['apis.py', 'config.py', 'models.py', 'pymonitor.py', 'test_db.py', 'urls.py', 'wsgiapp.py']

序列化

在程序运行的过程中，所有变量都在内存中，如果不将其存在磁盘上的话，下次还是最开始的值。

我们把变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。

序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。

反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

Python提供了pickle模块来实现序列化。

Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。我们用的也不多，此处就不详细介绍了。

JSON

在不同编程语言之间传递对象，就必须将其序列化为标准格式，如xml、json。

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

JSON类型	Python类型
{}	dict
[]	list
“string”	str
1234.56	int或float
true/false	True/False
null	None

Python内置的json模块提供了非常完善的Python对象到JSON格式的转换。我们先看看如何把Python对象变成一个JSON：

>>> import json
>>> d = dict(name='Bob', age=20, score=88)
>>> json.dumps(d)
'{"age": 20, "score": 88, "name": "Bob"}'

dumps()方法返回一个str，内容就是标准的JSON。类似的，dump()方法可以直接把JSON写入一个file-like Object。

要把JSON反序列化为Python对象，用loads()或者对应的load()方法，前者把JSON的字符串反序列化，后者从file-like Object中读取字符串并反序列化：

>>> json_str = '{"age": 20, "score": 88, "name": "Bob"}'
>>> json.loads(json_str)
{'age': 20, 'score': 88, 'name': 'Bob'}

由于JSON标准规定JSON编码是UTF-8，所以我们总是能正确地在Python的str与JSON的字符串之间转换。

JSON进阶

Python的dict对象可以直接序列化为JSON的{}，不过，很多时候，我们更喜欢用class表示对象，比如定义Student类，然后序列化：

import json

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

s = Student("Bob", 20, 88)
print(json.dumps(s))

运行代码，毫不留情地得到一个TypeError

Traceback (most recent call last):
  ...
TypeError: <__main__.Student object at 0x10603cc50> is not JSON serializable

它说Student对象不是一个可序列化为JSON的对象。这时候就要不服了，dict能转json，为什么我这个实例对象不能转，从json的视角看，上面的数据和下面这个字典完全等价：

{name: "Bob", age: 20, score: 88}

实例对象明明就是最标准、最完美的结构化数据，如果 JSON 竟然认不出它，那不是 JSON 眼瞎吗？

是时候去看看官方文档了https://docs.python.org/3/library/json.html#json.dumps，我们发现，除了第一个必须的obj参数外，dumps()方法还提供了一大堆的可选参数，这些可选参数就是让我们来定制JSON序列化。前面的代码之所以无法把Student类实例序列化为JSON，是因为默认情况下，dumps()方法不知道如何将Student实例变为一个JSON的{}对象。那我们就写一个转换函数student2dict(),将实例转为dict，再序列化为json

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

>>> print(json.dumps(s, default=student2dict))
{"age": 20, "name": "Bob", "score": 88}

但如果遇到一个其他实例，如Teacher类的实例，照样无法序列化为JSON。我们可以偷个懒，把任意class的实例变为dict

print(json.dumps(s, default=lambda obj: obj.__dict__))

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

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

def dict2student(d):
    return Student(d['name'], d['age'], d['score'])

运行结果如下：

>>> json_str = '{"age": 20, "score": 88, "name": "Bob"}'
>>> print(json.loads(json_str, object_hook=dict2student))
<__main__.Student object at 0x10cd3c190>

打印出的是反序列化的Student实例对象。