流畅的python

1 一摞Python风格的纸牌

import collections

Card = collections.namedtuple('Card', ['rank', 'suit'])
suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)


class FrenchDeck:
    ranks = [str(n) for n in range(2, 11)] + list('JQKA')
    suits = 'spades diamonds clubs hearts'.split()

    def __init__(self):
        self._cards = [Card(rank, suit) for suit in self.suits for rank in self.ranks]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, position):
        return self._cards[position]

def spades_high(card):
    rank_value = FrenchDeck.ranks.index(card.rank)
    return rank_value * len(suit_values) + suit_values[card.suit]

for card in sorted(deck, key=spades_high):
	print(card)
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

獲取一個紙牌對象

beer_card = Card('7', 'diamonds')
1

getitem 方法提供

• 抽取特定的一張紙牌

  deck = FrenchDeck()
  deck[0]
  1
  2

• 随机抽取一张纸牌

  from random import choice
  choice(deck)
  1
  2

• 自动支持切片（slicing）操作

  deck[12::13]
  1

• 將一摞牌变成可迭代

  for card in deck:
  	print(card)
  for card in reversed(deck):
      print(card)
  1
  2
  3
  4

排序

suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)
def spades_high(card):
	rank_value = FrenchDeck.ranks.index(card.rank)
	return rank_value * len(suit_values) + suit_values[card.suit]
	
# 有了 spades_high 函数，就能对这摞牌进行升序排序了：
for card in sorted(deck, key=spades_high):
	print(card)
1
2
3
4
5
6
7
8

python风格

• python最好的品质之一是一致性；
• python的设计思想完全体现在python的数据模型上，而数据模型所描述的API，为使用最地道的语言特性来构建你自己的对象提供了工具；
• python解释器碰到特殊的句法时，会使用特殊方法去激活一些基本的对象操作；
• 中缀运算符的基本原则就是不改变操作对象，而是产出一个新的值。
• 在切片和区间操作里不包含区间范围的最后一个元素。
  • 当只有最有一个位置信息时，我们也可以快速看出切片和区间里有几个元素：range(3)和my_list[:3]都返回3个元素；
  • 当起止位置信息都可见时，我们可以快速计算出切片和区间的长度，用后一个数减去第一个下标（stop-start）即可；
  • 可以利用任意一个下标来把序列分割成不重叠的两部分，只要携程my_list[:x]和mylist[x:]就可以了。
• python的一个惯例：如果一个函数或者方法对对象进行的是就地改动，那它就应该返回None，好让调用者知道传入的参数发生了变动，而且并未产生新的的对象。

如何使用特殊方法

• 特殊方法的存在是为了被 Python 解释器调用的，你自己并不需要调用它们：
  • 也就是说没有 my_object._len_() 这种写法，而应该使用 len(my_object)。
  • 在执行 len(my_object) 的时候，如果my_object 是一个自定义类的对象，那么 Python 会自己去调用其中由你实现的 _len_ 方法。
• 然而如果是 Python 内置的类型，比如列表（list）、字符串（str）、字节序列（bytearray）等，那么 CPython 会抄个近路，_len_ 实际上会直接返回 PyVarObject 里的 ob_size 属性。PyVarObject 是表示内存中长度可变的内置对象的 C 语言结构体。直接读取这个值比调用一个方法要快很多。
• 很多时候，特殊方法的调用是隐式的，比如 for i in x: 这个语句，背后其实用的是 iter(x)，而这个函数的背后则是 x._iter_() 方法。当然前提是这个方法在 x 中被实现了。
• __init__ 方法，目的是在你自己的子类的_init_ 方法中调用超类的构造器。
• 通过内置的函数（例如 len、iter、str，等等）来使用特殊方法是最好的选择。这些内置函数不仅会调用特殊方法，通常还提供额外的好处，而且对于内置的类来说，它们的速度更快。

2 數據結構

内置序列类型

• 容器序列: list、tuple 和 collections.deque

  这些序列能存放不同类型的数据。

  容器序列存放的是它们所包含的任意类型的对象的引用

• 扁平序列: str、bytes、bytearray、memoryview 和 array.array

  这类序列只能容纳一种类型。

  扁平序列里存放的是值而不是引用；

  扁平序列是一段连续的内存空间，它里面只能存放诸如字符、字节和数值这种基础类型。

• 可变序列: list、bytearray、array.array、collections.deque 和 memoryview

• 不可变序列: tuple、str 和 bytes

列表表達式

• 列表推导不会有变量泄露的问题
• 列表推导可以帮助我们把一个序列或是其他可迭代类型中的元素过滤或是加工，然后再新建一个列表。

beyond_ascii = [ord(s) for s in symbols if ord(s) > 127]
1

map/filter 组合

beyond_ascii = list(filter(lambda c: c > 127, map(ord, symbols)))
1

生成器表达式

colors = ['black', 'white']
sizes = ['S', 'M', 'L']
for tshirt in ('%s %s' % (c, s) for c in colors for s in sizes):
    print(tshirt)
1
2
3
4

元祖

• 元祖其实是对数据的记录：元祖中的每个元素都存放了记录中一个字段的数据，外加这个字段的位置。

元祖拆包

city, year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8014)
1

• 不使用中间变量交换两个变量的值

  b, a = a, b
  1

• 用 * 运算符把一个可迭代对象拆开作为函数的参数

  divmod(*t)
  1

• 让一个函数可以用元组的形式返回多个值，然后调用函数的代码就能轻松地接受这些返回值

  import os 
  
  path, filename = os.path.split('/home/luciano/.ssh/idrsa.pub')
  print(path)  # /home/luciano/.ssh
  print(filename)  # idrsa.pub
  1
  2
  3
  4
  5

• 函数用 *args 来获取不确定数量的参数

  >>> a, b, *rest = range(5)
  >>> a, b, rest
  (0, 1, [2, 3, 4])
  
  >>> *rest， a, b = range(5)
  >>> a, b, rest
  ([0, 1, 2], 3, 4)
  1
  2
  3
  4
  5
  6
  7

• 嵌套元祖拆包

具名元组

• 创建一个具名元祖需要两个参数，一个是类名，另一个是类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串。

• 存放在对应字段里的数据要以一串参数的形式传入到构造函数中，注意元祖的构造函数只接受单一的可迭代对象。

• 可以通过字段名或位置来获取一个字段的信息。

• _fields类属性：是一个包含这个类所有字段名称的元祖

• _make()：通过接受一个可迭代对象来生成这个类的一个实例，它的作用跟City(*delhi_data)是一样的

  from collections import namedtuple
  
  City = namedtuple('City', 'name country population coordinates')
  LatLong = namedtuple('LatLong', 'lat long')
  delhi_data = ('Delhi NCR', 'IN', 21.935, LatLong(28.613889, 77.208889))
  delhi = City._make(delhi_data)
  result = City(*delhi_data)
  print(delhi)
  print(result)
  >>> City(name='Delhi NCR', country='IN', population=21.935, coordinates=LatLong(lat=28.613889, long=77.208889))
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

from collections import namedtuple
City = namedtuple('City', 'name country population coordinates')
tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))

>>> tokyo
City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722,
139.691667))
>>> tokyo.population
36.933
1
2
3
4
5
6
7
8
9

切片

• ​用s[a : b : c]的形式对s在a和b之间以c为间隔取值。c的值为负值意味着反向取值。

• 操作方式

  1. 对对象进行切片

  2. 多维切片

  3. 省略

  4. 给切片赋值

     把切片放在赋值语句的左边，或把它作为del操作的对象，我们就可以对序列进行嫁接、切除或就地修改操作。

     如果赋值的对象是一个切片，那么赋值语句的右侧必须是个可迭代对象。即便只有单独一个值，也要把它转换成可迭代的序列。

对序列使用+和*

• 不修改原有的操作对象，而是构建一个全新的序列。

board = [['_'] * 3 for i in range(3)]
>>> board
[['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
1
2
3

序列的增量赋值

• +=对可变序列来说，变量名会不会被关联到新的对象，完全取决于类型有没有实现__iadd__方法，使用id()查看。

增量操作

• 对不可变序列进行重复拼接操作的话，效率会很低，因为每次都有一个新对象，而解释器需要把原来对象中的元素先复制到新的对象里，然后再追加新的元素。
• str 是一个例外，因为对字符串做 += 实在是太普遍了，所以 CPython 对它做了优化。为 str初始化内存的时候，程序会为它留出额外的可扩展空间，因此进行增量操作的时候，并不会涉及复制原有字符串到新位置这类操作。

list.sort方法

• list.sort方法会就地排序列表，因此不会把原列表复制一份。

• 内置函数sorted会新建一个列表作为返回值。可以接受任何形式的可迭代对象作为参数，甚至包括不可变序列或生成器。

• reverse

  如果被设定为True，被排序的序列里的元素会以降序输出。

• key

  一个只有一个参数的函数，这个函数会被用在序列里的每一个元素上，所产生的结果将是排序算法依赖的对比关键字。

sorted 函数的key

一个只有一个参数的函数，这个函数会被用在序列里的每一个元素上，所产生的结果将是排序算法依赖的对比关键字。比如说，在对一些字符串排序时，可以用 key=str.lower 来实现忽略大小写的排序，或者是用 key=len 进行基于字符串长度的排序。这个参数的默认值是恒等函数（identity function），也就是默认用元素自己的值来排序。

• sorted会新建一个列表作为返回值。

• sorted方法可以接受任何形式的可迭代对象作为参数，甚至包括不可变序列或生成器。而不管 sorted 接受的是怎样的参数，它最后都会返回一个列表。

• Python 的排序算法——Timsort——是稳定的，意思是就算两个元素比不出大小，在每次排序的结果里它们的相对位置是固定的。

  >>> fruits = ['grape', 'raspberry', 'apple', 'banana']
  >>> sorted(fruits)
  ['apple', 'banana', 'grape', 'raspberry'] ➊
  >>> fruits
  ['grape', 'raspberry', 'apple', 'banana'] ➋
  >>> sorted(fruits, reverse=True)
  ['raspberry', 'grape', 'banana', 'apple'] ➌
  >>> sorted(fruits, key=len)
  ['grape', 'apple', 'banana', 'raspberry'] ➍
  >>> sorted(fruits, key=len, reverse=True)
  ['raspberry', 'banana', 'grape', 'apple'] ➎
  >>> fruits
  ['grape', 'raspberry', 'apple', 'banana'] ➏
  >>> fruits.sort() ➐
  >>> fruits
  ['apple', 'banana', 'grape', 'raspberry'] ➑
  """
  ❶ 新建了一个按照字母排序的字符串列表。
  ❷ 原列表并没有变化。
  ❸ 按照字母降序排序。
  ❹ 新建一个按照长度排序的字符串列表。因为这个排序算法是稳定的，grape 和 apple 的长度都是 5，它们的相对位置跟在原来的列表里是一样的。
  ❺ 按照长度降序排序的结果。结果并不是上面那个结果的完全翻转，因为用到的排序算法是稳定的，也就是说在长度一样时，grape 和 apple的相对位置不会改变。
  ❻ 直到这一步，原列表 fruits 都没有任何变化。
  ❼ 对原列表就地排序，返回值 None 会被控制台忽略。
  ❽ 此时 fruits 本身被排序。
  """
  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

用bisect来管理已排序的序列

bisect(haystack, needle)在haystack里搜索needle的位置，该位置满足的条件是，把needle插入这个位置之后，haystack还能保持升序。也就是这个函数返回的位置前面的值，都小于或等于needle的值。

用bisect.insort插入新元素

insort(seq, item)把变量item插入到序列seq中，并能保持seq的升序顺序。

数组

• 数组在背后存的并不是float对象，而是数字的机器翻译，也就是字节表述。因此要存放1000万个浮点数，数组（array）的效率更高。
• 一个只包含数字的列表，用array.array比list更高效。
• 频繁对序列作出先进先出的操作，deque（双端队列）的速度更快。
• 包含操作（比如检查一个元素是否出现在一个集合中）的频率很高，用set（集合）会更合适。

>>> from array import array ➊ 引入 array 类型。
>>> from random import random
>>> floats = array('d', (random() for i in range(10**7))) ➋ 利用一个可迭代对象来建立一个双精度浮点数组（类型码是 'd'），这里我们用的可迭代对象是一个生成器表达式。
>>> floats[-1] ➌ 查看数组的最后一个元素。
0.07802343889111107
>>> fp = open('floats.bin', 'wb')
>>> floats.tofile(fp) ➍ 把数组存入一个二进制文件里。
>>> fp.close()
>>> floats2 = array('d') ➎ 新建一个双精度浮点空数组。
>>> fp = open('floats.bin', 'rb')
>>> floats2.fromfile(fp, 10**7) ➏ 把 1000 万个浮点数从二进制文件里读取出来。
>>> fp.close()
>>> floats2[-1] ➐ 查看新数组的最后一个元素。
0.07802343889111107
>>> floats2 == floats ➑ 检查两个数组的内容是不是完全一样。
True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

memoryview

是一个内置类，它能让用户在不复制内容的情况下操作同一个数组的不同切片，即在数据结构之间共享内存

队列

collections.deque类（双向队列）

是一个线程安全、可以快速从两端添加或者删除元素的数据类型。

from collections import deque
dq = deque(range(10), maxlen=10) ➊ maxlen 是一个可选参数，代表这个队列可以容纳的元素的数量，而且一旦设定，这个属性就不能修改了。
dq.rotate(3) ➋ 队列的旋转操作接受一个参数 n，当 n > 0 时，队列的最右边的 n个元素会被移动到队列的左边。当 n < 0 时，最左边的 n 个元素会被移动到右边。
dq.appendleft(-1) ➌ 当试图对一个已满（len(d) == d.maxlen）的队列做尾部添加操作的时候，它头部的元素会被删除掉。
dq.extend([11, 22, 33]) ➍ 在尾部添加 3 个元素的操作会挤掉 -1、1 和 2。
dq.extendleft([10, 20, 30, 40]) ➎ extendleft(iter) 方法会把迭代器里的元素逐个添加到双向队列的左边，因此迭代器里的元素会逆序出现在队列里。
1
2
3
4
5
6

dict字典 - 映射类型

• isinstance可以用来判定某个数据是否为广义上的映射类型

  my_dict = {}
  isinstance(my_dict, abc.Mapping)
  1
  2

• 标准库里的所有映射类型都是利用dict来实现的

可散列的数据类型

如果一个对象是可散列的，那么在这个对象的声明周期中，它的散列值是不变的，而且这个对象需要实现__hash__()方法。另外可散列对象还要有__qe__()方法，这样才能跟其他键做比较。如果两个可散列对象是相等的，那么它们的散列值一定是一样的。

用setdefault处理找不到的键

"""创建从一个单词到其出现情况的映射"""
"""获取单词的出现情况列表，如果单词不存在，把单词和一个空列表
放进映射，然后返回这个空列表，这样就能在不进行第二次查找的情况
下更新列表了。"""

import sys
import re

WORD_RE = re.compile(r'\w+')
index = {}
with open(sys.argv[0], encoding='utf-8') as fp:
    for line_no, line in enumerate(fp, 1):
        for match in WORD_RE.finditer(line):
            word = match.group()
            column_no = match.start() + 1
            location = (line_no, column_no)
            index.setdefault(word, []).append(location)

print(index)
# 以字母顺序打印出结果
for word in sorted(index, key=str.upper):
    print(word, len(index[word]))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

defaultdict：处理找不到的键的一个选择

在用户创建defaultdict对象的时候，需要给构造方法提供一个可调用对象，这个可调用对象会在__getitem__碰到找不到的键的时候被调用，让__getitem__返回某种默认值。

特殊方法__missing__

所有的映射类型在处理找不到的键的时候，都会牵扯到__missing__方法。

如果有一个类继承了 dict，然后这个继承类提供了 _missing_ 方法，那么在 _getitem_ 碰到找不到的键的时候，Python 就会自动调用它，而不是抛出一个 KeyError 异常。

class StrKeyDict0(dict):  # ➊ StrKeyDict0 继承了 dict。
    """在查询的时候把非字符串的键转换为字符串"""

    def __missing__(self, key):
        if isinstance(key, str):  # ➋ 如果找不到的键本身就是字符串，那就抛出 KeyError 异常。
            raise KeyError(key)
        return self[str(key)]  # ➌ 如果找不到的键不是字符串，那么把它转换成字符串再进行查找。

    def get(self, key, default=None):
        try:
            return self[key]  # ➍get 方法把查找工作用 self[key] 的形式委托给 __getitem__，这样在宣布查找失败之前，还能通过 __missing__ 再给某个键一个机会.
        except KeyError:
            return default  # ➎ 如果抛出 KeyError，那么说明 __missing__ 也失败了，于是返回default.

    def __contains__(self, key):
        return key in self.keys() or str(key) in self.keys()  # ➏ 先按照传入键的原本的值来查找（我们的映射类型中可能含有非字符串的键），如果没找到，再用 str() 方法把键转换成字符串再查一次


d = StrKeyDict0([('2', 'two'), ('4', 'four')])
print(d['2'])

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

字典的变种

• collections.OrderedDict

这个类型在添加键的时候会保持顺序，因此键的迭代次序总是一致的。

• collections.ChainMap

  这类型可以容纳数个不同的映射对象，然后在进行键查找操作的时候，这些对象会被当作一个整体被逐个查找，直到键被找到为止。

• collections.Counter

  这个映射类型会给键准备一个整数计数器。每次更新一个键的时候都会增加这个计数器。

• 子类化UserDict

 """"无论是添加、更新还是查询操作，StrKeyDict 都会把
 非字符串的键转换为字符串"""
 import collections

 class StrKeyDict(collections.UserDict):  # ➊ StrKeyDict 是对 UserDict 的扩展。
     def __missing__(self, key):  # ➋
         if isinstance(key, str):
             raise KeyError(key)
         return self[str(key)]
   
     def __contains__(self, key):
         return str(key) in self.data  # ➌ 这里可以放心假设所有已经存储的键都是字符串。因此，只要在 self.data 上查询就好了,
   
     def __setitem__(self, key, item):
         self.data[str(key)] = item  # ➍ __setitem__ 会把所有的键都转换成字符串
 d = StrKeyDict0([('2', 'two'), ('4', 'four')])
 print(d['2'])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

不可变映射类型MappingProxyType

types模块中引入了一个封装类名叫MappingProxyType。如果给这个类一个映射，它就返回一个只读的映射视图。虽然是个只读视图，但是它是动态的。这意味着如果对原映射做出改动，我们通过这个视图可以观察到，但是无法通过这个视图对原映射做出修改。

from types import MappingProxyType

d = {1: 'A'}
d_proxy = MappingProxyType(d)
1
2
3
4

大多数映射类型都提供的方法：

1. setdefault

   setdefaul方法可以用来更新字典里存放的可变值，比如列表，从而避免了重复键搜索。

2. update

   update方法让批量更新成为可能，它可以用来插入新值或者更新已有键值对，它的参数可以是包含（key, value）这种键值对的可迭代对象，或者关键字参数。映射类型的构造方法也会利用update方法来让用户可以使用别的映射对象、可迭代对象或者关键字参数来创建新对象。

集合类型

• 集合的本质是许多唯一对象的聚集。因此，集合可以用于去重。
• 集合实现了很多基础的中缀 运算符：合集|、&交集、-差集
• 查找功能速度极快（得益于集合背后的散列表）
• 空集必须写成set()
• 除了空集，集合的字符串表示形式总是以{…}的形像{1, 2, 3}这种字面量句法相比于构造方法set([1,2,3])要更快且更易读。

字典dict和集合set类型背后的实现 - 散列表

dict的实现

• 键必须是可散列的

  所有由用户自定义的对象默认都是可散列的，因为它们的散列值由id()来获取，而且它们都是不相等的。

  1. 支持hash()函数，并且通过_hash_()方法所得到的散列值是不变的；
  2. 支持通过_eq_()方法来检测相等性；
  3. 若a == b为真，则hash(a) == hash(b) 也为真；

• 字典在内存上的开销巨大

  由于字典使用了散列表，而散列表又必须是稀疏的，这导致它在空间上的效率低下。

  • 用元祖取代字典就能节省空间的原因：
    1. 避免了散列表所耗费的空间；
    2. 无需把记录中字段的名字在每个元素里都存一遍

• 键查询很快

  dict的实现是典型的空间换时间：字典类型有着巨大的内存开销，但它们提供了无视数据量大小的快速访问–只要字典能被装在内存里。

• 键的次序取决于添加顺序

  当往 dict 里添加新键而又发生散列冲突的时候，新键可能会被安排存放到另一个位置。

• 往字典里添加新键可能会改变已有键的顺序

  无论何时往字典里添加新的键，Python 解释器都可能做出为字典扩容的决定。扩容导致的结果就是要新建一个更大的散列表，并把字典里已有的元素添加到新表里。这个过程中可能会发生新的散列冲突，导致新散列表中键的次序变化。要注意的是，上面提到的这些变化是否会发生以及如何发生，都依赖于字典背后的具体实现，因此你不能很自信地说自己知道背后发生了什么。如果你在迭代一个字典的所有键的过程中同时对字典进行修改，那么这个循环很有可能会跳过一些键——甚至是跳过那些字典中已经有的键。

  由此可知，不要对字典同时进行迭代和修改。如果想扫描并修改一个字典，最好分成两步来进行：首先对字典迭代，以得出需要添加的内容，把这些内容放在一个新字典里；迭代结束之后再对原有字典进行更新。

set的实现

set 和 frozenset的实现也依赖散列表，但在它们的散列表里存放的只有元素的引用。

• 集合里的元素必须是可散列的；
• 集合很消耗内存；
• 可以很高效地判断元素是否存在于某个集合；
• 元素的次序取决于被添加到集合里的次序；
• 往集合里添加元素，可能会改变集合里已有元素的次序；

文本和字节序列

unicode标准

• 字符的标识，即码位，是0_{1114111的数字（十进制），在Unicode标准中以4}6个十六进制数字表示，而且加前缀“U+”。
• 字符的具体表述取决于所用的编码。编码是在码位和字节序列之间转换时使用的算法。
• 把码位转换成字节序列的过程是编码；把字节序列转换成码位的过程是解码。

二进制序列类型

• bytes或bytearray对象的各个元素是介于0~255（含）之间的整数。

处理UnicodeEncodeError

city = 'São Paulo'
city.encode('utf_8')
city.encode('utf_16')
city.encode('cp437', errors='ignore') # error='ignore' 处理方式悄无声息地跳过无法编码的字符
city.encode('cp437', errors='replace') # 编码时指定 error='replace'，把无法编码的字符替换成 '?'；
city.encode('cp437', errors='xmlcharrefreplace') # 'xmlcharrefreplace' 把无法编码的字符替换成 XML 实体。
1
2
3
4
5
6

处理UnicodeDecodeError

不是每一个字节都包含有效的 ASCII 字符，也不是每一个字符序列都是有效的 UTF-8 或 UTF-16。

特殊方法

Python 解释器碰到特殊的句法时，会使用特殊方法去激活一些基本的对象操作。

特殊方法的存在是为了被 Python 解释器调用的。

_len_

Return the number of items in a container.

_getitem_

Return self[key]

• 使类自动支持切片（slicing）操作
• 使類變成可迭代的

_init_

_iter_

_abs_

如果输入是整数或者浮点数，它返回的是输入值的绝对值；如果输入是复数（complex number），那么返回这个复数的模

_repr_

得到一个对象的字符串表示形式

_add_

算術運算符 +

_mul_

算術運算符 *

_bool_

判斷真假 返回 True 或者 False。

元祖嵌套列表

# t[2] 被改动了，但是也有异常抛出
t = (1, 2, [30, 40])
t[2] += [50, 60]
print(t)
1
2
3
4

一个浮点型数组的创建、存入文件和从文件读取的过程

from array import array
from random import random

# array.tofile 和 array.fromfile
floats = array('d', (random() for i in range(10 ** 7)))
print(floats[-1])
fp = open('floats.bin', 'wb')
floats.tofile(fp)
fp.close()
floats2 = array('d')
fp = open('floats.bin', 'rb')
floats2.fromfile(fp, 10 ** 7)
fp.close()
print(floats2[-1])
1
2
3
4
5
6
7
8
9
10
11
12
13
14

雙向隊列

from collections import deque

dq = deque(range(10), maxlen=10)
1
2
3

不可變映射類型

from types import MappingProxyType

d = {1: 'A'}
d_proxy = MappingProxyType(d)
d[2] = "b"
print(d_proxy)
1
2
3
4
5
6

可散列类型的定义

如果一个对象是可散列的，那么在这个对象的生命周期中，它的散列值是不变的，而且这个对象需要实现 __hash__() 方法。另外可散列对象还要有 __qe__() 方法，这样才能跟其他键做比较。如果两个可散列对象是相等的，那么它们的散列值一定是一样的……

學習方式總結

從整體到局部：首先從整體上去把握（整體的結構是什麼？–what，整體的內容是什麼？又分為哪些部分？目的是什麼？為什麼存在？–why。通過通讀一遍的方式，把握整體的脈絡、主旨、大意，肯定會遇到問題，先對問題有個基本的印象，以便日後有針對性地掃除問題），然後從局部去逐一理解（作者為了達成目的使用了設麼方法，或者提供了什麼工具？–how），如何解決問題？wha?why?how?找到問題的突破口，引入負熵，通過搜索或尋求幫助，通過記錄筆記可以更好地實現目標。

我發現，再晦澀的內容，通過整體到局部，通過刻意練習，不斷地拆解，不斷地引入負熵理解問題，逐一去解決問題，不斷掃除障礙，掃除知識盲區，通過時間慢慢去消化，都可以將開始難以理解的內容得心應手，你的理解和能力也會有有一個質的飛越。

• Unicode 字符串、二进制序列、Unicode 文本、ASCII 文本、字节序列、码位、bytes 对象、str 对象、bytearray 类型、memoryview、array.array
• 把码位转换成字节序列的过程是编码 .encode()
• 把字节序列转换成码位的过程是解码 .decode()

s = 'café'
len(s) # 'café' 字符串有 4 个 Unicode 字符。
4
b = s.encode('utf8') # 使用 UTF-8 把 str 对象编码成 bytes 对象。
b
b'caf\xc3\xa9' # bytes 字面量以 b 开头
len(b) # 字节序列 b 有 5 个字节（在 UTF-8 中，“é”的码位编码成两个字节）。
5
b.decode('utf8') # 使用 UTF-8 把 bytes 对象解码成 str 对象。
'café
1
2
3
4
5
6
7
8
9
10

• bytes 或 bytearray 对象的各个元素是介于 0~255（含）之间的整数

cafe = bytes('café', encoding='utf_8') # bytes 对象可以从 str 对象使用给定的编码构建。
cafe # b'caf\xc3\xa9'
cafe[0] # 99 各个元素是 range(256) 内的整数。
cafe[:1] # b'c'
cafe_arr = bytearray(cafe)
cafe_arr # bytearray(b'caf\xc3\xa9') bytearray 对象没有字面量句法，而是以 bytearray() 和字节序列字面量参数的形式显示。
cafe_arr[-1:] # bytearray(b'\xa9') bytearray 对象的切片还是 bytearray 对象。
1
2
3
4
5
6
7

• 虽然二进制序列其实是整数序列，但是它们的字面量表示法表明其中有ASCII 文本。因此，各个字节的值可能会使用下列三种不同的方式显示。

  • 可打印的 ASCII 范围内的字节（从空格到 ~），使用 ASCII 字符本身。
  • 制表符、换行符、回车符和 \ 对应的字节，使用转义序列\t、\n、\r 和 \。
  • 其他字节的值，使用十六进制转义序列（例如，\x00 是空字节）。

• memoryview 类不是用于创建或存储字节序列的，而是共享内存，让你访问其他二进制序列、打包的数组和缓冲中的数据切片，而无需复制字节序列

一等函数

python函数的一等本性：可以把函数赋值给变量、传给其他函数、存储在数据结构中，以及访问函数的属性，供框架和一些工具使用。

一等函数

• 在运行时创建
• 能赋值给变量或数据结构中的元素
• 能作为参数传给函数
• 能作为函数的返回结果

高阶函数

• 接受函数为参数，或者把函数作为结果返回的函数是高阶函数(map,sorted,reduce)

• 常用的高阶函数：sorted、map、filter、reduce

• 归约函数

  • sum和reduce的通用思想是把某个操作连续应用到序列的元素上，累计之前的结果，把一系列值归约成一个值。
  • all(iterable)：如果iterable的每个元素都是真值，返回True；all([])返回True。
  • any(iterable)：只要iterable中有元素是真值，就返回True；all([])返False。

• 匿名函数lambda

  为了使用高阶函数，有时创建一次性的小型函数更便利。这就是匿名函数存在的原因。

  lambda只能使用纯表达式，即lambda函数的定义体中不能赋值，也不能使用while和try等python语句。

  在参数列表中最适合使用匿名函数。

  • 除了作为参数传给高阶函数之外，python很少使用匿名函数。如果使用lambda表达式导致一段代码难以理解，则可以像下面进行重构：
    1. 编写注释，说明lambda表达式的作用；
    2. 研究一会儿注释，并找出一个名称来概括注释；
    3. 把lambda表达式转换成def语句，使用那个名称来定义函数；
    4. 删除注释

• 7种可调用对象

  • 用户定义的函数(使用 def 语句或 lambda 表达式创建)

  • 内置函数(使用 C 语言（CPython）实现的函数，如 len 或 time.strftime)

  • 内置方法(使用 C 语言实现的方法，如 dict.get)

  • 方法(在类的定义体中定义的函数)

  • 类

    调用类时会运行类的 __new__ 方法创建一个实例，然后运行__init__ 方法，初始化实例，最后把实例返回给调用方。因为 Python没有 new 运算符，所以调用类相当于调用函数。（通常，调用类会创建那个类的实例，不过覆盖 __new__ 方法的话，也可能出现其他行为。
    1

  • 类的实例(如果类定义了\ __call__ 方法，那么它的实例可以作为函数调用)

  • 生成器函数(使用 yield 关键字的函数或方法。调用生成器函数返回的是生成器对象)

• 可调用对象

  • python中一切皆对象，函数也是对象，同时也是可调用对象（callable）。
  • 关于可调用对象，我们平时自定义的函数、内置函数和类都属于可调用对象，但凡是可以把一对括号()应用到某个对象身上都可称之为可调用对象，判断对象是否为可调用对象可以用函数 callable()
  • 一个类实例要变成一个可调用对象，只需要实现一个特殊方法_call_()。

• 列出常规对象没有而函数有的属性

  >>> class C: pass # ➊
  >>> obj = C() # ➋
  >>> def func(): pass # ➌
  >>> sorted(set(dir(func)) - set(dir(obj))) # ➍
  ['__annotations__', '__call__', '__closure__', '__code__', '__defaults__',
  '__get__', '__globals__', '__kwdefaults__', '__name__', '__qualname__']
  1
  2
  3
  4
  5
  6

生成器函数

• 生成器函数是使用yield关键字的函数或方法；
• 调用生成器函数返回的是生成器对象；

用户定义的可调用类型

只需要实现实例方法_call_，任何python对象都可以表现得像函数。

实现__call||方法的类是创建函数类对象的简便方式，此时必须在内部维护一个状态，让它在调用之间可用。装饰器就是这样，装饰器必须是函数，而且有时要在多次调用之间“记住”某些事。

import random


class BingoCage:
    def __init__(self, items):
        self._items = list(items)  # ➊ __init__ 接受任何可迭代对象；在本地构建一个副本，防止列表参数的意外副作用.
        random.shuffle(self._items)  # ➋ shuffle 定能完成工作，因为 self._items 是列表。

    def pick(self):  # ➌ 起主要作用的方法。
        try:
            return self._items.pop()
        except IndexError:
            raise LookupError('pick from empty BingoCage')  # ➍ 如果 self._items 为空，抛出异常，并设定错误消息。

    def __call__(self):  # ➎ bingo.pick() 的快捷方式是 bingo()。
        return self.pick()


bingo = BingoCage(range(3))
print(bingo.pick())
print(bingo())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

函数内省

• dir()函数：查看函数对象的所有属性；

• 函数使用__dict__属性存储赋予它的用户属性；

• 函数注解

  def clip(text:str, max_len:'int > 0'=80) -> str:
  函数声明中的各个参数可以在 : 之后增加注解表达式。
  如果参数有默认值，注解放在参数名和 = 号之间。
  如果想注解返回值，在 ) 和函数声明末尾的 : 之间添加 -> 和一个表达式。那个表达式可以是任何类型。
  注解不会做任何处理，只是存储在函数的 __annotations__ 属性
  1
  2
  3
  4
  5

支持函数式编程的包 - operator模块

在函数式编程中，经常需要把算术运算符当作函数使用。

operator 模块为多个算术运算符提供了对应的函数：算术运算符函数

itemgetter 使用 [] 运算符，因此它不仅支持序列，还支持映射和任何实现 _getitem_ 方法的类。

• 使用reduce函数和一个匿名函数计算阶乘

  from functools import reduce
  def fact(n):
  	return reduce(lambda a, b: a*b, range(1, n+1))
  1
  2
  3

• 使用 reduce 和 operator.mul 函数计算阶乘

  from functools import reduce
  from operator import mul
  def fact(n):
  	return reduce(mul, range(1, n+1))
  1
  2
  3
  4

• operator 模块中还有一类函数，能替代从序列中取出元素或读取对象属性的 lambda 表达式：因此，itemgetter 和 attrgetter 其实会自行构建函数：

  • 使用itemgetter排序一个元祖列表

    metro_data = [
        ('Tokyo', 'JP', 36.933, (35.689722, 139.691667)),
        ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)),
        ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)),
        ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)),
        ('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)),
    ]
    
    from operator import itemgetter
    # 按照国家代码（第 2 个字段）的顺序打印各个城市的信息。
    for city in sorted(metro_data, key=itemgetter(1)):
        print(city)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

  • 如果把多个参数传给 itemgetter，它构建的函数会返回提取的值构成的元组：

    metro_data = [
        ('Tokyo', 'JP', 36.933, (35.689722, 139.691667)),
        ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)),
        ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)),
        ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)),
        ('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)),
    ]
    
    from operator import itemgetter
    
    cc_name = itemgetter(1, 0)
    for city in metro_data:
        print(cc_name(city))
    
    """('JP', 'Tokyo')
    ('IN', 'Delhi NCR')
    ('MX', 'Mexico City')
    ('US', 'New York-Newark')
    ('BR', 'Sao Paulo')"""
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19

  • attrgetter

    它创建的函数根据名称提取对象的属性。

    如果把多个属性名传给 attrgetter，它也会返回提取的值构成的元组。

    此外，如果参数名中包含 .（点号），attrgetter 会深入嵌套对象，获取指定的属性。

    metro_data = [
        ('Tokyo', 'JP', 36.933, (35.689722, 139.691667)),
        ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)),
        ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)),
        ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)),
        ('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)),
    ]
    
    from collections import namedtuple
    
    LatLong = namedtuple('LatLong', 'lat long')  # ➊ 使用 namedtuple 定义 LatLong。
    Metropolis = namedtuple('Metropolis', 'name cc pop coord')  # ➋ 再定义 Metropolis。
    
    # ➌ 使用 Metropolis 实例构建 metro_areas 列表；注意，我们使用嵌套的元组拆包提取 (lat, long)，然后使用它们构建 LatLong，作为 Metropolis 的 coord 属性。
    metro_areas = [Metropolis(name, cc, pop, LatLong(lat, long)) for name, cc, pop, (lat, long) in metro_data]
    print(metro_areas[0])
    # Metropolis(name='Tokyo', cc='JP', pop=36.933, coord=LatLong(lat=35.689722, long=139.691667))
    
    Metropolis(name='Tokyo', cc='JP', pop=36.933, coord=LatLong(lat=35.689722, long=139.691667))
    print(metro_areas[0].coord.lat)  # ➍ 深入 metro_areas[0]，获取它的纬度。
    # 35.689722
    
    
    from operator import attrgetter
    
    name_lat = attrgetter('name', 'coord.lat')  # ➎ 定义一个 attrgetter，获取 name 属性和嵌套的 coord.lat 属性。
    for city in sorted(metro_areas, key=attrgetter('coord.lat')):  # ➏ 再次使用 attrgetter，按照纬度排序城市列表。
        print(name_lat(city))  # ➐ 使用标号❺中定义的 attrgetter，只显示城市名和纬度。
    """('Sao Paulo', -23.547778)
    ('Mexico City', 19.433333)
    ('Delhi NCR', 28.613889)
    ('Tokyo', 35.689722)
    ('New York-Newark', 40.808611)"""
    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
    33

  • methodcaller

    methodcaller创建的函数会在对象上调用参数指定的方法。

    from operator import methodcaller
    
    s = 'The time has come'
    upcase = methodcaller('upper')
    print(upcase(s))
    'THE TIME HAS COME'
    hiphenate = methodcaller('replace', ' ', '-')
    print(hiphenate(s))
    'The-time-has-come'
    
    str.upper(s)
    'THE TIME HAS COME'
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

使用functools.partial冻结参数

• functools.partial

  用于部分应用一个函数。部分应用是指，基于一个函数创建一个新的可调用对象，把原函数的某些参数固定。使用这个函数可以把接受一个或多个参数的函数改编成需要回调的API，这样参数更少。

  • 使用partial把一个两参数函数改编成需要单参数的可调用对象

    from operator import mul
    from functools import partial
    triple = partial(mul, 3)
    triple(7)
    21
    >>> list(map(triple, range(1, 10)))
    [3, 6, 9, 12, 15, 18, 21, 24, 27]
    1
    2
    3
    4
    5
    6
    7

装饰器

函数装饰器用于在源码中“标记”函数，以某种方式增强函数的行为

• 装饰器的特性：

  • 能把被装饰的函数替换成其他函数。
  • 装饰器在加载模块时立即执行，而被装饰的函数只在明确调用时运行。

• 函数中赋值时想把解释器当成全局变量，要使用global声明。

• python内置了三个用于装饰方法的函数：property、calssmethod和staticmethod

• 装饰器是可调用的对象，其参数是另一个函数（被装饰的函数）

  @decorate
  def target():
  	print('running target()')
  
  # 上述代码的效果与下述写法一样：
  def target():
  	print('running target()')
  target = decorate(target)
  1
  2
  3
  4
  5
  6
  7
  8

• 装饰器通常把函数替换成另一个函数

  def deco(func):
      def inner():
          print('running inner()')
  
      return inner
  @deco
  def target():
  	print('running target()')
      
  target() # 调用被装饰的 target 其实会运行 inner。
  # running inner()
  print(target) # 审查对象，发现 target 现在是 inner 的引用。
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

• 装饰器在加载模块时立即执行

  装饰器的一个关键特性是，它们在被装饰的函数定义之后立即运行。这通常是在导入时（即 Python 加载模块时）

  register 装饰器原封不动地返回被装饰的函数，但是这种技术并非没有用处。很多 Python Web 框架使用这样的装饰器把函数添加到某种中央注册处，例如把 URL 模式映射到生成 HTTP 响应的函数上的注册处。这种注册装饰器可能会也可能不会修改被装饰的函数。

# 函数装饰器在导入模块时立即执行，而被装饰的函数只在明确调用时运行。
 registry = []  # ➊ registry 保存被 @register 装饰的函数引用。


 def register(func):  # ➋ register 的参数是一个函数。
     print('running register(%s)' % func)  # ➌ 为了演示，显示被装饰的函数。
     registry.append(func)  # ➍  把 func 存入 registry。
     return func  # ➎ 返回 func：必须返回函数；这里返回的函数与通过参数传入的一样。


 @register  # ➏ f1 和 f2 被 @register 装饰。
 def f1():
     print('running f1()')


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


 def f3():  # ➐ f3 没有装饰。
     print('running f3()')


 def main():  # ➑ main 显示 registry，然后调用 f1()、f2() 和 f3()。
     print('running main()')
     print('registry ->', registry)
     f1()
     f2()
     f3()


 if __name__ == '__main__':
     main()  # ➒ 只有把 registration.py 当作脚本运行时才调用 main()。

 """
 running register()
 running register()
 running main()
 registry -> [, ]
 running f1()
 running f2()
 running f3()
 """
 # ，register 在模块中其他函数之前运行（两次）。调用register 时，传给它的参数是被装饰的函数
 # 加载模块后，registry 中有两个被装饰函数的引用：f1 和 f2。这两个函数，以及 f3，只在 main 明确调用它们时才执行。
 """
 1.装饰器函数与被装饰的函数在同一个模块中定义。实际情况是，装饰器通常在一个模块中定义，然后应用到其他模块中的函数上。
 2.register 装饰器返回的函数与通过参数传入的相同。实际上，大多数装饰器会在内部定义一个函数，然后将其返回。
 """
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

• 如果导入 registration.py 模块（不作为脚本运行）

  import registration
  running register(<function f1 at 0x10063b1e0>)
  running register(<function f2 at 0x10063b268>)
  
  # 此时查看 registry 的值，得到的输出如下：
  registration.registry
  [<function f1 at 0x10063b1e0>, <function f2 at 0x10063b268>]
  1
  2
  3
  4
  5
  6
  7

闭包

闭包指延伸了作用域的函数，其中包含函数定义体中引用、但是不在定义体中定义的非全局变量。函数是不是匿名的没有关系，关键是它能访问定义体之外定义的非全局变量。

闭包是一种函数，它会保留定义函数时存在的自由变量的绑定，这样调用函数时，虽然定义作用域不可用了，但是仍能使用那些绑定。只有嵌套在其他函数中的函数才可能需要处理不在全局作用域中的外部变量。

闭包不仅在装饰器中有用，而且还是回调式异步编程和函数式编程风格的基础。

"""闭包
	series = []

    def averager(new_value):
        series.append(new_value)
        total = sum(series)
        return total / len(series)
"""
def make_averager():
    series = []

    def averager(new_value):
        series.append(new_value) # series是自由变量
        total = sum(series)
        return total / len(series)

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

"""
调用 Averager() 或make_averager() 得到一个可调用对象 avg，它会更新历史值，然后计算当前均值。
"""


# 计算移动平均值的类
class Averager():
    def __init__(self):
        self.series = []

    def __call__(self, new_value):
        self.series.append(new_value)
        total = sum(self.series)
        return total / len(self.series)


# avg = Averager()


# 计算移动平均值的高阶函数
def make_averager():
    series = []

    def averager(new_value):
        # 没有给 series 赋值，我们只是调用 series.append，并把它传给 sum 和 len。也就是说，我们利用了列表是可变的对象这一事实。
        series.append(new_value)
        total = sum(series)
        return total / len(series)

    return averager


avg = make_averager()
print(avg(10))
print(avg(11))
print(avg(12))
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
33
34
35
36

• 计算移动平均值的高阶函数，不保存所有历史值，但有缺陷

  """
  当 count 是数字或任何不可变类型时，count += 1 语句的作用其实与 count = count + 1 一样。因此，我们在 averager 的定义体中为 count 赋值了，这会把 count 变成局部变量。total 变量也受这个问题影响。
  
  对数字、字符串、元组等不可变类型来说，只能读取，不能更新。如果尝试重新绑定，例如 count = count + 1，其实会隐式创建局部变量 count。这样，count 就不是自由变量了，因此不会保存在闭包中。为了解决这个问题，Python 3 引入了 nonlocal 声明
  """
  def make_averager():
      count = 0
      total = 0
  
      def averager(new_value):
          count += 1  # 在 averager 的定义体中为 count 赋值了，这会把 count 变成局部变量
          total += new_value
          return total / count
  
      return averager
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

• nonlocal的作用

  把变量标记为自由变量，即使在函数中为变量赋予新值了，也会变成自由变量。如果为 nonlocal 声明的变量赋予新值，闭包中保存的绑定会更新。

# 计算移动平均值，不保存所有历史（使用 nonlocal 修正）
def make_averager():
 count = 0
 total = 0
 def averager(new_value):
   nonlocal count, total
   count += 1
   total += new_value
   return total / count
 return averager
1
2
3
4
5
6
7
8
9
10

• 应用于装饰器，也是回调式异步编程和函数式编程风格的基础

• 如果在函数中赋值时想让解释器把 b 当成全局变量，要使用 global 声明：

• 装饰器不修改被装饰的函数

  • 促销策略函数无需使用特殊的名称（即不用以 _promo 结尾）。
  • @promotion 装饰器突出了被装饰的函数的作用，还便于临时禁用某个促销策略：只需把装饰器注释掉。
  • 促销折扣策略可以在其他模块中定义，在系统中的任何地方都行，只要使用 @promotion 装饰即可。

from abc import ABC, abstractmethod
from collections import namedtuple

 Customer = namedtuple('Customer', 'name fidelity')


 class LineItem:

     def __init__(self, product, quantity, price):
         self.product = product
         self.quantity = quantity
         self.price = price

     def total(self):
         return self.price * self.quantity


 class Order:  # 上下文
     def __init__(self, customer, cart, promotion=None):
         self.customer = customer
         self.cart = list(cart)
         self.promotion = promotion

     def total(self):
         if not hasattr(self, '__total'):
             self.__total = sum(item.total() for item in self.cart)
         return self.__total

     def due(self):
         if self.promotion is None:
             discount = 0
         else:
             discount = self.promotion.discount(self)
         return self.total() - discount

     def __repr__(self):
         fmt = ''
         return fmt.format(self.total(), self.due())


 promos = []  # ➊ promos 列表起初是空的。


 def promotion(promo_func):  # ➋ promotion 把 promo_func 添加到 promos 列表中，然后原封不动地将其返回。
     promos.append(promo_func)
     return promo_func


 @promotion  # ➌ 被 @promotion 装饰的函数都会添加到 promos 列表中。
 def fidelity(order):
     """为积分为1000或以上的顾客提供5%折扣"""
     return order.total() * .05 if order.customer.fidelity >= 1000 else 0


 @promotion
 def bulk_item(order):
     """单个商品为20个或以上时提供10%折扣"""
     discount = 0
     for item in order.cart:
         if item.quantity >= 20:
             discount += item.total() * .1
     return discount


 @promotion
 def large_order(order):
     """订单中的不同商品达到10个或以上时提供7%折扣"""
     distinct_items = {item.product for item in order.cart}
     if len(distinct_items) >= 10:
         return order.total() * .07
     return 0


 def best_promo(order):  # ➍ best_promos 无需修改，因为它依赖 promos 列表。
     """选择可用的最佳折扣
     """
     return max(promo(order) for promo in promos)
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

• 装饰器会修改被装饰的函数(通常，它们会定义一个内部函数，然后将其返回，替换被装饰的函数。使用内部函数的代码几乎都要靠闭包才能正确运作。)

一个简单的装饰器，输出函数的运行时间

# 在每次调用被装饰的函数时计时，然后把经过的时间、传入的参数和调用的结果打印出来。
import time


def clock(func):
    def clocked(*args):  # ➊ 定义内部函数 clocked，它接受任意个定位参数。
        t0 = time.perf_counter()
        result = func(*args)  # ➋ 这行代码可用，是因为 clocked 的闭包中包含自由变量 func。
        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  # ➌ 返回内部函数，取代被装饰的函数。示例 7-16 演示了 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))

"""
**************************************** Calling snooze(.123)
[0.13714430s] snooze(0.123) -> None
**************************************** Calling factorial(6)
[0.00000200s] factorial(1) -> 1
[0.00008190s] factorial(2) -> 2
[0.00011430s] factorial(3) -> 6
[0.00013500s] factorial(4) -> 24
[0.00015500s] factorial(5) -> 120
[0.00017970s] factorial(6) -> 720
6! = 720
"""
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
33
34
35
36
37
38
39
40
41
42
43
44
45

@clock
def factorial(n):
    return 1 if n < 2 else n * factorial(n - 1)
# 等价于：
def factorial(n):
    return 1 if n < 2 else n * factorial(n - 1)

factorial = clock(factorial)
1
2
3
4
5
6
7
8

• factorial 会作为 func 参数传给 clock。然后， clock 函数会返回 clocked 函数，Python 解释器在背后会把 clocked 赋值给 factorial。其实，导入clockdeco_demo 模块后查看 factorial 的 _name_ 属性，会得到如下结果：

  clockdeco_demo.factorial.__name__
  # 'clocked'
  1
  2

• 所以，现在 factorial 保存的是 clocked 函数的引用。自此之后，每次调用 factorial(n)，执行的都是clocked(n)。clocked 大致做了下面几件事：

  • (1) 记录初始时间 t0。
  • (2) 调用原来的 factorial 函数，保存结果。
  • (3) 计算经过的时间。
  • (4) 格式化收集的数据，然后打印出来。
  • (5) 返回第 2 步保存的结果。

• 装饰器的典型行为：把被装饰的函数替换成新函数，二者接受相同的参数，而且（通常）返回被装饰的函数本该返回的值，同时还会做些额外操作。

• 上面实现的 clock 装饰器有几个缺点：不支持关键字参数，而且遮盖了被装饰函数的\ __name__ 和 __doc__ 属性。使用functools.wraps 装饰器把相关的属性从 func 复制到 clocked 中。此外，这个新版还能正确处理关键字参数。

  • functools.wraps装饰器把相关的属性从func复制到clocked中

    # 在每次调用被装饰的函数时计时，然后把经过的时间、传入的参数和调用的结果打印出来。
    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
    
    
    @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))
        print(factorial.__name__)
    
    """
    **************************************** Calling snooze(.123)
    [0.13714430s] snooze(0.123) -> None
    **************************************** Calling factorial(6)
    [0.00000200s] factorial(1) -> 1
    [0.00008190s] factorial(2) -> 2
    [0.00011430s] factorial(3) -> 6
    [0.00013500s] factorial(4) -> 24
    [0.00015500s] factorial(5) -> 120
    [0.00017970s] factorial(6) -> 720
    6! = 720
    factorial
    """
    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
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55

functools.lru_cache装饰器

• 使用functools.lru_cache做备忘，这是一项优化技术
• 它把耗时的函数的结果保存起来，避免传入相同的参数时重复计算。
• 。LRU 三个字母是“LeastRecently Used”的缩写，表明缓存不会无限制增长，一段时间不用的缓存条目会被扔掉。
• 除了优化递归算法之外，lru_cache 在从 Web 中获取信息的应用中也能发挥巨大作用。

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


# 生成第 n 个斐波纳契数，递归方式非常耗时
@clock
def fibon(n):
   if n < 2:
       return n
   return fibon(n - 2) + fibon(n - 1)

# 使用缓存实现，速度更快。
# 注意，必须像常规函数那样调用 lru_cache。这一行中有一对括号：@functools.lru_cache()。这么做的原因是，lru_cache 可以接受配置参数
@functools.lru_cache()
@clock  # 这里叠放了装饰器：@lru_cache() 应用到 @clock 返回的函数上。
def fibonacci(n):
   if n < 2:
       return n
   return fibonacci(n - 2) + fibonacci(n - 1)


if __name__ == '__main__':
   print(fibonacci(30))
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
33
34
35
36
37
38
39
40
41
42
43

• lru_cache 可以使用两个可选的参数来配置

  • maxsize 参数指定存储多少个调用的结果。缓存满了之后，旧的结果会被扔掉，腾出空间。为了得到最佳性能，maxsize 应该设为 2 的幂。
  • typed 参数如果设为 True，把不同参数类型得到的结果分开保存，即把通常认为相等的浮点数和整数参数（如 1 和 1.0）区分开。

  functools.lru_cache(maxsize=128, typed=False)
  1

• 因为 lru_cache 使用字典存储结果，而且键根据调用时传入的定位参数和关键字参数创建，所以被 lru_cache 装饰的函数，它的所有参数都必须是可散列的。

functools.singledispatch装饰器

• 可以把整体方案拆分成多个模块，甚至可以为你无法修改的类提供专门的函数。
• @singledispatch 装饰的普通函数会变成泛函数（generic function）：根据第一个参数的类型，以不同方式执行相同操作的一组函数。
• singledispatch 机制的一个显著特征是，你可以在系统的任何地方和任何模块中注册专门函数。如果后来在新的模块中定义了新的类型，可以轻松地添加一个新的专门函数来处理那个类型。此外，你还可以为不是自己编写的或者不能修改的类添加自定义函数。

"""
只要可能，注册的专门函数应该处理抽象基类（如 numbers.Integral和 abc.MutableSequence），不要处理具体实现（如 int 和list）。这样，代码支持的兼容类型更广泛。例如，Python 扩展可以子类化 numbers.Integral，使用固定的位数实现 int 类型。
"""
from functools import singledispatch
from collections import abc
import numbers
import html


@singledispatch  # ➊ @singledispatch 标记处理 object 类型的基函数。
def htmlize(obj):
    content = html.escape(repr(obj))
    return '
{}
'.format(content)


@htmlize.register(str)  # ➋ 各个专门函数使用 @«base_function».register(«type») 装饰。
def _(text):  # ➌ 专门函数的名称无关紧要；_ 是个不错的选择，简单明了。
    content = html.escape(text).replace('\n', '
\n')
    return '
{0}
'.format(content)


@htmlize.register(numbers.Integral)  # ➍ 为每个需要特殊处理的类型注册一个函数。numbers.Integral 是int 的虚拟超类。
def _(n):
    return '
{0} (0x{0:x})
'.format(n)


@htmlize.register(tuple)  # ➎ 可以叠放多个 register 装饰器，让同一个函数支持不同类型。
@htmlize.register(abc.MutableSequence)
def _(seq):
    inner = '