Python 与 Django 开发实践

整理自「开发 Tips」系列，汇总 Python 与 Django 开发中的常见问题与解决方法。

1. Python 可迭代对象的排序

可迭代对象 iterable 主要包括 3 类：

全部序列类型，比如 list(列表)、str(字符串)、tuple(元组)
部分非序列类型，比如 dict(字典)、file(文件)
包含 __iter__() 或 __getitem__() 方法的对象

sort 是 list 对象的一个方法，sorted 可以对所有可迭代的对象进行排序操作。不同的是 sort 在原位重新排列列表，而 sorted() 是产生一个新的列表。有关排序的基本概念：

iterable
可迭代对象
cmp
比较函数，需要两个参数
key
比较的元素，只有一个参数
reverse
排序规则，reverse = True 降序， reverse = False 升序

1.1 sort 函数

原型：

1
list.sort(cmp=None, key=None, reverse=False)

使用实例：

1
2
3
4
my_list = ['3', '4', 'u', 9]
my_list.sort(reverse=True)
print my_list
['u', '4', '3', 9]

1
2
3
4
5
6
def takeSecond(elem):
    return elem[1]
mylist = [(2, 2), (3, 4), (42, 1), (41, 1), (1, 3)]
mylist.sort(key=takeSecond)
print mylist
[(42, 1), (41, 1), (2, 2), (1, 3), (3, 4)]

1.2 sorted 函数

原型：

1
sorted(iterable, cmp=None, key=None, reverse=False)

使用实例：

1
2
3
mylist = [5, 2, 3, 1, 4]
print sorted(mylist, reverse=True)
[5, 4, 3, 2, 1]

1
2
3
mylist = [('b', 2), ('a', 1), ('c', 3), ('d', 4)]
print sorted(mylist, cmp=lambda x, y: cmp(x[1], y[1]))
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

指定多个排序关键字，先按照 x[1]，再按照 x[0] 排序。

1
2
3
mylist = [('d', 2), ('a', 4), ('b', 3), ('c', 2)]
print sorted(mylist, key=lambda x: (x[1], x[0]))
[('c', 2), ('d', 2), ('b', 3), ('a', 4)]

2. Python 中的序列化与反序列化

序列化，将内存对象转化为可存储或传输序列的过程。反序列化，把序列化序列重新转化为内存对象的过程。Json 和 Pickle 是 Python 中常用的两个序列化处理模块。

Json VS Pickle:

Json 实现的是内存对象与 Json 字符串的转换，Pickle 实现的是内存对象与字节对象的转换
Json 格式广泛应用于除 Python 外的其他领域，Pickle 是 Python 独有的
Json 只能序列化 Python 内置的基本数据类型对象，Pickle 可以序列化一切对象，包括函数
cPickle 是 Pickle 的 C 语言实现，常用来替换 Pickle 以提升性能

使用示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
# -*- coding: utf-8 -*-
import json
import pickle


obj = {'a': 'b', 'c': 'd'}
ps = pickle.dumps(obj)
print ps
# "(dp0\nS'a'\np1\nS'b'\np2\nsS'c'\np3\nS'd'\np4\ns."
js = json.dumps(obj)
print js
# {"a": "b", "c": "d"}
print pickle.loads(ps)
# {'a': 'b', 'c': 'd'}
print json.loads(js)
# {u'a': u'b', u'c': u'd'}

除此之外，对字符串还可以进行压缩，以节省存储：

1
2
3
4
5
6
7
8
import cPickle as pickle
import zlib

# 序列化，并压缩
compressed = zlib.compress(pickle.dumps(obj))

# 解压缩，反序列化
obj = pickle.loads(zlib.decompress(compressed))

3. Python 的日志模块

Python 的 logging 模块主要由四个部分组成：

Loggers: 可供程序直接调用的接口
Handlers: 将日志记录输出至合适的位置
Filters: 提供更细粒度的日志是否输出判断
Formatters: 定制最终记录打印的布局格式

看下面这个例子，log1.py 文件

1
2
3
4
5
6
7
8
import logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

logger.info('info log')
logger.debug('debug log')
logger.warning('Warning log')

直接执行，输出：

1
2
2018-10-26 21:08:02,905 - __main__ - INFO - info log
2018-10-26 21:08:02,907 - __main__ - WARNING - Warning log

log2 文件

1
from log1 import logger

直接执行，输出：

1
2
2018-10-26 21:11:36,849 - log1 - INFO - info log
2018-10-26 21:11:36,849 - log1 - WARNING - Warning log

format 部分参数：

%(levelno)s：打印日志级别的数值
%(levelname)s：打印日志级别的名称
%(pathname)s：打印当前执行程序的路径，其实就是 sys.argv[0]
%(filename)s：打印当前执行程序名
%(funcName)s：打印日志的当前函数
%(lineno)d：打印日志的当前行号
%(asctime)s：打印日志的时间
%(thread)d：打印线程 ID
%(threadName)s：打印线程名称
%(process)d：打印进程 ID
%(processName)s：打印线程名称
%(module)s：打印模块名称
%(message)s：打印日志信息

4. Python 的调试工具

The Python Debugger 是官方调试器，内置在 Python 标准模块中。

使用方式：$python -m pdb scriptfile 或者在代码中 pdb.set_trace()

ipdb

基于 ipython 的 pdb，是一个增强版的 pdb。

使用方式：$ipdb scriptfile 或 $python –pdb scriptfile

PuDB

全屏的基于控制台的可视化调试器。

使用方式：$python -m pudb.run scriptfile 或 $pudb scriptfile

5. Django CSRF

django.middleware.csrf.CsrfViewMiddleware 处理逻辑:

进入 views 函数处理之前，如果 cookies 里面有 csrf token，则将其设置在 request.Meta 中，否则生成一个 token。如果不是 GET、HEAD 等方法则，校验 CSRF。

校验规则：从 Cookie 中取出 csrf token 与 POST 请求中的 csrfmiddlewaretoken 或者 HTTP_X_CSRFTOKEN 进行比较。如果两者相等，则通过校验，否则返回 403。

在返回响应之前，如果设置过 CSRF_COOKIE_USED，则会将 csrf token 设置到 Cookie 中。通常有两种方式设置 CSRF_COOKIE_USED：

直接使用 django.middleware.csrf.get_token 函数获取 csrf token
配置 django.template.context_processors.csrf 上下文处理器，在模板里面渲染 csrf token，实际上还是调用了 get_token 函数

下面是摘取的部分 Django 源码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class CsrfViewMiddleware(object):
    def process_view(self, request, callback, callback_args, callback_kwargs):
        try:
            csrf_token = _sanitize_token(
                request.COOKIES[settings.CSRF_COOKIE_NAME])
            request.META['CSRF_COOKIE'] = csrf_token
        except KeyError:
            request.META["CSRF_COOKIE"] = _get_new_csrf_key()
        if request.method == "POST":
                request_csrf_token = request.POST.get('csrfmiddlewaretoken', '')
            if request_csrf_token == "":
                request_csrf_token = request.META.get('HTTP_X_CSRFTOKEN', '')
            if not constant_time_compare(request_csrf_token, csrf_token):
                return self._reject(request, REASON_BAD_TOKEN)

    def process_response(self, request, response):
        if request.META.get("CSRF_COOKIE") is None:
            return response

        if not request.META.get("CSRF_COOKIE_USED", False):
            return response
        response.set_cookie(settings.CSRF_COOKIE_NAME,
                            request.META["CSRF_COOKIE"],
                            max_age=settings.CSRF_COOKIE_AGE,
                            domain=settings.CSRF_COOKIE_DOMAIN,
                            path=settings.CSRF_COOKIE_PATH,
                            secure=settings.CSRF_COOKIE_SECURE,
                            httponly=settings.CSRF_COOKIE_HTTPONLY
                            )
        return response

参数解释：

max_age: cookie的生命长度，默认为None，浏览器关闭 cookie 立即失效
expires: cookie 过期时间时间点，默认为None，浏览器关闭 cookie 立即失效
path: Cookie 生效的路径，/ 表示根路径，根路径的cookie可以被任何url的页面访问
domain: 默认值为 None，设置该 Cookie 的网页所在的域名None
secure: 用来设置 Cookie 只在确保安全的请求中才会发送。当请求是 HTTPS 或者其他安全协议时，包含 secure 选项的 Cookie 才能被保存到浏览器或者发送至服务器。
httponly: 只能 http 协议传输，无法被 JavaScript 获取（不是绝对，底层抓包可以获取到也可以被覆盖）默认值 False。

Django 中关于 CSRF 的默认配置：

1
2
3
4
5
6
7
# Settings for CSRF cookie.
CSRF_COOKIE_NAME = 'csrftoken'
CSRF_COOKIE_AGE = 60 * 60 * 24 * 7 * 52
CSRF_COOKIE_DOMAIN = None
CSRF_COOKIE_PATH = '/'
CSRF_COOKIE_SECURE = False
CSRF_COOKIE_HTTPONLY = False

6. djcelery_crontabschedule already exists 错误

使用版本：

Django==1.8.3
celery==3.1.18
django-celery==3.1.16

升级 django-celery==3.2.2 时，执行 python manage.py migrate，报错：

1
2
3
File "/app/.heroku/python/lib/python2.7/site-packages/pymysql/err.py", line 115, in _check_mysql_exception
    raise InternalError(errno, errorvalue)
django.db.utils.InternalError: (1050, u"Table 'djcelery_crontabschedule' already exists")

在 django-celery 的 GitHub 更新日志中提到：

在 3.1.17 更新版本之后，新增了 Django migrations。

如果已经存在 djcelery_* 等表，则会导致执行 $python manage.py migrate 时报错。升级依赖的版本库时，需要注意版本的兼容性。

7. Django Model 的更新信号处理

通过 created 字段，可以区分 Django Model 的新建和更新操作。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from django.db.models.signals import post_save


@receiver(post_save, sender=User)
def handle_when_user_updated(sender, instance, created, **kwargs):
    if not created:
        # User object updated
        pass
    else:
        # User object created
        pass

8. WhiteNoise 转发静态文件

Django 内置的静态文件服务器效率很低，而 WhiteNoise 是一个不错的替代品。具有如下特点：

通常用于 PaaS 服务
支持 wsgi 应用程序，针对 Django 进行了特殊适配
配合 CDN 使用，更佳
在 Gunicorn 配合下，使用 sendfile 系统调用，处理效率非常高
相比于 Nginx，WhiteNoise 提供静态文件服务的方式更加简单，但效率只有 Nginx 的 15％

9. 记录 Django 模型修改历史

django-simple-history
原理：每个需要追踪的模型都需要单独创建一张表，修改实例时，在表中直接新建一条记录。
django-reversion
原理：当模型数据发生修改时，将修改序列化到 Version 表中。仅需要一张表，就可以记录全部修改记录。

10. Python 内存分析方法

主要涉及四个工具：

memory_profile：分析每一行代码的内存使用量
objgraph：跟踪内存中的对象的关系
guppy：在运行时跟踪堆的使用情况
pyrasite：向进程中注入代码

分为两步：

模拟线上环境，使用 pyrasite 和 guppy 获取堆信息
根据上一步的信息定位到代码中的某一块，再使用 memory_profile 或 objgraph 来进行进一步的分析

11. Python 多重继承

Python 多重继承调用方法时，采用深度优先搜索算法。按顺序从一个父类一直深度搜索，然后再搜索第二个父类，一直到找到方法为止。

旧类

旧类查找顺序， C(A, B) => C -> A -> B

新类

新类有一个问题就是，任何多重继承的子类都有一个共同的祖类 Object，都是菱形继承。新类的方法是按照 Class.mro中储存的类的顺序查找的。

新类查找顺序， C(A, B) => C -> A -> B -> Object

12. pymysql 替换 MySQL-python

MySQL-python 已停止更新，只支持 Python2，不支持 Python3 ，并且依赖复杂，安装麻烦。

pymysql 为替代 MySQL-python 而生，纯 Python 编写，接口与 MySQL-python 兼容，安装方便，支持 Python3。

下面是替换方法：

1
2
3
import pymysql

pymysql.install_as_MySQLdb()

13. Python3 连接数据库

Python3 主要有两个数据库连接客户端: mysqlclient 和 PyMySQL 。

mysqlclient 是由 C 语言实现的
PyMySQL 是由 Python 实现的

在性能上， mysqlclient 比 PyMySQL 高一个数量级。但，在 PyPy 下，PyMySQL 与 mysqlclient 性能相差不大。

如果需要使用 gevent 或 eventlet 的 monkeypatched 处理 socket，那就选择 PyMySQL。

14. MySQL 报错 Table ‘performance_schema.session_variables’ doesn’t exist

执行如下命令，可解决：

1
2
3
mysql -u root -p
mysql> set @@global.show_compatibility_56=ON;
Query OK, 0 rows affected (0.00 sec)

参考链接：将show_compatibilty OFF和PFS编译出来的SHOW命令的文档行为

15. Python2 和 Python3 中的异常处理

Python2，Python3 都支持的两种方式：

带参数

1
2
except （ExceptionType） as Argument:
    # 访问 Argument

不带参数

1
except ExceptionType：

仅 Python2 支持的方式：

1
2
except ExceptionType, Argument:
    # 访问 Argument

16. Django 中的 get_object_or_404 和 get_queryset

get_object_or_404 通过使用 get 获取对象，否则返回 404

1
2
3
4
5
6
7
8
9
from django.shortcuts import get_object_or_404
from django.forms.models import model_to_dict
from django.http import JsonResponse
from .models import Fruit


def filter404(request):
    obj = get_object_or_404(Fruit, title='aa')
    return JsonResponse(model_to_dict(obj))

使用 get_queryset 可以全局的定制查询行为，包括 admin

1
2
3
class FruitManager(models.Manager):
    def get_queryset(self):
        return super(FruitManager, self).get_queryset().filter(is_delete=False)

17. 树形结构存储

物化路径

每个节点存储其完整路径编码。

1
2
3
4
5
Name        Path
William     1
Jones       1/1
Blake       1/2
Adams       1/2/1

优点是读取和写入都非常快。

邻接表模型

邻接列表表示通过保持到某些相邻节点的链接来存储树。

1
2
3
Name        Parent     Next
William     null       Joseph
Jones       William    Blake

优点是，结构简单易懂，但是数据量很大时，基于递归的查询效率非常低。

嵌套集

每个节点存储一些索引（通常是左右值）。

1
2
3
4
Name        left   right
William     1      10
Jones       2      3
Blake       4      7

优点是查询数据很快，但是更新时，需要修改的节点很大。

区间嵌套集

将区间映射为二维空间，每一个节点根据规则对应一个分数。在涉及节点位置的层次查询时，不需要访问数据库。优点是，性能非常好，但是实现和理解起来有一点门槛。

django-treebeard 实现了物化路径，嵌套集和邻接列表。 django-mptt 混合了嵌套集和邻接列表，能高效地查询子节点，被破坏时可以重建树。

18. Pytest 找不到模块报错

报错信息：

1
2
3
4
5
6
=================================== ERRORS ====================================
_____________ ERROR collecting home_application/test/test_mptt.py _____________
ImportError while importing test module 'C:\pytest\home_application\test\test_mptt.py'.
Hint: make sure your test modules/packages have valid Python names.
Traceback:
ImportError: No module named home_application.test.test_mptt

问题原因：

test 目录下，存在 __init__.py 文件，导致 Pytest 将整个 test 当作一个模块来处理。实际上，我们需要的是 Pytest 进入目录，找到 test_ 开头的文件，运行测试。只需要删除 __init__.py 文件即可。

19. Python 续行的几种方式

1，利用反斜杠

1
2
3
4
5
6
7
8
9
a = 'sdfaf' \
    'test'

a = '1' + '2' + '3' + \
    '4' + '5'

if False and \
    True:
    pass

2，利用括号

1
2
3
4
5
6
7
8
9
a = ('sdfaf'
    'test')

a = ('1' + '2' + '3' +
    '4' + '5')

if(False and
    True):
    pass

20. Python 列表、元组遍历速度差不多

在 IPython 中执行如下测试代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import timeit

a = range(9999)

def test_list():
    for i in a:
        i = i * i

timeit.timeit('test_list()', 'from __main__ import test_list', number=1000)
# 0.29664087295532227

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import timeit

a = tuple(range(9999))

def test_tuple():
    for i in a:
        i = i * i

timeit.timeit('test_tuple()', 'from __main__ import test_tuple', number=1000)
# 0.3050811290740967

从测试结果看到，list、tuple 的遍历速度差不多。但经常听到 tuple 比 list 快的言论，实际上指的是创建速度。另外，它们的查找速度也差不多。

在 CPython 中，创建 tuple 会一次性分配固定连续的内容；创建 list 会被分配两块内存，一块记录 Python Object 信息，一块用来存储数据。

21. Python 的类构造函数 type()

1
type(name, bases, dict)

参数说明:

name, 字符串，指定新类的名字, 赋给新类的 __name__
bases，一个 tuple，指定新类的基类，赋给新类的 __bases__
dict，字典类型，指定新类的属性，赋给新类的 __dict__

Python 作为一种动态语言，动态构建类能实现很多美妙特性、节省大量代码。

22. Python 中的 EAFP 原则

Easier to ask for forgiveness than permission. This common Python coding style assumes the existence of valid keys or attributes and catches exceptions if the assumption proves false. This clean and fast style is characterized by the presence of many try and except statements. The technique contrasts with the 07001 common to many other languages such as C.

举个例子：

EAFP 风格

1
2
3
4
try:
    x = my_dict["key"]
except KeyError:
    # handle missing key

LBYL 风格

1
2
3
4
if "key" in my_dict:
    x = my_dict["key"]
else:
    # handle missing key

LBYL 需要搜索字典两次，另外，可读性也没有 EAFP 好。