错误、调试和测试：
错误处理：
try:
print('try...')
r = 10 / 0
print('result:', r)
except ZeroDivisionError as e:
print('except:', e)
finally:
print('finally...')
print('END')
首先是执行语句，然后发现错误了就会跳转到执行except，语句，然后按顺序执行，如果是正确的就不会执行except语句。
其中的Error还可以细分，错误本身也是一个类，都继承自BaseException，所以尽量不要出现错误的父类和子类同时捕获，
因为这时候只会执行父类的捕获错误。
调用栈：
如果一个错误没有被捕获，就会一直往上抛，最后被python解释器捕获，出错的时候通过分析错误的调用栈信息，可以定位
错误的位置。
记录错误：
python内置的logging模块可以非常容易地记录错误信息
# err_logging.py
import logging
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar('0')
except Exception as e:
logging.exception(e)
main()
print('END')
$ python3 err_logging.py
ERROR:root:division by zero
Traceback (most recent call last):
File "err_logging.py", line 13, in main
bar('0')
File "err_logging.py", line 9, in bar
return foo(s) * 2
File "err_logging.py", line 6, in foo
return 10 / int(s)
ZeroDivisionError: division by zero
END
抛出错误：
因为错误是class，然后捕获一个错误就是捕获到一个实例，如果要抛出错误，可以根据需要定义一个错误的class，
选择好继承关系，然后用raise语句抛出一个错误的实例。只有在必要的时候才定义我们自己的错误类型，如果可以，
尽量使用python内置的错误类型。
最后还有一种错误处理的方式：
# err_reraise.py
def foo(s):
n = int(s)
if n==0:
raise ValueError('invalid value: %s' % s)
return 10 / n
def bar():
try:
foo('0')
except ValueError as e:
print('ValueError!')
raise
bar()
捕获异常后，又把错误用过raise语句抛出去，是因为，捕获错误的目的只是记录一下，由于当前函数不知道
应该怎么处理该错误，所以往上抛是一种很好的方式，最终会让顶层调用者去处理。
调试：
1.一种方法简单粗暴，直接用print()打印。
2.断言，凡是用print()来辅助查看的都可以用断言(assert)来替代。
3.logging，把print()替换为logging是第三种方式，logging可以指定记录信息的级别，有debug，info，warning，error
等几个级别，指定高级别的时候，低级别就不起作用了。
4.pdb，启用python的调试器pdb，让程序以单步方式运行，可以随时查看运行状态。pdb.set_trace()，也是用pdb，只
需要导入pdb，然后在可能出错的地方放一个pdb.set_trace()，就可以设置一个断点，到了之后就会暂停并进入pdb
调试环境，用p可以查看变量，用c继续运行。
5.IDE，支持调试功能的IDE，有一些比较好的Python IDE。
单元测试：
用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作。我们给出一系列数据，然后期望输出的结果是我们
预期的结果，如果不相符就说明我们的代码中存在问题。
文档测试：
利用注释来告知代码我们希望得到的结果，然后又一些工具来自动生成文档。
IO编程：
IO指的是Input/Output，也就是输入和输出。IO编程中由于内外设备的速度不匹配，又可以分为同步IO和异步IO两种方式，
现在涉及到的是同步IO
文件读写：
读文件
>>> f = open('/Users/michael/test.txt', 'r')
如果不存在就会报错，然后如果成功打开调用read()方法就可以一次性读到内存当中，用一个str对象表示，要记得调用
close()方法来关闭文件，如果出错是无法关闭文件的，f.close()也不会调用，所以用try...finally来实现，但是总写会很麻烦，
所以可以调用python的with语句来自动调用close()方法：
with open('/path/to/file', 'r') as f:
print(f.read())
想open()函数这种返回有个read()方法的对象，在python中统称为file-like Object，除了file外还有很多其他的流，不过只要
有个read()方法就可以了。读
>>> from io import StringIO
>>> f = StringIO()
>>> f.write('hello')
5
>>> f.write(' ')
1
>>> f.write('world!')
6
>>> print(f.getvalue())
hello world!
操作二进制数据就需要使用BytesIO。
StringIO和BytesIO是在内存中操作str和bytes的方法，使得和读写文件具有一致的接口。
取二进制文件，用’rb‘模式打开文件就行；读取字符编码文本文件，添加一个encoding=’gkb'，遇到
不规范的可以添加参数errors=‘ignore'。
写文件
>>> f = open('/Users/michael/test.txt', 'w')
>>> f.write('Hello, world!')
>>> f.close()
写文件和读文件一样，不过区别在于传入的标识符，‘w'或者’wb‘表示文本文件或者写二进制文件，如果要写入特定编码的文本
文件，要给open()传入encoding参数，将字符串自动转换成特定编码。
StringIO和BytesIO
操作文件和目录：
python的os模块封装了操作系统的目录和文件操作，这些函数有的在os模块中，有的在os.path模块中。
序列化：
把变量从内存中变成可存储或可传输的过程称之为序列化，反过来把变量内容从序列化的对象重新读到内存里称之为反序列化。
python提供pickle模块来实现序列化，但是要把序列变得更通用、更符合Web标准，就可以使用json模块。
json模块的dumps()和loads()函数是用来序列化和反序列化的，如果默认的序列化和反序列化机制不满足要求时，可以传入更多
的参数来定制序列化或反序列化规则。
进程和线程：
多任务的实现方式有3种：1.多进程模式；
2.多线程模式；
3.多进程+多线程模式
线程时最小的执行单元，而进程由至少一个线程组成。
多进程：
在Unix/Linux下，可以使用fork()调用实现多进程。
如果要实现跨平台的多进程，可以使用multiprocessing模块。
subprocess模块可以很方便地启动一个子进程，然后控制其输入和输出。
进程间通信时通过Queue、Pipes等实现地。
多线程：
同一个进程内多个线程，python地标准库提供了_thread和threading两个模块，绝大多数下使用threading这个高级模块。
启动一个线程就是把一个函数传入并创建Thread实例，然后调用start()开始执行。多线程中，由于线程地调度是由系统
决定地，当线程交替执行时，很容易造成内容被乱改。为了确保变量，可以给线程上锁，一个进程提供一个锁，然后让
线程去获取该锁，这样线程就只有在获得锁的情况下才能执行语句，就不会造成冲突了。然后坏处的话只要时降低了
效率以及容易造成死锁。Python的解释器执行代码时，有一个GIL锁：Global Interpreter Lock，任何Python线程执行前，
必须先获得GIL锁。这个GIL全局锁实际上把所有线程的执行代码都给上锁。
ThreadLocal：
import threading
# 创建全局ThreadLocal对象:
local_school = threading.local()
def process_student():
# 获取当前线程关联的student:
std = local_school.student
print('Hello, %s (in %s)' % (std, threading.current_thread().name))
def process_thread(name):
# 绑定ThreadLocal的student:
local_school.student = name
process_student()
t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A')
t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()
局部变量在函数调用时很麻烦，一层一层传递很麻烦，全局变量local_school就是一个ThreadLocal对象，每个Thread
对它都可以读写student属性，但互不影响。可以把local_school看成全局变量，每个属性如local_school.student都是线
程的局部变量，可以任意读写而互不干扰，也不用管理锁的问题，ThreadLocal内部会处理。
ThreadLocal最常用的地方就是为每个线程绑定一个数据库连接，HTTP请求，用户身份信息等，这样一个线程的所有调
用到的处理函数都可以非常方便地访问这些资源。一个ThreadLocal变量虽然是全局变量，但每个线程都只能读写自己
线程的独立副本，互不干扰。ThreadLocal解决了参数在一个线程中各个函数都可以非常方便地访问这些资源。
分布式进程：
Python地分布式进程接口简单，封装良好，适合需要把繁重任务分布到多台机器地环境下。
注意Queue地作用是用来传递任务和接收结果，每个任务的描述数据量要尽量小。比如发送一个处理日志文件的任务，
就不要发送几百兆的日志文件本身，而是发送日志文件存放的完整路径，由Worker进程再去共享的磁盘上读取文件。