改善 Python 程序的 91 个建议

学习笔记 博客素材

第 1 章 引论

建议 1：理解 Pythonic 概念

Pythonic
当你输入 import this 就会显示 zen of python

美丽胜于丑陋。
显式优于隐式。
简单比复杂好。
复合胜于复杂。
平面比嵌套好。
稀疏比密集好。
可读性是重要的。
特殊情况不足以打破规则。
虽然实用性胜过纯粹。
除了显示错误，错误永远不应该沉默。

代码风格
充分体现python动态语言的特色，类似于

# 变量交换
a, b = b, a
# 上下文管理
with open(path, 'r') as f:
    do_sth_with(f)
# 不应当过分地追求奇技淫巧
a = [1, 2, 3, 4]
a[::-1] # 不推荐。好吧，自从学了切片我一直用的这个
list(reversed(a))   # 推荐

然后表扬了 Flask 框架，提到了 generator 之类的特性尤为 Pythonic，有个包和模块的约束：
* 包和模块的命名采用小写、单数形式，而且短小
* 包通常仅作为命名空间，如只含空的init.py文件

建议 2：编写 Pythonic 代码

避免劣化代码

• 避免只用大小写区分不同的对象
• 避免使用容易引起混淆的名称
• 不要害怕过长的变量名

深入认识python有助于编写pythonic代码

• 全面掌握 python 提供的特性，包括语言和库
• 随着时间推移，要不断更新知识
• 深入学习业界公认的 pythoni 代码
• 编写符合 pep8 的代码规范（就是让你使用pycharm）

建议 3：理解 Python 与 C 语言的不同之处

• Python 使用代码缩进的方式来分割代码块，不要混用 Tab 键和空格
• Python 中单、双引号的效果相同（个人建议使用单引号，在面对其他语言的双引号源码时不必再转义）
• 三元操作符：x if bool else y（原因是作者认为应该用可读性更好的方式表达）
• 用其他方法替代 switch-case

建议 4：在代码中适当添加注释

• 块和行注释仅仅注释复杂的操作、算法等
• 注释和代码隔开一段距离
• 给外部可访问的函数和方法添加文档注释
• 推荐在文件头中包含 copyright 申明、模块描述等

另外，编写代码应该朝代码即文档的方向进行，但仍应该注重注释的使用

建议 5：通过适当添加空行使代码布局更为优雅、合理

• 表达完一个完整思路后，应该用空白行间隔，尽量不要在一段代码中说明几件事。
• 尽量保持上下文的易理解性，比如调用者在上，被调用者在下
• 避免过长的代码行，超过80个字符应该使用行连接换行（还是让你使用pycharm）
• 水平对齐毫无意义，不要用多余空格保持对齐
• 空格的使用要能够在需要使用时强调警示读者（符合PEP8规范）

建议 6：编写函数的 4 个原则

1. 函数设计要尽量短小，嵌套层次不宜过深
2. 函数申明应该做到合理、简单、易于使用
3. 函数参数设计应该考虑向下兼容
4. 一个函数只做一件事，尽量保证函数语句粒度的一致性

Python 中函数设计的好习惯还包括：不要在函数中定义可变对象作为默认值，使用异常替换返回错误，保证通过单元测试等。

# 关于函数设计的向下兼容
def readfile(filename):         # 第一版本
    pass
def readfile(filename, log):    # 第二版本
    pass
def readfile(filename, logger=logger.info):     # 合理的设计
    pass

最后还有个函数可读性良好的例子：

def GetContent(ServerAdr, PagePath):
    http = httplib.HTTP(ServerAdr)
    http.putrequest('GET', PagePath)
    http.putheader('Accept', 'text/html')
    http.putheader('Accept', 'text/plain')
    http.endheaders()
    httpcode, httpmsg, headers = http.getreply()
    if httpcode != 200:
        raise "Could not get document: Check URL and Path."
    doc = http.getfile()
    data = doc.read()       # 此处是不是应该使用 with ？
    doc.close
    return data
def ExtractData(inputstring, start_line, end_line):
    lstr = inputstring.splitlines()             # split
    j = 0
    for i in lstr:
        j += 1
        if i.strip() == start_line: slice_start = j
        elif i.strip() == end_line: slice_end = j
    return lstr[slice_start:slice_end]
def SendEmail(sender, receiver, smtpserver, username, password, content):
    subject = "Contented get from the web"
    msg = MIMEText(content, 'plain', 'utf-8')
    msg['Subject'] = Header(subject, 'utf-8')
    smtp = smtplib.SMTP()
    smtp.connect(smtpserver)
    smtp.login(username, password)
    smtp.sendmail(sender, receiver, msg.as_string())
    smtp.quit()

建议 7：将常量集中到一个文件

在Python中应当如何使用常量：

• 常量名全部大写
• 将存放常量的文件命名为constant.py

示例为：

class _const:
    class ConstError(TypeError): pass
    class ConstCaseError(ConstError): pass
    def __setattr__(self, name, value):
        if self.__dict__.has_key(name):
            raise self.ConstError, "Can't change const.%s" % name
        if not name.isupper():
            raise self.ConstCaseError, \
                    'const name "%s" is not all uppercase' % name
        self.__dict__[name] = value
import sys
sys.modules[__name__] = _const()
import const
const.MY_CONSTANT = 1
const.MY_SECOND_CONSTANT = 2
const.MY_THIRD_CONSTANT = 'a'
const.MY_FORTH_CONSTANT = 'b'

其他模块中引用这些常量时，按照如下方式进行即可：

from constant import const
print(const.MY_CONSTANT)

第 2 章 编程惯用法

建议 8：利用 assert 语句来发现问题

断言的判断会对性能有所影响，因此要分清断言的使用场合：

• 断言应使用在正常逻辑无法到达的地方或总是为真的场合
• python本身异常处理能解决的问题不需要用断言
• 不要使用断言检查用户输入，而使用条件判断
• 在函数调用后，当需要确认返回值是否合理时使用断言
• 当条件是业务的先决条件时可以使用断言

代码示例：

>>> y = 2
>>> assert x == y, "not equals"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: not equals
>>> x = 1
>>> y = 2
# 以上代码相当于
>>> if __debug__ and not x == y:
...     raise AssertionError("not equals")
... 
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
AssertionError: not equals

运行是加入-O参数可以禁用断言。

建议 9：数据交换的时候不推荐使用中间变量

>>> Timer('temp = x; x = y; y = temp;', 'x = 2; y = 3').timeit()
0.059251302998745814
>>> Timer('x, y = y, x', 'x = 2; y = 3').timeit()
0.05007316499904846

对于表达式x, y = y, x，在内存中执行的顺序如下：
1. 先计算右边的表达式y, x，因此先在内存中创建元组(y, x)，其标识符和值分别为y, x及其对应的值，其中y和x是在初始化已经存在于内存中的对象
2. 计算表达式左边的值并进行赋值，元组被依次分配给左边的标识符，通过解压缩，元组第一标识符y分配给左边第一个元素x，元组第二标识符x分配给左边第一个元素y，从而达到交换的目的

（简单来说，直接交换符合pythonic且性能最佳，这么做就对了）

建议 10：充分利用 Lazy evaluation 的特性

（就是生成器）
Lazy evaluation常被译为延迟计算，体现在用 yield 替换 return 使函数成为生成器，好处主要有两方面：

1. 避免不必要的计算，带来性能提升
2. 节省空间，使无限循环的数据结构成为可能

def fib():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

建议 11：理解枚举替代实现的缺陷

使用 flufl.enum 实现枚举

建议 12：不推荐使用 type 来进行类型检查

使用 isinstance 来进行类型检查（注意上下包含关系就行）

建议 13：尽量转换为浮点类型后再做除法

py2.x:转换浮点类型后再做除法

建议 14：警惕 eval() 的安全漏洞

eval具有安全漏洞，建议使用安全性更好的ast.literal_eval。

建议 15：使用 enumerate() 获取序列迭代的索引和值

>>> li = ['a', 'b', 'c', 'd', 'e']
>>> for i, e in enumerate(li):
...     print('index: ', i, 'element: ', e)
... 
index:  0 element:  a
index:  1 element:  b
index:  2 element:  c
index:  3 element:  d
index:  4 element:  e
# enumerate(squence, start=0) 内部实现
def enumerate(squence, start=0):
    n = start
    for elem in sequence:
        yield n, elem   # 666
        n += 1
# 明白了原理我们自己也来实现一个反序的
def reversed_enumerate(squence):
    n = -1
    for elem in reversed(sequence):
        yield len(sequence) + n, elem
        n -= 1

（此方式相比从列表里放索引取值更加优雅）

建议 16：分清 == 与 is 的适用场景

比较有趣的：

>>> s1 = 'hello world'
>>> s2 = 'hello world'
>>> s1 == s2
True
>>> s1 is s2
False
>>> s1.__eq__(s2)
True
>>> a = 'Hi'
>>> b = 'Hi'
>>> a == b
True
>>> a is b
True

为了提高系统性能，对于较小的字符串会保留其值的一个副本，当创建新的字符串时直接指向该副本，所以a和b的 id 值是一样的，同样对于小整数[-5, 257)也是如此：

注意is不相当于 ==， is 是对 id 方法做的 == 。

建议 17：考虑兼容性，尽可能使用 Unicode

python2.x 这是无敌深坑，需要刻苦学习掌握（python3偶尔也会碰到这种问题，但避免了大多数这种可能）

建议 18：构建合理的包层次来管理 module

（__init__是对包的头文件定制）
本质上每一个 Python 文件都是一个模块，使用模块可以增强代码的可维护性和可重用性，在较大的项目中，我们需要合理地组织项目层次来管理模块，这就是包(Package)的作用。

一句话说包：一个包含__init__.py 文件的目录。包中的模块可以通过.进行访问，即包名.模块名。那么这\个init.py文件有什么用呢？最明显的作用就是它区分了包和普通目录，在该文件中申明模块级别的 import 语句从而变成了包级别可见，另外在该文件中定义__all__变量，可以控制需要导入的子包或模块。

这里给出一个较为合理的包组织方式，是FlaskWeb 开发：基于Python的Web应用开发实战一书中推荐而来的：

|-flasky
    |-app/                      # Flask 程序
        |-templates/            # 存放模板
        |-static/               # 静态文件资源
        |-main/
            |-__init__.py
            |-errors.py         # 蓝本中的错误处理程序
            |-forms.py          # 表单对象
            |-views.py          # 蓝本中定义的程序路由
        |-__init__.py
        |-email.py              # 电子邮件支持
        |-models.py             # 数据库模型
    |-migrations/               # 数据库迁移脚本
    |-tests/                    # 单元测试
        |-__init__.py
        |-test*.py
    |-venv/                     # 虚拟环境
    |-requirements/
        |-dev.txt               # 开发过程中的依赖包
        |-prod.txt              # 生产过程中的依赖包
    |-config.py                 # 储存程序配置
    |-manage.py                 # 启动程序以及其他的程序任务

第 3 章：基础语法

建议 19：有节制地使用 from...import 语句

Python 提供三种方式来引入外部模块：import语句、from...import语句以及__import__函数，其中__import__函数显式地将模块的名称作为字符串传递并赋值给命名空间的变量。

使用import需要注意以下几点：

• 优先使用import a的形式
• 有节制地使用from a import A
• 尽量避免使用from a import *

为什么呢？我们来看看 Python 的 import 机制，Python 在初始化运行环境的时候会预先加载一批内建模块到内存中，同时将相关信息存放在sys.modules中，我们可以通过 sys.modules.items() 查看预加载的模块信息，当加载一个模块时，解释器实际上完成了如下动作：

1. 在 sys.modules 中搜索该模块是否存在，如果存在就导入到当前局部命名空间，如果不存在就为其创建一个字典对象，插入到 sys.modules 中
2. 加载前确认是否需要对模块对应的文件进行编译，如果需要则先进行编译
3. 执行动态加载，在当前命名空间中执行编译后的字节码，并将其中所有的对象放入模块对应的字典中

>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>> import test
testing module import
>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'test']
>>> import sys
>>> 'test' in sys.modules.keys()
True
>>> id(test)
140367239464744
>>> id(sys.modules['test'])
140367239464744
>>> dir(test)
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b']
>>> sys.modules['test'].__dict__.keys()
dict_keys(['__file__', '__builtins__', '__doc__', '__loader__', '__package__', '__spec__', '__name__', 'b', 'a', '__cached__'])

从上可以看出，对于用户自定义的模块，import 机制会创建一个新的 module 将其加入当前的局部命名空间中，同时在 sys.modules 也加入该模块的信息，但本质上是在引用同一个对象，通过test.py所在的目录会多一个字节码文件。

（这节说的是，盲目使用from...import...会带来：

1. 命名空间冲突
2. 循环嵌套导入）

建议 20：优先使用 absolute import 来导入模块

（py3 中 relative import方法已被移除，不用操心）

建议 21： i+=1 不等于 ++i

++i 合法，但是无效

建议 22：使用 with 自动关闭资源

对于打开的资源我们记得关闭它，如文件、数据库连接等，Python 提供了一种简单优雅的解决方案：with。

with的实现得益于一个称为上下文管理器(context manager)的东西，它定义程序运行时需要建立的上下文，处理程序的进入和退出，实现了上下文管理协议，即对象中定义了enter()和exit()，任何实现了上下文协议的对象都可以称为一个上下文管理器：

• enter()：返回运行时上下文相关的对象
• exit(exception_type, exception_value, traceback)：退出运行时的上下文，处理异常、清理现场等

包含with语句的代码块执行过程如下：

>>> with open('test.txt', 'w') as f:
...     f.write('test')
... 
4
>>> f.__enter__
<built-in method __enter__ of _io.TextIOWrapper object at 0x7f1b967aaa68>
>>> f.__exit__
<built-in method __exit__ of _io.TextIOWrapper object at 0x7f1b967aaa68>

1. 计算表达式的值，返回一个上下文管理器对象
2. 加载上下文管理器对象的exit()以备后用
3. 调用上下文管理器对象的enter()
4. 将enter()的返回值赋给目标对象
5. 执行代码块，正常结束调用exit()，其返回值直接忽略，如果发生异常，会调用exit()并将异常类型、值及 traceback 作为参数传递给exit()，exit()返回值为 false 异常将会重新抛出，返回值为 true 异常将被挂起，程序继续执行

Python 还提供 contextlib 模块，通过 Generator 实现，其中的 contextmanager 作为装饰器来提供一种针对函数级别上的上下文管理器，可以直接作用于函数/对象而不必关心enter()和exit()的实现。

推荐文章

建议 23：使用 else 子句简化循环（异常处理）

python 的 else 子句在循环正常结束和循环条件不成立时被执行，由 break 语句中断时不执行，同样，我们可以利用这颗语法糖作用在 while 和 try...except 中。

建议 24：遵循异常处理的几点基本原则

异常处理的几点原则：
1. 注意异常的粒度，不推荐在 try 中放入过多的代码
2. 谨慎使用单独的 except 语句处理所有异常，最好能定位具体的异常
3. 注意异常捕获的顺序，在适合的层次处理异常，Python 是按内建异常类的继承结构处理异常的，所以推荐的做法是将继承结构中子类异常在前抛出，父类异常在后抛出
4. 使用更为友好的异常信息，遵守异常参数的规范

建议 25：避免 finally 中可能发生的陷阱

当 finally 执行完毕时，之前临时保存的异常将会再次被抛出，但如果 finally 语句中产生了新的异常或执行了 return 或 break 语句，那么临时保存的异常将会被丢失，从而异常被屏蔽。
在实际开发中不推荐 finally 中使用 return 语句进行返回。

建议 26：深入理解 None，正确判断对象是否为空

（None被判断为False，但是空集不等于None）
类型FalseTrue布尔False （与0等价）True （与1等价）字符串""（ 空字符串）非空字符串，例如 " ", "blog"数值0, 0.0非0的数值，例如：1, 0.1, -1, 2容器[], (), {}, set()至少有一个元素的容器对象，例如：[0], (None,), ['']NoneNone非None对象

>>> id(None)
10743840
>>> a = None
>>> id(a)
10743840
>>> l = []
>>> if l is not None:       # 判断逻辑 l 不为空
...     print('l is {}'.format(l))
... else:
...     print('l is empty')
... 
l is []
>>> if l:   # #3 正确的判断形式
...     print('Do something...')
... else:
...     print('Do other thing...')
... 
Do other thing...

执行中会调用nonzero()来判断自身对象是否为空并返回0/1或True/False，如果没有定义该方法，Python 将调用len()进行判断，返回 0 表示为空。如果一个类既没有定义len()又没有定义nonzero()，该类实例用 if 判断为True。

建议 27：连接字符串优先使用 join 而不是 +

连接字符串使用join将使程序性能更佳，原因是使用每次使用 + 都需要格外分一块内存去存储结果。

建议 28：格式化字符串时尽量使用 .format 而不是 %

format方法总结
使用 format 格式化字符串有以下好处：

• format更为灵活，参数顺序和格式不必完全相同
• format更为方便的作为参数传递（例如支持列表的索引操作）
• %最终会被format取代
• %容易抛出异常，而format则不会（未尝是好事）

建议 29：区别对待可变对象和不可变对象

Python 中一切皆对象，每个对象都有一个唯一的标识符（id）、类型（type）和值。数字、字符串、元组属于不可变对象，字典、列表、字节数组属于可变对象。

默认参数在初始化时仅仅被评估一次，以后直接使用第一次评估的结果，course 指向的是 list 的地址，每次操作的实际上是 list 所指向的具体列表，所以对于可变对象的更改会直接影响原对象。

最好的方法是传入None作为默认参数，在创建对象的时候动态生成列表。

>>> list1 = ['a', 'b', 'c']
>>> list2 = list1
>>> list1.append('d')
>>> list2
['a', 'b', 'c', 'd']
>>> list3 = list1[:]    # 可变对象的切片操作相当于浅拷贝
>>> list3.remove('a')
>>> list3
['b', 'c', 'd']
>>> list1
['a', 'b', 'c', 'd']

建议 30：[]、() 和 {} 一致的容器初始化形式

使用列表解析、字典解析、元组解析等替代for循环
解析式有以下好处：

• 代码更清晰、简洁
• 效率更高、速度更快
• （代码更加pythonic）

建议 31：记住函数传参既不是传值也不是传引用

正确的说法是传对象（call by object）或传对象的引用（call-by-object-reference），函数参数在传递过程中将整个对象传入，对可变对象的修改在函数外部以及内部都可见，对不可变对象的”修改“往往是通过生成一个新对象然是赋值实现的。

建议 32：警惕默认参数潜在的问题

其中就是默认参数如果是可变对象，在调用者和被调用者之间是共享的。
所以默认值使用可以使用数字、字符串、元组
不可以使用字典、列表、字节数组

import time
# 对当前系统时间进行处理
def report(when=time.time): # 而不是when=time.time()
    pass

建议 33：慎用变长参数

原因如下：
1. 使用过于灵活，导致函数签名不够清晰，存在多种调用方式
2. 使用*args和**kw简化函数定义就意味着函数可以有更好的实现方法

使用场景：
1. 为函数添加一个装饰器
2. 参数数目不确定
3. 实现函数的多态或子类需要调用父类的某些方法时

建议 34：深入理解 str() 和repr() 的区别

（str方法面向用户更为友好，repr解释更加清晰）
总结几点：

1. str()面向用户，返回用户友好和可读性强的字符串类型；repr()面向 Python 解释器或开发人员，返回 Python 解释器内部的含义
2. 解释器中输入a默认调用repr()，而print(a)默认调用str()
3. repr()返回值一般可以用eval()还原对象：obj == eval(repr(obj))
4. 以上两个方法分别调用内建的str()和repr()，一般来说类中都应该定义repr()，但当可读性比准确性更为重要时应该考虑str()，用户实现repr()方法的时候最好保证其返回值可以用eval()是对象还原

建议 35：分清 staticmethod 和 classmethod 的适用场景

（需要返回类的实例时，或需要动态生成对应类的类变量，使用classmethod，方法不跟实例与类相关（不适用self和cls），定义为静态方法（工具方法））

调用类方法装饰器的修饰器的方法，会隐式地传入该对象所对应的类，可以动态生成对应的类的类变量，同时如果我们期望根据不同的类型返回对应的类的实例，类方法才是正确的解决方案。

反观静态方法，当我们所定义的方法既不跟特定的实例相关也不跟特定的类相关，可以将其定义为静态方法，这样使我们的代码能够有效地组织起来，提高可维护性。

当然，也可以考虑定义一个模块，将一组的方法放入其中，通过模块来访问。

第 4 章 库

建议 36：掌握字符串的基本用法

# 小技巧：Python 遇到未闭合的小括号会自动将多行代码拼接为一行
>>> s = ('SELECT * '
...      'FROM table '
...      'WHERE field="value"')
>>> s
'SELECT * FROM table WHERE field="value"'
# Python2 中使用 basestring 正确判断一个变量是否是字符串
# 性质判断
isalnum() isalpha() isdigit() islower() isupper() isspace() istitle()
# 查找替换
startswith(prefix[, start[, end]]) endswith(suffix[, start[, end]]) # prefix参数可以接收 tuple 类型的实参
count(sub[, start[, end]]) find(sub[, start[, end]]) index(sub[, start[, end]])
rfind(sub[, start[, end]]) rindex(sub[, start[, end]]) replace(old, new[, count])   # count是指的替换次数，不指定就全部替换
# 切分
partition(sep) rpartition(sep) splitlines([keepends]) split([sep, [, maxsplit]]) rsplit([sep[, maxsplit]])  # partition 返回一个3个元素的元组对象
# 变形
lower() upper() capitalize() swapcase() title()
# 删减填充
strip([chars]) lstrip([chars]) rstrip([chars]) # 没有提供chars默认是空白符，由string.whitespace 常量定义
center(width[, fillchar]) ljuct(width[, fillchar]) rjust(width[, fillchar])
zfill(width) expandtabs([tabszie])

下面来介绍一些易混淆的地方：

>>> '  hello world'.split()
['hello', 'world']
>>> '  hello world'.split(' ')
['', '', 'hello', 'world']
>>> 'hello wORld'.title()
'Hello World'
>>> import string
>>> string.capwords(' hello world!')
'Hello World!'
>>> string.whitespace
' \t\n\r\x0b\x0c'

建议 37：按需选择 sort() 或者 sorted()

（sort方法是原地操作，sorted是复制操作，不需要保留源列表用sort）

# 函数原型
sorted(iterable[, cmp[, key[, reverse]]])   # 返回一个排序后的列表
s.sort([cmp[, key[, reverse]]])             # 直接修改原列表，返回为None
>>> persons = [{'name': 'Jon', 'age': 32}, {'name': 'Alan', 'age': 50}, {'name': 'Bob', 'age': 23}]
>>> sorted(persons, key=lambda x: (x['name'], -x['age']))
[{'name': 'Alan', 'age': 50}, {'name': 'Bob', 'age': 23}, {'name': 'Jon', 'age': 32}]
>>> a = (1, 2, 4, 2, 3)
>>> sorted(a)
[1, 2, 2, 3, 4]

所以如果实际过程中需要保留原有列表，可以使用sorted()。sort()不需要复制原有列表，消耗内存较小，效率较高。同时传入参数key比传入参数cmp效率要高，cmp传入的函数在整个排序过程中会调用多次，而key针对每个元素仅作一次处理。

建议 38：使用 copy 模块深拷贝对象

（对可变对象需要真正意义上的复制时使用copy.deepcopy，这种需求情况还是比较少见）

• 浅拷贝（shallow copy）：构造一个新的复合对象并将从原对象中发现的引用插入该对象中。工厂函数、切片操作、copy 模块中的 copy 操作都是浅拷贝

• 深拷贝（deep copy）：针对引用所指向的对象继续执行拷贝，因此产生的对象不受其它引用对象操作的影响。深拷贝需要依赖 copy 模块的 deepcopy() 操作

在 python 中，标识一个对象唯一身份的是：对象的id(内存地址)，对象类型，对象值，而浅拷贝就是创建一个具有相同类型，相同值但不同id的新对象。因此使用浅拷贝的典型使用场景是：对象自身发生改变的同时需要保持对象中的值完全相同，比如 list 排序：

def sorted_list(olist, key=None):
    copied_list = copy.copy(olist)
    copied_list.sort(key=key)
    return copied_list
a = [3, 2, 1]       # [3, 2, 1]
b = sorted_list(a)  # [1, 2, 3]

深拷贝不仅仅拷贝了原始对象自身，也对其包含的值进行拷贝，它会递归的查找对象中包含的其他对象的引用，来完成更深层次拷贝。因此，深拷贝产生的副本可以随意修改而不需要担心会引起原始值的改变：

>>> a = [1, 2]
>>> b = [a, a]
>>> b
[[1, 2], [1, 2]]
>>> from copy import deepcopy
>>> c = deepcopy(b)
>>> id(b[0]) == id(c[0])
False
>>> id(b[0]) == id(b[1])
True
>>> c
[[1, 2], [1, 2]]
>>> c[0].append(3)
>>> c
[[1, 2, 3], [1, 2, 3]]

使用 copy 和 deepcopy 可以完成对一个对象拷贝的定制。

参考博文

建议 39： 使用 Counter 进行计数统计

（需要计数统计时，使用Counter）
常见的计数统计可以使用dict、defaultdict、set和list，不过 Python 提供了一个更优雅的方式：

>>> from collections import Counter
>>> some_data = {'a', '2', 2, 3, 5, 'c', '7', 4, 5, 'd', 'b'}
>>> Counter(some_data)
Counter({'7'，: 1, 2: 1, 3: 1, 4: 1, 5: 1, '2': 1, 'b': 1, 'a': 1, 'd': 1, 'c': 1})

Counter 类属于字典类的子类，是一个容器对象，用来统计散列对象，支持+、-、&、|，其中&和|分别返回两个 Counter 对象各元素的最小值和最大值。

# 初始化
Counter('success')
Counter(s=3, c=2, e=1, u=1)
Counter({'s': 3, 'c': 2, 'u': 1, 'e': 1})
# 常用方法
list(Counter(some_data).elements())     # 获取 key 值
Counter(some_data).most_common(2)       # 前 N 个出现频率最高的元素以及对应的次数
(Counter(some_data))['y']               # 访问不存在的元素返回 0
c = Counter('success')
c.update('successfully')                # 更新统计值
c.subtract('successfully')              # 统计数相减，允许为0或为负

建议 40：深入掌握 ConfigParser

（啥程序都需要配置，要搞懂配置库）
几乎所有的应用程序都会读取配置文件，ini是一种比较常见的文件格式：

[section1]
option1=0

Python 提供标准库 ConfigParser 来支持它：

import ConfigParser
conf = ConfigParser.ConfigParser()
conf.read('example.conf')
print(conf.get('section1', 'in_default'))

再来看个SQLAlchemy配置文件的例子：

[DEFAULT]
conn_str = %(dbn)s://%(user)s:%(pw)s@%(host)s:%(port)s/%(db)s
dbn = mysql
user = root
host = localhost
port = 3306
[db1]
user = aaa
pw = ppp
db = example
[db2]
host = 192.168.0.110
pw = www
db = example

import ConfigParser
conf = ConfigParser.ConfigParser()
conf.read('format.conf')
print(conf.get('db1', 'conn_str'))
print(conf.get('db2', 'conn_str'))

建议 41：使用argparse处理命令行参数

处理命令行参数可以使用argsparse，也推荐更方便更高级的docopt进行处理
docopt是根据常见的帮助信息定义了一套领域特定语言（DSL），并通过这个DSL Parser参数生成处理命令行参数的代码。

建议 42：使用pandas处理大型CSV文件

pandas作为python三大科学运算库之一的使用。

建议 43：一般情况下使用ElementTree解析xml格式文件

使用Beautifulsoup更好

建议 44：理解模块pickle优劣

序列化，简单来说就是把内存中的数据结构在不丢失其身份和类型信息的情况下转成对象的文本或二进制表示的过程。同类支持序列化的模块有pickle，json，marshal和shelve。

pickle是最通用的序列化模块，我们应该优先使用c语言实现的cPickle，速度比pickle快1000倍，区别是cPickle不能被继承。

pickle主要通过dump和load两种方法序列化与反序列化（存储与读取）

import cPickle as pickle
# 序列化
my_data= {"name":"Python","type":"Language"}
fp = open("picklefile.dat","wb")
pickle.dump(my_data, fp)
fp.close
# 反序列化
fp = open("picklefile.dat", "rb")
out = pickle.load(fp)

pickle模块的优点：
1. 接口简单，容易使用
2. 存储格式有平台通用型，在Linux和Windouws都可以使用，兼容性好。
3. 支持数据类型广泛，除了常规项，还包含能通过类的__dict__或__getstate__()方法返回的对象。
4. pickle是可扩展的，对于不可序列化的对象，也可以通过特殊方法来返回示例在被pickle时的状态。
5. 能够自动维护对象间的引用

pickle模块的限制：
* pickle不能保证操作的原子性。当错误发生时，可能部分数据已经被保存；如果对象处于深递归状态，那么可能超过python的最大递归深度，可以通过sys.setrecursionlimit()进行扩展
* pickle存在安全性问题，为乳清提供了可能
* pickle协议是python特定的，不同语言之间数据内容可能难以保障。

简单来说，对于需要存储的对象，使用pickle，另外很重要的一点，dat文件用pickle模块来读。

建议 45：序列化的另一个不错的选择 -- JSON

cJson比python自身的json要快250倍
JSON的优势：
1. 使用简单，支持多种数据类型（集合、列表、字典、关联数组等等）
2. 存储格式可读性更友好，易于修改
3. 支持跨平台跨语言操作，所占空间更小
4. 具有较强扩展性

json的速度比pickle略慢
json不支持序列化dateime

建议 46：使用 traceback 获取栈信息

当发生异常，开发人员往往需要看到现场信息，trackback 模块可以满足这个需求，先列几个常用的：

traceback.print_exc()   # 打印错误类型、值和具体的trace信息
traceback.print_exception(type, value, traceback[, limit[, file]])  # 前三个参数的值可以从sys.exc_info()
raceback.print_exc([limit[, file]])         # 同上，不需要传入那么多参数
traceback.format_exc([limit])               # 同 print_exc()，返回的是字符串
traceback.extract_stack([file, [, limit]])  # 从当前栈中提取 trace 信息

traceback 模块获取异常相关的数据是通过sys.exc_info()得到的，该函数返回异常类型type、异常value、调用和堆栈信息traceback组成的元组。

同时 inspect 模块也提供了获取 traceback 对象的接口。

建议 47：使用 logging 记录日志信息

仅仅将信息输出到控制台是远远不够的，更为常见的是使用日志保存程序运行过程中的相关信息，如运行时间、描述信息以及错误或者异常发生时候的特定上下文信息。Python 提供 logging 模块提供了日志功能。

常规日志设置:

logging.basicConfig(
            filename='%s.log' % self.table_name,
            level=logging.DEBUG,
            format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
            datefmt='%a, %d %b %Y %H:%M:%S')

logging是线程安全的，不支持多进程写入同一个子文件，对多个进程需要配置不同的日志文件。

建议 48：使用 threading 模块编写多线程程序

（python3中，使用threadpool线程池模块比较省心）
由于 GIL 的存在，让 Python 多线程编程在多核处理器中无法发挥优势，但在一些使用场景下使用多线程仍然比较好，如等待外部资源返回，或建立反应灵活的用户界面，或多用户程序等。

Python3 提供了两个模块：_thread和threading。_thread提供了底层的多线程支持，使用比较复杂，下面我们重点说说threading。

Python 多线程支持用两种方式来创建线程：一种通过继承 Thread 类，重写它的run()方法；另一种是创建一个 threading.Thread 对象，在它的初始化函数init()中将可调用对象作为参数传入。

threading模块中不仅有 Lock 指令锁，RLock 可重入指令锁，还支持条件变量 Condition、信号量 Semaphore、BoundedSemaphore 以及 Event 事件等。

下面有一个比较经典的例子来理解多线程：

import threading
from time import ctime,sleep
def music(func):
    for i in range(2):
        print("I was listening to %s. %s" % (func,ctime()))
        sleep(1)    # 程序休眠 1 秒
def move(func):
    for i in range(2):
        print("I was at the %s! %s" % (func,ctime()))
        sleep(5)
threads = []
t1 = threading.Thread(target=music,args=('爱情买卖',))
threads.append(t1)
t2 = threading.Thread(target=move,args=('阿凡达',))
threads.append(t2)
if __name__ == '__main__':
    for t in threads:
        t.setDaemon(True)   # 声明线程为守护线程
        t.start()
    #3
    print("all over %s" % ctime())

以下是运行结果：

I was listening to 爱情买卖. Tue Apr  4 17:57:02 2017
I was at the 阿凡达! Tue Apr  4 17:57:02 2017
all over Tue Apr  4 17:57:02 2017

分析：threading 模块支持线程守护，我们可以通过setDaemon()来设置线程的daemon属性，当其属性为True时，表明主线程的退出可以不用等待子线程完成，反之，daemon属性为False时所有的非守护线程结束后主线程才会结束，那运行结果为：

I was listening to 爱情买卖. Tue Apr  4 18:05:26 2017
I was at the 阿凡达! Tue Apr  4 18:05:26 2017
all over Tue Apr  4 18:05:26 2017
I was listening to 爱情买卖. Tue Apr  4 18:05:27 2017
I was at the 阿凡达! Tue Apr  4 18:05:31 2017

继续修改代码，当我们在#3处加入t.join()，此方法能够阻塞当前上下文环境，直到调用该方法的线程终止或到达指定的 timeout，此时在运行程序：

I was listening to 爱情买卖. Tue Apr  4 18:08:15 2017
I was at the 阿凡达! Tue Apr  4 18:08:15 2017
I was listening to 爱情买卖. Tue Apr  4 18:08:16 2017
I was at the 阿凡达! Tue Apr  4 18:08:20 2017
all over Tue Apr  4 18:08:25 2017

当我们把music函数的休眠时间改为 4 秒，再次运行程序：

I was listening to 爱情买卖. Tue Apr  4 18:11:16 2017
I was at the 阿凡达! Tue Apr  4 18:11:16 2017
I was listening to 爱情买卖. Tue Apr  4 18:11:20 2017
I was at the 阿凡达! Tue Apr  4 18:11:21 2017
all over Tue Apr  4 18:11:26 2017

此时我们就可以发现多线程的威力了，music虽然增加了 3 秒，然而总的运行时间仍然为 10 秒。

建议 49：使用 Queue 使多线程编程更加安全

（同47，使用threadingpool）
线程间的同步和互斥，线程间数据的共享等这些都是涉及线程安全要考虑的问题。纵然 Python 中提供了众多的同步和互斥机制，如 mutex、condition、event 等，但同步和互斥本身就不是一个容易的话题，稍有不慎就会陷入死锁状态或者威胁线程安全。

如何保证线程安全呢？我们先来看看 Python 中的 Queue 模块：

• Queue.Queue(maxsize)：先进先出，maxsize 为队列大小，其值为非正数的时候为无限循环队列

• Queue.LifoQueue(maxsize)：后进先出，相当于栈

• Queue.PriorityQueue(maxsize)：优先级队列

以上队列所支持的方法：

• Queue.qsize()：返回近似的队列大小。当该值 > 0 的时候并不保证并发执行的时候 get() 方法不被阻塞，同样，对于 put() 方法有效。

• Queue.empty()：队列为空的时候返回 True，否则返回 False

• Queue.full()：当设定了队列大小的情况下，如果队列满则返回 True，否则返回 False

• Queue.put(item[, block[, timeout]])：往队列中添加元素 item，block 设置为 False 的时候，如果队列满则抛出 Full 异常。如果 block 设置为 True，timeout 为 None 的时候则会一直等待直到有空位置，否则会根据 timeout 的设定超时后抛出 Full 异常

• Queue.put_nowait(item)：等于 put(item, False).block 设置为 False 的时候，如果队列空则抛出 Empty 异常。如果 block 设置为 True、timeout 为 None 的时候则会一直等到有元素可用，否则会根据 timeout 的设定超时后抛出 Empty 异常

• Queue.get([block[, timeout]])：从队列中删除元素并返回该元素的值

• Queue.get_nowait()：等价于 get(False)

• Queue.task_done()：发送信号表明入列任务已经完成，经常在消费者线程中用到

• Queue.join()：阻塞直至队列中所有的元素处理完毕

首先 Queue 中的队列和 collections.deque 所表示的队列并不一样，前者用于不同线程之间的通信，内部实现了线程的锁机制，后者是数据结构上的概念，支持 in 方法。

Queue 模块实现了多个生产者多个消费者的队列，当多线程之间需要信息安全的交换的时候特别有用，因此这个模块实现了所需要的锁原语，为 Python 多线程编程提供了有力的支持，它是线程安全的。

先来看一个简单的例子：

import os
import Queue
import threading
import urllib2
class DownloadThread(threading.Thead):
    def __init__(self, queue):
        threading.Thread.__init__(self)
        self.queue = queue
    def run(self):
        while True:
            url = self.queue.get()
            print('{0} begin download {1}...'.format(self.name, url))
            self.download_file(url)
            self.queque.task_done()
            print('{0} download completed!!!'.format(self.name))
    def download_file(self, url):
        urlhandler = urllib2.urlopen(url)
        fname = os.path.basename(url) + '.html'
        with open(fname, 'wb') as f:
            while True:
                chunk = urlhandler.read(1024)
                if not chunk: break
                f.write(chunk)
if __name__ == '__main__':
    urls = ['http://wiki.python.org/moin/WebProgramming',
            'https://www.createspace.com/3611970',
            'http://wiki.python.org/moin/Documentation'
    ]
    queue = Queue.Queue()
    for i range(5):
        t = DownloadThread(queue)
        t.setDaemon(True)
        t.start()
    for url in urls:
        queue.put(url)
    queue.join()

第 5 章 设计模式

建议 50：利用模块实现单例模式

单例模式可以保证徐彤中一个类只有一个实例且该实例易被外界访问，常用来使用XxxManager之类的功能。

满足单例模式的 3 个需求：

• 只能有一个实例
• 必须自行创建这个实例
• 必须自行向整个系统提供这个实例

模块采用的其实是天然的单例的实现方式，在入口文件导入：
* 所有的变量都会绑定到模块
* 模块只初始化一次
* import 机制是线程安全的，保证了在并发状态下模块也只是一个实例

# World.py
import Sun
def run():
    while True:
        Sun.rise()
        Sun.set()
# main.py
import World
World.run()

此外，Borg模式可以创造任意数量实例，并保证状态共享。

建议 51：用 mixin 模式让程序更加灵活

模板方法模式就是在一个方法中定义一个算法的骨架，并将一些实现步骤延迟到子类中。模板方法可以使子类在不改变算法结构的情况下，重新定义算法中的某些步骤。

class UseSimpleTeapot(object):
    def get_teapot(self):
        return SimpleTeapot()
class UseKungfuTeapot(object):
    def get_teapot(self):
        return KungfuTeapot()
class OfficePeople(People, UseSimpleTeapot): pass
class HomePeople(People, UseSimpleTeapot): pass
class Boss(People, UseKungfuTeapot): pass
def simple_tea_people():
    people = People()
    people.__base__ += (UseSimpleTeapot,)
    return people
def coffee_people():
    people = People()
    people.__base__ += (UseCoffeepot,)
def tea_and_coffee_people():
    people = People()
    people.__base__ += (UseSimpleTeapot, UserCoffeepot,)
    return people
def boss():
    people = People()
    people.__base__ += (KungfuTeapot, UseCoffeepot, )
    return people

代码的原理在于每个类都有一个bases属性，它是一个元组，用来存放所有的基类，作为动态语言，Python 中的基类可以在运行中可以动态改变。所以当我们向其中增加新的基类时，这个类就拥有了新的方法，这就是混入mixin。

利用这个技术我们可以在不修改代码的情况下就可以完成需求：

import mixins   # 把员工需求定义在 Mixin 中放在 mixins 模块
def staff():
    people = People()
    bases = []
    for i in config.checked():
        bases.append(getattr(maxins, i))
    people.__base__ += tuple(bases)
    return people

建议 52：用发布订阅模式实现松耦合

发布订阅模式是一种编程模式，消息的发送者不会发送其消息给特定的接收者，而是将发布的消息分为不同的类别直接发布，并不关注订阅者是谁。而订阅者可以对一个或多个类别感兴趣，且只接收感兴趣的消息，并且不关注是哪个发布者发布的消息。要实现这个模式，就需要一个中间代理人. Broker，它维护着发布者和订阅者的关系，订阅者把感兴趣的主题告诉它，而发布者的信息也通过它路由到各个订阅者处。

from collections import defaultdict
route_table = defaultdict(list)
def sub(topic, callback):
    if callback in route_table[topic]:
        return
    route_table[topic].append(callback)
def pub(topic, *args, **kw):
    for func in route_table[topic]:
        func(*args, **kw)

将以上代码放在 Broker.py 的模块，省去了各种参数检测、优先处理、取消订阅的需求，只向我们展示发布订阅模式的基础实现：

import Broker
def greeting(name):
    print('Hello, {}'.format(name))
Broker.sub('greet', greeting)
Broker.pub('greet', 'LaiYonghao')

因为python-message的消息订阅默认是全局性的，所以有可能产生名字冲突。

建议 53：用状态模式美化代码

所谓状态模式，就是当一个对象的内在状态改变时允许改变其行为，但这个对象看起来像是改变了其类。

简单的状态模式有其缺点：

• 查询对象的当前状态很麻烦
• 状态切换时需要对原状态做一些清扫工作，而对新状态做初始化工作，因每个状态需要做的事情不同，全部写在切换状态的代码中必然重复

这时候我们可以使用 Python-state 来解决。

from state import curr, switch, stateful, State, behavior
@stateful
class People(object):
    class Workday(State):
        default = True
        @behavior   # 相当于staticmethod
        def day(self):  # 这里的self并不是Python的关键字，而是有助于我们理解状态类的宿主是People的实例
            print('work hard')
    class Weekend(State):
        @behavior
        def day(self):
            print('play harder')
people = People()
while True:
    for i in range(1, 8):
        if i == 6:
            switch(people, People.Weekend)
        if i == 1:
            switch(people, People.Workday)
        people.day()

@statefule装饰器重载了被修饰的类的getattr()从而使得 People 的实例能够调用当前状态类的方法，同时被修饰的类的实例是带有状态的，能够使用curr()查询当前状态，也可以使用switch()进行状态切换，默认的状态是通过类定义的 default 属性标识，default = True的类成为默认状态。

状态类 Workday 和 Weekend 继承自 State 类，从其派生的子类可以使用begin和end_状态转换协议，自定义进入和离开当前状态时对宿主的初始化和清理工作。

下面是一个真实业务的例子：

@stateful
class User(object):
    class NeedSignin(State):
        default = True
        @behavior
        def signin(self, user, pwd):
            ...
            switch(self, Player.Signin)
    class Signin(State):
        @behavior
        def move(self, dst): ...
        @behavior
        def atk(self, other): ...

第 6 章 内部机制

建议 54：理解 built-in objects

Python 中一切皆对象，在新式类中，object 是所有内建类型的基类，用户自定义的类可以继承自 object 也可继承自内建类型。

In [1]: class TestNewClass:
   ...:     __metaclass__ = type
   ...:     
In [2]: type(TestNewClass)
Out[2]: type
In [3]: TestNewClass.__bases__
Out[3]: (object,)
In [4]: a = TestNewClass()
In [5]: type(a)
Out[5]: __main__.TestNewClass
In [6]: a.__class__
Out[6]: __main__.TestNewClass

新式类支持 property 和描述符特性，作为新式类的祖先，Object 类还定义了一些特殊方法：new()、init()、delattr()、getattribute()、setattr()、hash()、repr()、str()等。

建议 55：init()不是构造方法

class A(object):
    def __new__(cls, *args, **kw):
        print(cls)
        print(args)
        print(kw)
        print('----------')
        instance = object.__new__(cls, *args, **kw)
        print(instance)
    def __init__(self, a, b):
        print('init gets called')
        print('self is {}'.format(self))
        self.a, self.b = a, b
a1 = A(1, 2)
print(a1.a)
print(a1.b)

运行结果：

<class '__main__.A'>
(1, 2)
{}
----------
Traceback (most recent call last):
  File "test.py", line 19, in <module>
    a1 = A(1, 2)
  File "test.py", line 13, in __new__
    instance = object.__new__(cls, *args, **kw)
TypeError: object() takes no parameters

从结果中我们可以看出，程序输出了new()调用所产生的输出，并抛出了异常。于是我们知道，原来new()才是真正创建实例，是类的构造方法，而init()是在类的对象创建好之后进行变量的初始化。上面程序抛出异常是因为在new()中没有显式返回对象，a1此时为None，当去访问实例属性时就抛出了异常。

根据官方文档，我们可以总结以下几点：

• object.new(cls[, args...])：其中 cls 代表类，args 为参数列表，为静态方法

• object.init(self[, args...])：其中 self 代表实例对象，args 为参数列表，为实例方法

• 控制实例创建的时候可使用 new() ，而控制实例初始化的时候使用 init()

• new()需要返回类的对象，当返回类的对象时将会自动调用init()进行初始化，没有对象返回，则init()不会被调用。init() 方法不需要显示返回，默认为 None，否则会在运行时抛出 TypeError

• 但当子类继承自不可变类型，如 str、int、unicode 或者 tuple 的时候，往往需要覆盖new()

• 覆盖 new() 和 init() 的时候这两个方法的参数必须保持一致，如果不一致将导致异常

下面我们来总结需要覆盖new()的几种特殊情况：

• 当类继承不可变类型且默认的 new() 方法不能满足需求的时候

• 用来实现工厂模式或者单例模式或者进行元类编程，使用new()来控制对象创建

• 作为用来初始化的 init() 方法在多继承的情况下，子类的 init()方法如果不显式调用父类的 init() 方法，则父类的 init() 方法不会被调用；通过super(子类， self).init()显式调用父类的初始化方法；对于多继承的情况，我们可以通过迭代子类的 bases 属性中的内容来逐一调用父类的初始化方法

分别来看例子加深理解：

# 创建一个集合能够将任何以空格隔开的字符串变为集合中的元素
class UserSet(frozenset):
    def __new__(cls, *args):
        if args and isinstance(args[0], str):
            args = (args[0].split(), ) + args[1:]
        return super(UserSet, cls).__new__(cls, *args)
# 一个工厂类根据传入的参量决定创建出哪一种产品类的实例
class Shape(object):
    def __init__(object):
        pass
    def draw(self):
        pass
class Triangle(Shape):
    def __init__(self):
        print("I am a triangle")
    def draw(self):
        print("I am drawing triangle")
class Rectangle(Shape):
    def __init__(self):
        print("I am a rectangle")
    def draw(self):
        print("I am drawing triangle")
class Trapezoid(Shape):
    def __init__(self):
        print("I am a trapezoid")
    def draw(self):
        print("I am drawing triangle")
class Diamond(Shape):
    def __init__(self):
        print("I am a diamond")
    def draw(self):
        print("I am drawing triangle")
class ShapeFactory(object):
    shapes = {'triangle': Triangle, 'rectangle': Rectangle, 'trapzoid': Trapezoid, 'diamond': Diamond}
    def __new__(cls, name):
        if name in ShapeFactory.shapes.keys():
            print('creating a new shape {}'.format(name))
            return ShapeFactory.shapes[name]()
        else:
            print('creating a new shape {}'.format(name))
            return Shape()

建议 56：理解名字查找机制

在 Python 中所谓的变量其实都是名字，这些名字指向一个或多个 Python 对象。这些名字都存在于一个表中（命名空间），我们称之为局部变量，调用locals()可以查看：

>>> locals()
{'__package__': None, '__spec__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__doc__': None, '__name__': '__main__', '__builtins__': <module 'builtins' (built-in)>}
>>> globals()
{'__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__builtins__': <module 'builtins' (built-in)>, '__package__': None, '__doc__': None, '__spec__': None, '__name__': '__main__'}

Python 中的作用域分为：

• 局部作用域: 一般来说函数的每次调用都会创建一个新的本地作用域, 拥有新的命名空间

• 全局作用域: 定义在 Python 模块文件中的变量名拥有全局作用域, 即在一个文件的顶层的变量名仅在这个文件内可见

• 嵌套作用域: 多重函数嵌套时才会考虑, 即使使用 global 进行申明也不能达到目的, 其结果最终是在嵌套的函数所在的命名空间中创建了一个新的变量

• 内置作用域: 通过标准库中的builtin实现的

当访问一个变量的时候，其查找顺序遵循变量解析机制 LEGB 法则，即依次搜索 4 个作用域：局部作用域、嵌套作用域、全局作用域以及内置作用域，并在第一个找到的地方停止搜寻，如果没有搜到，则会抛出异常。

Python 3 中引入了 nonlocal 关键字:

def foo(x):
    a = x
    def bar():
        nonlocal a
        b = a * 2
        a = b + 1
        print(a)
    return bar

建议 57: 为什么需要 self 参数

在类中当定义实例方法的时候需要将第一个参数显式声明为self, 而调用时不需要传入该参数, 我们通过self.x访问实例变量, self.m()访问实例方法:

class SelfTest(object):
    def __init__(self.name):
        self.name = name
    def showself(self):
        print('self here is {}'.format(self))
    def display(self):
        self.showself()
        print('The name is: {}'.format(self.name))
st = SelfTest('instance self')
st.display()
print('{}'.format(st))

运行结果:

self here is <__main__.SelfTest object at 0x7f440c53ba58>
The name is: instance self
<__main__.SelfTest object at 0x7f440c53ba58>

从中可以发现, self 表示实例对象本身, 即 SelfTest 类的对象在内存中的地址. self 是对对象 st 本身的引用, 我们在调用实例方法时也可以直接传入实例对象: SelfTest.display(st). 同时 self 或 cls 并不是 Python 的关键字, 可以替换成其它的名称.

Python 中为什么需要 self 呢:

1. 借鉴了其他语言的特征

2. Python 语言本身的动态性决定了使用 self 能够带来一定便利

3. 在存在同名的局部变量以及实例变量的情况下使用 self 使得实例变量更容易被区分

Python 属于一级对象语言, 我们有好几种方法可以引用类方法:

A.__dict__["m"]
A.m.__func__

Python 的哲学是：显示优于隐式（Explicit is better than implicit）.

建议 58: 理解 MRO 与多继承

古典类与新式类所采取的 MRO (Method Resolution Order, 方法解析顺序) 的实现方式存在差异.

古典类是按照多继承申明的顺序形成继承树结构, 自顶向下采用深度优先的搜索顺序. 而新式类采用的是 C3 MRO 搜索方法, 在新式类通过mro得到 MRO 的搜索顺序, C3 MRO 的算法描述如下:

假定，C1C2...CN 表示类 C1 到 CN 的序列，其中序列头部元素（head）=C1，序列尾部（tail）定义 = C2...CN；

C 继承的基类自左向右分别表示为 B1，B2...BN

L[C] 表示 C 的线性继承关系，其中 L[object] = object。

算法具体过程如下：

L[C(B1...BN)] = C + merge(L[B1] ... L[BN], B1 ... BN)

其中 merge 方法的计算规则如下：在 L[B1]...L[BN]，B1...BN 中，取 L[B1] 的 head，如果该元素不在 L[B2]...L[BN]，B1...BN 的尾部序列中，则添加该元素到 C 的线性继承序列中，同时将该元素从所有列表中删除（该头元素也叫 good head），否则取 L[B2] 的 head。继续相同的判断，直到整个列表为空或者没有办法找到任何符合要求的头元素（此时，将引发一个异常）。

菱形继承是我们在多继承设计的时候需要尽量避免的一个问题.

建议 59: 理解描述符机制

In [1]: class MyClass(object):
   ...:     class_attr = 1
   ...:     
# 每一个类都有一个__dict__属性, 包含它的所有属性
In [2]: MyClass.__dict__
Out[2]:
mappingproxy({'__dict__': <attribute '__dict__' of 'MyClass' objects>,
              '__doc__': None,
              '__module__': '__main__',
              '__weakref__': <attribute '__weakref__' of 'MyClass' objects>,
              'class_attr': 1})
In [3]: my_instance = MyClass()
# 每一个实例也相应有一个实例属性, 我们通过实例访问一个属性时,
# 它首先会尝试在实例属性中查找, 找不到会到类属性中查找
In [4]: my_instance.__dict__
Out[4]: {}
# 实例访问类属性
In [5]: my_instance.class_attr
Out[5]: 1
# 如果通过实例增加一个属性,只能改变此实例的属性
In [6]: my_instance.inst_attr = 'china'
In [7]: my_instance.__dict__
Out[7]: {'inst_attr': 'china'}
# 对于类属性而言并没有丝毫变化
In [8]: MyClass.__dict__
Out[8]:
mappingproxy({'__dict__': <attribute '__dict__' of 'MyClass' objects>,
              '__doc__': None,
              '__module__': '__main__',
              '__weakref__': <attribute '__weakref__' of 'MyClass' objects>,
              'class_attr': 1})
# 我们可以动态地给类增加一个属性
In [9]: MyClass.class_attr2 = 100
In [10]: my_instance.class_attr2
Out[10]: 100
# 但Python的内置类型并不能随意地为它增加属性或方法

.操作符封装了对实例属性和类属性两种不同属性进行查找的细节。

但是如果是访问方法呢:

In [1]: class MyClass(object):
   ...:     def my_method(self):
   ...:         print('my_method')
   ...:         
In [2]: MyClass.__dict__['my_method']
Out[2]: <function __main__.MyClass.my_method>
In [3]: MyClass.my_method
Out[3]: <function __main__.MyClass.my_method>
In [4]: type(MyClass.my_method)
Out[4]: function
In [5]: type(MyClass.__dict__['my_method'])
Out[5]: function

根据通过实例访问属性和根据类访问属性的不同，有以下两种情况：

• 一种是通过实例访问，比如代码 obj.x，如果 x 是一个描述符，那么 getattribute() 会返回 type(obj).dict['x'].get(obj, type(obj)) 结果，即：type(obj) 获取 obj 的类型；type(obj).dict['x'] 返回的是一个描述符，这里有一个试探和判断的过程；最后调用这个描述符的 get() 方法。

• 另一个是通过类访问的情况，比如代码 cls.x，则会被 getattribute()转换为 cls.dict['x'].get(None, cls)。

  描述符协议是一个 Duck Typing 的协议，而每一个函数都有 get 方法，也就是说其他每一个函数都是描述符。所有对属性, 方法进行修饰的方案往往都用到了描述符, 如classmethod, staticmethod, property等, 以下是property的参考实现:

  class Property(object):
      "Emulate PyProperty_Type() in Objects/descrobject.c"
      def __init__(self, fget=None, fset=None, fdel=None, doc=None):
          self.fget = fget
          self.fset = fset
          self.fdel = fdel
          self.__doc__ = doc
      def __get__(self, obj, objtype=None):
          if obj is None:
              return self
          if self.fget is None:
              raise AttributeError, "unreadable attribute"
          return self.fget(obj)
      def __set__(self, obj, value):
          if self.fset is None:
              raise AttributeError, "can't set attribute"
          self.fset(obj, value)
      def __delete__(self, obj):
          if self.fdel is None:
              raise AttributeError, "can't delete attribute"
          self.fdel(obj)

建议 60：区别getattr()和getattribute()方法

以上两种方法可以对实例属性进行获取和拦截：

• getattr(self, name)：适用于属性在实例中以及对应的类的基类以及祖先类中都不存在；

• getattribute(self, name)：对于所有属性的访问都会调用该方法

但访问不存在的实例属性时，会由内部方法getattribute()抛出一个 AttributeError 异常，也就是说只要涉及实例属性的访问就会调用该方法，它要么返回实际的值，要么抛出异常。详情请参考。

那么getattr()在什么时候调用呢：

• 属性不在实例的dict中；

• 属性不在其基类以及祖先类的dict中；

• 触发AttributeError异常时（注意，不仅仅是getattribute()方法的AttributeError异常，property 中定义的get()方法抛出异常的时候也会调用该方法）。

当这两个方法同时被定义的时候，要么在getattribute()中显式调用，要么触发AttributeError异常，否则getattr()永远不会被调用。

我们知道 property 也能控制属性的访问，如果一个类中如果定义了 property、getattribute()以及getattr()来对属性进行访问控制，会最先搜索getattribute()方法，由于 property 对象并不存在于 dict 中，因此并不能返回该方法，此时会搜索 property 中的get()方法；当 property 中的set()方法对属性进行修改并再次访问 property 的get()方法会抛出异常，这时会触发getattr()的调用。

getattribute()总会被调用，而getattr()只有在getattribute()中引发异常的情况下调用。

第 6 章 内部机制

建议 61：使用更加安全的 property

property 实际上是一种实现了 get() 、 set() 方法的类，用户也可以根据自己的需要定义个性化的 property，其实质是一种特殊的数据描述符（数据描述符：如果一个对象同时定义了 get() 和 set() 方法，则称为数据描述符，如果仅定义了get() 方法，则称为非数据描述符）。它和普通描述符的区别在于：普通描述符提供的是一种较为低级的控制属性访问的机制，而 property 是它的高级应用，它以标准库的形式提供描述符的实现，其签名形式为：

property(fget=None, fset=None, fdel=None, doc=None) -> property attribute

property 有两种常用的形式：

1、第一种形式

class Some_Class(object):
    def __init__(self):
        self._somevalue = 0
    def get_value(self):
        print('calling get method to return value')
        return self._somevalue
    def set_value(self, value):
        print('calling set method to set value')
        self._somevalue = value
    def def_attr(self):
        print('calling delete method to delete value')
        def self._somevalue
    x = property(get_value, set_value, del_attr, "I'm the 'x' property.")
obj = Some_Class()
obj.x = 10
print(obj.x + 2)
del obj.x
obj.x

2、第二种形式

class Some_Class(self):
    _x = None
    def __init__(self):
        self._x = None
    @property
    def x(self):
        print('calling get method to return value')
        return self._x
    @x.setter
    def x(self, value):
        print('calling set method to set value')
        self._x = value
    @x.deleter
    def x(self):
        print('calling delete method to delete value')
        del self._x

以上我们可以总结出 property 的优势：

1、代码更简洁，可读性更强

2、更好的管理属性的访问。property 将对属性的访问直接转换为对对应的 get、set 等相关函数的调用，属性能够更好地被控制和管理，常见的应用场景如设置校验（如检查电子邮件地址是否合法）、检查赋值的范围（某个变量的赋值范围必须在 0 到 10 之间）以及对某个属性进行二次计算之后再返回给用户（将 RGB 形式表示的颜色转换为#**）或者计算某个依赖于其他属性的属性。

class Date(object):
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day
    def get_date(self):
        return self.year + '-' + self.month + '-' + self.day
    def set_date(self, date_as_string):
        year, month, day = date_as_string.split('-')
        if not (2000 <= year <= 2017 and 0 <= month <= 12 and 0 <= day <= 31):
            print('year should be in [2000:2017]')
            print('month should be in [0:12]')
            print('day should be in [0, 31]')
            raise AssertionError
        self.year = year
        self.month = month
        self.day = day
    date = property(get_date, set_date)

创建一个 property 实际上就是将其属性的访问与特定的函数关联起来，相对于标准属性的访问，property 的作用相当于一个分发器，对某个属性的访问并不直接操作具体的对象，而对标准属性的访问没有中间这一层，直接访问存储属性的对象：

3、代码可维护性更好。property 对属性进行再包装，以类似于接口的形式呈现给用户，以统一的语法来访问属性，当具体实现需要改变的时候，访问的方式仍然可以保持一致。

4、控制属性访问权限，提高数据安全性。如果用户想设置某个属性为只读，来看看 property 是如何实现的。

class PropertyTest(object):
    def __init__(self):
        self.__var1 = 20
    @property
    def x(self):
        return self.__var1
pt = PropertyTest()
print(pt.x)
pt.x = 12

注意这样使用 property 并不能真正意义达到属性只读的目的，正如以双下划线命令的变量并不是真正的私有变量一样，我们还是可以通过pt._PropertyTest__var1 = 30来修改属性。稍后我们会讨论如何实现真正意义上的只读和私有变量。

既然 property 本质是特殊类，那么就可以被继承，我们就可以自定义 property：

def update_meta(self, other):
    self.__name__ = other.__name__
    self.__doc__ = other.__doc__
    self.__dict__.update(other.__dict__)
    return self
class UserProperty(property):
    def __new__(cls, fget=None, fset=None, fdel=None, doc=None):
        if fget is not None:
            def __get__(obj, objtype=None, name=fget.__name__):
                fegt = getattr(obj, name)
                return fget()
            fget = update_meta(__get__, fget)
        if fset is not None:
            def __set__(obj, value, name=fset.__name__):
                fset = getattr(obj, name)
                return fset(value)
            fset = update_meta(__set__, fset)
        if fdel is not None:
            def __delete__(obj, name=fdel.__name__):
                fdel = getattr(obj, name)
                return fdel()
            fdel = update_meta(__delete__, fdel)
        return property(fget, fset, fdel, doc)
class C(object):
    def get(self):
        return self._x
    def set(self, x):
        self._x = x
    def delete(self):
        del self._x
    x = UserProperty(get, set, delete)
c = C()
c.x = 1
print(c.x)
def c.x

UserProperty 继承自 property，其构造函数 new(cls, fget=None, fset=None, fdel=None, doc=None) 中重新定义了 fget() 、 fset() 以及 fdel() 方法以满足用户特定的需要，最后返回的对象实际还是 property 的实例，因此用户能够像使用 property 一样使用 UserProperty。

使用 property 并不能真正完全达到属性只读的目的，用户仍然可以绕过阻碍来修改变量。我们来看看一个可行的实现：

def ro_property(obj, name, value):
    setattr(obj.__class__, name, property(lambda obj: obj.__dict__["__" + name]))
    setattr(obj, "__" + name, value)
class ROClass(object):
    def __init__(self, name, available):
        ro_property(self, "name", name)
        self.available = available
a = ROClass("read only", True)
print(a.name)
a._Article__name = "modify"
print(a.__dict__)
print(ROClass.__dict__)
print(a.name)