因为新公司要使用Flask开发，于是需要熟悉它。找到《Flask Web Developmen》这本书，于是开始学习使用Flask编写Web站点。

想到把之前用Django开发的站点，爱与生的苦恼还不够完善，于是决定用Flask重写。之所以叫爱与生的苦恼，是因为之前看过叔本华写的《爱与生的苦恼》。想想每个人很多时候都是在爱与恨中度过，就像我喜欢跑步，囚徒健身，现代牧业，旭辉控股，莱尔斯丹等等，讨厌工商银行，赌博，垄断，Windows命令行等等。于是我想把它记下来，也可以看看自己喜欢与讨厌的变化。或许随着时间的推移，自己会变得更加宽容，更加开放。也许那个时候，不在讨厌工商银行，Windows命令行也是有可能的。记微信朋友圈显得有些杂乱，于是干脆记在自己写的网站里。

《Flask Web Development》的作者Miguel Grinberg显然具有多年开发经验，将Web开发需要注意的地方，通过一个完整的博客应用娓娓道来，令人倾佩。许多代码稍作更改，就可以用在自己的站点中，大呼过瘾。如果要学习Flask开发，极力推荐看看这本书。

相比于Django, Flask显得更加轻量。没有了Django的admin，但好在应用比较简单，写个简单的后台没有什么问题。基本上Django里有的功能，Flask都能找到合适替代品。整个开发过程还是很顺畅的，唯一不好的一点是Flask的migrate功能有问题，当使用SQLite做数据库时，自动生成的SQL语句会出问题，主要是SQLite不支持Alter字段。

刚开始时，访问速度很慢，因为显示的都是原始图片，动不动就是10M，用户体验不是很好。曾考虑过使用七牛图床，只是这样增加了开发成本，而且需要把照片寄存在第三方应用中，好处是图片清晰。考虑之后，还是决定使用Pillow模块进行图片裁剪，目前来看，效果还不错。

之后添加了粉丝，评论功能这些社交元素。除了界面显示效果略差，整体效果还算满意。

站点地址可移步爱与生的苦恼, 欢迎在此记录爱与生的苦恼。

这是一道关于元组+=赋值的谜题, 据说，能答对这道题的都是Python老司机。 请在不执行下面的代码的情况下，回答这个问题

1
2
3
4
5
6
7

>>> t = (1,2,[30,40])
>>> t[2] += [50, 60]
会发生什么, 选择最佳答案:
a) t变成(1, 2, [30, 40, 50, 60])
b 抛出TypeError, 'tuple' object does not support item assignment异常，即元祖对象不支持赋值
c) 上面两种情况都没有发生.
d) a 和 b都发生

看到这题时，第一反应是b。之后使用dis模块查看执行语句, 得到

1
2
3
4
5
6
7
8
9
10
11
12
13

>>> dis.dis("t[2] += [50, 60]")
  1           0 LOAD_NAME                0 (t)
              3 LOAD_CONST               0 (2)
              6 DUP_TOP_TWO
              7 BINARY_SUBSCR
              8 LOAD_CONST               1 (50)
             11 LOAD_CONST               2 (60)
             14 BUILD_LIST               2
             17 INPLACE_ADD
             18 ROT_THREE
             19 STORE_SUBSCR
             20 LOAD_CONST               3 (None)
             23 RETURN_VALUE

可以看到第17条的INPLACE_ADD操作，因为列表是可变对象，所以这条会执行成功。之后第19条进行保存，而元祖是不可变对象，所以第19条会报错。

所以答案是d, 即a和b都发生了。

在Python词汇表里对，可哈希的有这样一段说明:

An object is hashable if it has a hash value which never changes during its lifetime (it needs a hash() method), and can be compared to other objects (it needs an eq() method). Hashable objects which compare equal must have the same hash value.

也就是说，一个对象的哈希值(实现hash方法)在对象的生命周期里永远不变的，这个对象可以与其它对象进行比较(实现eq方法), 相等的对象哈希值一定相等，那么这个对象就是可哈希的。

也就是说，可哈希对象必须满足下面三个条件

1. 支持hash函数，也就是实现hash方法。这个方法的返回值在对象的生命周期里永远不变
2. 支持相等判断，也就是实现eq方法
3. 如果a == b, 那么hash(a)一定等于hash(b)，也就是相等的对象，哈希值一定相等。

这里不明白的是第三点，也就是为什么两个对象相等，哈希值一定要相等，不相等难道不行吗？

下面编写的一个测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class UnHashable(object):
    """
    >>> a = UnHashable(3)
    >>> b = UnHashable(3)
    >>> a == b
    True
    """
    def __init__(self, x):
        self.x = x

    def __eq__(self, other):
        return self.x == other.x

    def __hash__(self):
        import random
        return hash("{} {}".format(self.x, random.random()))

如果我们执行

1
2
3
4

d = dict()
a = UnHashable(3)
b = UnHashable(3)
d[a] = 4

之后我们会希望d[b]返回4，但是并不会如此，因为hash[a]并不一定等于hash[b]. 这就是为什么要求可哈希对象一定要a == b时，hash(a) == hash(b)

在Python中，对于内置不可变对象，都是可哈希的，而字典和列表等可变对象不是可哈希的。

什么是装饰器

在《Fluent Python》里说， A decorator is a callable that takes another function as argument。也就是装饰器就是一个可执行对象，它的参数是一个函数。

1
2
3

@decorate
def target():
    print('running target()')

相当于

1
2
3

def target():
    print('running target()')
target = decorate(target)

另一个重要的问题是当模块导入时，装饰器就执行了。

编写registration.py

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
31
32

registry = []


def register(func):
    print('running register(%s)' % func)
    registry.append(func)
    return func


@register
def f1():
    print('running f1()')


@register
def f2():
    print('running f2()')


def f3():
    print('running f3()')


def main():
    print('running main()')
    print('registry ->', registry)
    f1()
    f2()
    f3()

if __name__ == '__main__':
    main()

之后导入模块，可以看到registration.registry的值

1
2
3
4
5

>>> import registration
running register(<function f1 at 0x10063b1e0>) 
running register(<function f2 at 0x10063b268>)
>>> registration.registry
[<function f1 at 0x10063b1e0>, <function f2 at 0x10063b268>]

编写一个装饰器

下面编写一个记录函数执行时间的装饰器，保存到clockdeco.py中

1
2
3
4
5
6
7
8
9
10
11

import time
def clock(func):
    def clocked(*args): #
        t0 = time.perf_counter()
        result = func(*args) #
        elapsed = time.perf_counter() - t0
        name = func.__name__
        arg_str = ', '.join(repr(arg) for arg in args)
        print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result))
        return result
    return clocked

之后使用这个装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import time
from clockdeco import clock
@clock
def snooze(seconds):
    time.sleep(seconds)

@clock
def factorial(n):
    return 1 if n < 2 else n*factorial(n-1)

if __name__=='__main__':
    print('*' * 40, 'Calling snooze(.123)')
    snooze(.123)
    print('*' * 40, 'Calling factorial(6)')
    print('6! =', factorial(6))

可以看到结果

1
2
3
4
5
6
7

**************************************** Calling snooze(123) [0.12405610s] snooze(.123) -> None **************************************** Calling factorial(6) [0.00000191s] factorial(1) -> 1
[0.00004911s] factorial(2) -> 2
[0.00008488s] factorial(3) -> 6
[0.00013208s] factorial(4) -> 24
[0.00019193s] factorial(5) -> 120
[0.00026107s] factorial(6) -> 720
6!=720

使用内置装饰器

上面编写的clock装饰器存在一个问题是不支持关键字参数，可以使用标准库里的functools.wraps来解决这个问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import time
import functools
def clock(func):
    @functools.wraps(func)
    def clocked(*args, **kwargs):
        t0 = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - t0
        name = func.__name__
        arg_lst = []
        if args:
            arg_lst.append(', '.join(repr(arg) for arg in args))
        if kwargs:
        pairs = ['%s=%r' % (k, w) for k, w in sorted(kwargs.items())]
        arg_lst.append(', '.join(pairs))
        arg_str = ', '.join(arg_lst)
        print('[%0.8fs] %s(%s) -> %r ' % (elapsed, name, arg_str, result))
        return result
    return clocked

Python内置了三个常用的装饰器，property，classmethod和staticmethod，
标准库functools里还有两个有趣的装饰器lru_cache和singledispatch。

编写带参数的装饰器

要编写带参数的装饰器，一个解决的办法是编写一个装饰器工厂，然后根据参数不同，返回不同的装饰器。

拿上面的clock装饰器来说，如果要允许传入时间格式来输出不同的日期格式，可以如下编写装饰器工厂, 保存到clockdeco_param.py中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import time
DEFAULT_FMT = '[{elapsed:0.8f}s] {name}({args}) -> {result}'
def clock(fmt=DEFAULT_FMT):
    def decorate(func):
        def clocked(*_args):
            t0 = time.time()
            _result = func(*_args)
            elapsed = time.time() - t0
            name = func.__name__
            args = ', '.join(repr(arg) for arg in _args)
            result = repr(_result)
            print(fmt.format(**locals()))
            return _result
        return clocked
    return decorate

编写如下测试代码，可以看到不同的时间格式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import time
from clockdeco_param import clock
@clock()
def snooze(seconds):
    time.sleep(seconds)

for i in range(3):
    snooze(.123)


@clock('{name}({args}) dt={elapsed:0.3f}s')
def snooze(seconds):
    time.sleep(seconds)


for i in range(3):
    snooze(.123)

输出结果如下

1
2
3
4
5
6

[0.12581110s] snooze(0.123) -> None
[0.12463617s] snooze(0.123) -> None
[0.12825012s] snooze(0.123) -> None
snooze(0.123) dt=0.127s
snooze(0.123) dt=0.126s
snooze(0.123) dt=0.126s

《Fluent Python》里说，简单来说，闭包就是一个包含非全局变量且该变量不是在它自己函数体里声明的函数。它不关心函数是否匿名，它关心的是可以访问不在自己函数体里定义的非全局变量。

考虑一个avg平均值函数，如下

1
2
3
4
5
6

>>> avg(10) 
10.0
>>> avg(11) 
10.5
>>> avg(12) 
11.0

一个使用类的方法如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Averager():
    """
    >>> avg = Averager()
    >>> avg(10)
    10.0
    >>> avg(11)
    10.5
    >>> avg(12)
    11.0
    """
    def __init__(self):
        self.series = []
    def __call__(self, new_value):
        self.series.append(new_value)
        total = sum(self.series)
        return total/len(self.series)

一个函数的实现方法如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def make_averager():
    """
    >>> avg = make_averager()
    >>> avg(10)
    10.0
    >>> avg(11)
    10.5
    >>> avg(12)
    11.0
    """
    series = []
    def averager(new_value):
        series.append(new_value)
        total = sum(series)
        return total/len(series)
    return averager

这里需要注意的是series相对于averager是一个自由变量，也就是这个变量不属于局部变量。

1
2

>>> avg.__code__.co_varnames ('new_value', 'total')
>>> avg.__code__.co_freevars ('series',)

而每一个avg.__code__.co_freevars里的变量的值都保存在avg.__closure__中，其值在avg.__closure__[0].cell_contents

1
2
3
4
5
6

>>> avg.__code__.co_freevars
('series',)
>>> avg.__closure__
(<cell at 0x107a44f78: list object at 0x107a91a48>,) 
>>> avg.__closure__[0].cell_contents
[10, 11, 12]

所以，闭包就是一个可以从自由变量里获取变量的函数。

下面看看为什么会引入nonlocal这个关键字，以及它的作用。

如果我们想办法消除series变量，可以编写如下函数。

1
2
3
4
5
6
7
8
9

def make_averager():
 
    count = 0
    total = 0
    def averager(new_value):
        count += 1
        total += new_value
        return total / count
    return averager

但函数执行时会报错

1
2
3
4
5
6

>>> avg = make_averager()
>>> avg(10)
Traceback (most recent call last):
...
UnboundLocalError: local variable 'count' referenced before assignment
>>>

这是因为变量作用域的原因。count += 1相当于count = count + 1, 此时count会被当做局部变量，而不是引用外面一层的count, 而averager函数里并没有声明count变量，于是报错。可以参看Python之dis模块

在Python3里添加了nonlocal来解决这个问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def make_averager():
    """
    >>> avg = make_averager()
    >>> avg(10)
    10.0
    >>> avg(11)
    10.5
    >>> avg(12)
    11.0
    """
    count = 0
    total = 0
    def averager(new_value):
        nonlocal count, total
        count += 1
        total += new_value
        return total / count
    return averager

dis, 即Disassembler for Python bytecode, 用于Python字节码的反汇编。可以用于查看函数的具体执行步骤，例如下面的局部变量的例子

1
2
3

def f1(a):
    print(a)
    print(b)

得到

1
2
3
4
5
6
7
8
9
10
11

3           0 LOAD_GLOBAL              0 (print)
            3 LOAD_FAST                0 (a)
            6 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
            9 POP_TOP

4          10 LOAD_GLOBAL              0 (print)
           13 LOAD_GLOBAL              1 (b)
           16 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
           19 POP_TOP
           20 LOAD_CONST               0 (None)
           23 RETURN_VALUE

执行

1
2
3

a = 3
b = 4
f1(a)

不会报错，这里第13条是LOAD_GLOBAL，此时有全局变量b.

再看这个例子

1
2
3
4

def f2(a):
    print(a)
    print(b)
    b = 9

得到的是

1
2
3
4
5
6
7
8
9
10
11
12
13
14

4           0 LOAD_GLOBAL              0 (print)
            3 LOAD_FAST                0 (a)
            6 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
            9 POP_TOP

5          10 LOAD_GLOBAL              0 (print)
           13 LOAD_FAST                1 (b)
           16 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
           19 POP_TOP

6          20 LOAD_CONST               1 (9)
           23 STORE_FAST               1 (b)
           26 LOAD_CONST               0 (None)
           29 RETURN_VALUE

执行

1
2
3

a = 3
b = 4
f2(a)

会报找不到局部变量b, 这是因为第13条LOAD_FAST是加载局部变量，此时还没有局部变量b.

《Fluent Python》中写到，在使用Python字典时，有两种方式，d[key]与d.get(key)，它们有一些细微的区别

• d[key]底层实现是调用dict.__getitem__, 而d.get(key)就是一个函数调用。

• 当dict.__getitem__ 没有找到key时，会调用dict.__missing__

执行如下代码

1
2
3
4

from dis import dis
d = dict()
print(dis('d["a"]'))
print(dis('d.get("a")'))

输出如下结果

1
2
3
4
5
6
7
8
9
10

 1           0 LOAD_NAME                0 (d)
              3 LOAD_CONST               0 ('a')
              6 BINARY_SUBSCR
              7 RETURN_VALUE
None
  1           0 LOAD_NAME                0 (d)
              3 LOAD_ATTR                1 (get)
              6 LOAD_CONST               0 ('a')
              9 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             12 RETURN_VALUE

可以看到get是函数调用，而d[]不是。

编写测试代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Dict(dict):
    def __getitem__(self, key):
        return 2

class TestMiss(dict):
    def __missing__(self, key):
        return 3

if __name__ == "__main__":
    d = Dict()
    d["key"] = "test"
    print(d.get("key"), d["key"], d.get("k"), d["k"])

    d = TestMiss()
    d["key"] = "test"
    print(d.get("key"), d["key"], d.get("k"), d["k"])

输出结果如下

1
2

test 2 None 2
test test None 3

在ici，基于python的终端查词小工具看到终端查词小工具，遗憾的是不能查中文，而这是我经常用的。尝试在ici上添加中文，没有搞定，于是决定自己写一个。因为经常使用有道词典，于是有了ydd.

真正写起来还是比较简单，就是一个HTTP请求，之后读取JSON里的数据，显示出来。使用了click和requests两个库后，很快就写好了。click提供命令行参数解析以及终端颜色显示，requests用来发起请求非常方便。考虑到是小工具，所以异常情况都没有处理，代码总共才70行。后来发现不能兼容2.7，于是加上six来判断Python版本。

之后是使用setuptools发布到pypi上，很开心。目前使用上来说，查英文单词还是ici好，因为有例句，不过查中文当然是使用ydd好了。

好好的Chrome，在上传文件时，换回结果是text/plain类型时，突然报这个错，VM7369:1 Uncaught SyntaxError: Unexpected token ( in JSON at position 0，而其它浏览器就没有这个问题。

刚开始以为是版本太新的原因，于是改用低版本，发现问题还是存在，看同事的Mac，不存在这个问题。

最后在前端同事的帮助下，知道Chrome的隐身模式，在Chrome隐身模式下没有这个问题，于是猜测是插件问题。最终锁定是
LastPass: Free Password Manager这个插件的原因。禁用后就没有这个问题。

coverage用来统计代码测试覆盖率，非常方便。

安装

执行pip install coverage即可

指定代码路径

希望coverage只去统计我们关心的代码，此时–source选项派上用场。例如coverage --source .只统计当前目录下的所有代码。

coveragerc配置

通过使用coverage配置文件，可以很方便的控制coverage。coverage默认使用.coveragerc里的配置，也可以通过–rcfile来配置。

统计数据输出

执行完coverage测试后，可以执行coverage report和coverage html输出统计信息。

完整的Django测试执行命令可以这样coverage run --rcfile=.coveragerc --source . ./manage.py test