这是学习《流畅的Python》的第二天，今天希望把这一章看完，之所以跳过第二部分，是因为我对第三部分兴趣更多一些，之后再看第二部分吧。笔记不是对书的重复，只是把我接触到的任何不是特别熟悉的东西记录下来，会有点散乱。

一等对象 Page 118

在Python中，函数是一等对象。编程语言理论家把“一等对象”定义为满足下述条件的程序实体：  - 在运行时创建  - 能赋值给变量或数据结构中的元素  - 能作为参数传给函数  - 能作为函数的返回结果

高阶函数 Page 120

接受函数为参数，或者把函数作为结果返回的函数是高阶函数(higher-order function)。例如map函数、sorted函数。  sorted函数的可选的参数key用于提供一个单参数函数。这个单参数函数的返回值是一个可比较大小的对象。

def reverse(word):

return word[::-1]

fruits = ['strawberry', 'fig', 'apple', 'cherry', 'raspberry']

sorted(fruits, key=reverse)

map、filter、和reduce的现代替代品 Page 121

map和filter

函数式语言通常会提供map、filter和reduce三个高阶函数(有时使用不同的名称)。在Python3中，map和filter还是内置函数，但是由于引入了列表推导和生成器表达式，它们变得没那么重要了。列表推导或生成器表达式具有map和filter两个函数的功能，而且更易于阅读。

>>> def fact(n):

return 1 if n < 2 else n * fact(n-1)

# 这里的语法：(条件为真的值) if (条件) else (条件为假的值)

>>> list(map(fact, range(6)))

[1, 1, 2, 6, 24, 120]

>>> [fact(n) for n in range(6)]

[1, 1, 2, 6, 24, 120]

>>> list(map(fact, filter(lambda n: n % 2, range(6))))

[1, 6, 120]

>>> [fact(n) for n in range(6) if n % 2]

[1, 6, 120]

>>> # 这里for if连用，效果应该是if嵌套在for里面，且两者顺序不能颠倒。

这个新点子真的很棒，起初学map和filter的时候不太好懂，现在知道，用列表推导或生成器表达式就可以完成map和filter的所有功能了，而且还非常的直观。  下面总结一下Python中的各种推导式(comprehensions)，也叫解析式。推导式是可以从一个数据序列构建另一个新的数据序列的结构体。它包括三种：列表、集合、字典推导式。  生成器表达式

(f1(i) for i in obj if f2(i))

列表推导式

[f1(i) for i in obj if f2(i)]

集合推导式

{f1(i) for i in obj if f2(i)}

字典推导式

{f1(k, v): f2(k, v) for k, v in obj if f3(k, v)}

注意：以上只是说明了推导式(或者表达式)的格式，if语句可以没有(如果不需要筛选的话)，for可以是任意形式的迭代。

reduce

在Python3中，reduce不再是内置函数，放到functools模块里了。这个函数最常用于求和，但求和最好使用内置的sum函数。在可读性和性能方面，这是一项重大改善。

>>> from functools import reduce

>>> from operator import add

>>> reduce(add, range(100))

4950

>>> sum(range(100))

4950

sum和reduce的通用思想是把某个操作连续应用到序列的元素上，累计之前的结果，把一系列值归约成一个值。all和any也是内置的规约函数。

all(iterable)

# 如果iterable中存在元素为假，才为假。否则为真。我之所以这么说是因为all([])为True

any(iterable)

# 如果iterable中存在元素为真，才为真。否则为假。我之所以这么说是因为any([])为False

5.3 匿名函数 Page 122

lambda关键字在Python表达式内创建匿名函数。Python简单的语法限制了lambda函数的定义体只能使用纯表达式。换句话说，lambda函数的定义体中不能赋值，也不能使用try和while等Python语句。  在参数列表中最适合使用匿名函数。

>>> fruits = ['strawberry', 'fig', 'apple', 'cherry', 'raspberry', 'bananaa']

>>> sorted(fruits, key=lambda word: word[::-1])

['bananaa', 'apple', 'fig', 'raspberry', 'strawberry', 'cherry']

lambda语法

lambda 参数: 返回值

其中参数允许是单个或多个位置参数，逗号分开，也可以不提供参数。  lambda句法只是语法糖：与def语句一样，lambda表达式会创建函数对象。

5.4 可调用对象 Page 122

除了用户定义的函数，调用运算符()还可以应用在其他对象上。callable()可以用来判断对象是否可以调用。Python数据模型文档列出了7种可调用对象。

用户定义的函数  使用def语句或lambda表达式创建内置函数  使用C语言(CPython)实现的函数，如len或time.strftime内置方法  使用C语言实现的方法，如dict.get方法  在类的定义体中定义的函数类  调用类时会运行类的__new__方法创建一个实例，然后运行__init__方法，初始化实例，最后把实例返回给调用方。因为Python中没有new运算符，所以调用类相当于调用函数。(通常，调用类会创建那个类的实例，不过覆盖__new__方法的话，也可能出现其他行为)类的实例  如果类定义了__call__方法，那么它的实例可以作为函数调用。生成器函数  使用yield关键字的函数或方法。调用生成器函数返回的是生成器对象。生成器函数在很多方面与其他可调用对象不同，生成器函数还可以作为协程。

shuffle Page 123

shuffle() 方法将序列的所有元素随机排序。原型：

def shuffle(self, x, random=None):

"""Shuffle list x in place, and return None.

Optional argument random is a 0-argument function returning a

random float in [0.0, 1.0); if it is the default None, the

standard random.random will be used.

"""

另外从源码可以看出，不仅是list，实现了__getitem__、__setitem__、__len__方法的对象都可以应用于shuffle方法。

>>> import random

>>> a = [1,2,3]

>>> random.shuffle(a)

>>> a

[3, 1, 2]

函数的属性 Page 125

>>> def x(): pass

>>> dir(x) # 通常的函数具有的属性

['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

>>> class A: pass

>>> sorted(set(dir(x)) - set(dir(A()))) # 函数专有的而用户定义的一般对象没有的属性

['__annotations__', '__call__', '__closure__', '__code__', '__defaults__', '__get__', '__globals__', '__kwdefaults__', '__name__', '__qualname__']

表5-1：用户定义的函数的属性

名称类型说明__annotations__dict参数和返回值的注解__call__method-wrapper实现()运算符；即可调用对象协议__closure__tuple函数闭包，即自由变量的绑定(通常是None)__code__code编译成字节码的函数元数据和函数定义体__defaults__tuple形式参数的默认值__kwdefaults__dict仅限关键字形式参数的默认值__get__method-wrapper实现只读描述符协议__globals__dict函数所在模块中的全局变量__name__str函数名称__qualname__str函数的限定名称，如Random.choice

关于__dict__  与用户定义的常规类一样，函数使用__dict__属性存储赋予它的用户属性。这相当于一种基本形式的注解。一般来说，为函数随意赋予属性不是很常见的做法，但是Django框架这么做了。参见“The Django admin site”文档中对short_description、boolean和allow_tags属性的说明。下面的示例，把short_description属性赋予一个方法，Django管理后台使用这个方法时，在记录列表中会出现指定的描述文本：

def upper_case_name(obj):

return ("%s %s" % (obj.first_name, obj.last_name)).upper()

upper_case_name.short_description = 'Customer name'

# 我：函数是function类的实例，在Python中，一般类的实例都可以动态绑定属性，我觉得这也算是动态绑定属性了吧

5.7 从定位参数到仅限关键字参数 Page 126

Python最好的特性之一是提供了极为灵活的参数处理机制，而且Python3进一步提供了仅限关键字参数(keyword-only argument)。与之密切相关的是，调用函数时使用*和**“展开”可迭代对象，映射到单个参数。  下面的示例展示了这些特性，tag函数用于生成HTML标签。

def tag(name, *content, cls=None, **attrs):

"""生成一个或多个HTML标签"""

if cls is not None:

attrs['class'] = cla

if attrs:

attr_str = ''.join(' %s="%s"' % (attr, value) for attr, value in sorted(attrs.items()))

else:

attr_str = ''

if content:

return '\n'.join('%s%s>' % (name, attr_str, c, name) for c in content)

else:

return '' % (name, attr_str)

tag的调用方式很多，如下：

>>> tag('br')

'
'

>>> tag('p', 'hello')

'

hello

'

>>> print(tag('p', 'hello', 'world'))

hello

world

>>> tag('p', 'hello', id=33)

'

hello

'

>>> print(tag('p', 'hello', 'world', cls='sidebar'))

hello

world

>>> tag(content='testing', name='img') # 注意这里的content！！！

'

>>> my_tag = {'name': 'img', 'title': 'Sunset Boulevard', 'src': 'sunset.jpg', 'cls': 'framed'}

>>> tag(**my_tag)

''

仅限关键字参数  仅限关键字参数是Python3新增的特性。上例中cls参数只能通过关键字参数指定，它一定不会捕获未命名的定位参数(因为定位参数都被*获取了)。定义函数时若想指定仅限关键字参数，要把他们放到前面有*的参数后面。如果不想支持数量不定的定位参数，但是想支持仅限关键字参数，在签名中放一个*，如下所示：

>>> def d(a, *, b):

return a, b

>>> f(1, b=2)

(1, 2)

注：这样子，位置参数有且只能有1个，即a。

5.8 获取关于参数的信息 Page 127

下面将介绍几个函数的属性：__defaults__、__code__.co_varnames、__code__.co_argcount

def clip(text, max_len=80):

"""在max_len前面或后面的第一个空格处截断文本"""

end = None

if len(text) > max_len:

space_before = text.rfind(' ', 0, max_len)

if space_before > 0:

end = space_before

else:

space_after = text.rfind(' ', max_len)

if space_after >= 0:

end = space_after

if end is None:

end = len(text)

return text[:end].rstrip()

下面查看这个函数那些属性的值：

>>> clip.__defaults__

(80,)

>>> clip.__code__ # 我：这里应该是64位操作系统虚拟地址了，应该是函数结构体的位置吧(最近在学操作系统)

>>> clip.__code__.co_argcount

2

>>> clip.__code__.co_varnames

('text', 'max_len', 'end', 'space_before', 'space_after')

可以看出，这种组织信息的方式并不是最便利的。参数名称在__code__.co_varnames中，不过里面还有函数定义体中创建的局部变量。因此参数名称是前N个字符串，N的值由__code__.co_argcount确定。顺便说一下，这里不包含前缀为*或**的变长参数。参数的默认值只能通过他们在__defaults__元祖中的位置确定，因此要从后向前扫描才能把参数和默认值对应起来。在这个示例中clip函数有两个参数，text和max_len，其中一个有默认值，即80，因此它必然属于最后一个参数，即max_len。这有违常理。  幸好，我们有更好的方式——使用inspect模块。

>>> from inspect import signature

>>> sig = signature(clip)

>>> sig

>>> str(sig)

'(text, max_len=80)'

>>> for name, param in sig.parameters.items():

print(param.kind, ':', name, '=', param.default)

POSITIONAL_OR_KEYWORD : text =

POSITIONAL_OR_KEYWORD : max_len = 80

这样就好多了。inspect.signature函数返回一个inspect.Signature对象，它有一个parameters属性，这是一个有序映射，把参数名和inspect.Parameter对象对应起来。各个Parameter属性也有自己的属性，例如name、default和kind。特殊的inspect._empty值表示没有默认值，考虑到None是有效的默认值(也经常这么做)，而且这么做是合理的。  kind属性的值是_ParameterKind类中的5个值之一，列举如下：

POSITIONAL_OR_KEYWORD  可以通过定位参数和关键字参数传入的形参(多数Python函数的参数属于此类)VAR_POSITIONAL  定位参数元祖。VAR_KEYWORD  关键字参数字典。KEYWORD_ONLY  仅限关键字参数(Python3新增)。POSITIONAL_ONLY  仅限定位参数；目前，Python声明函数的句法不支持，但是有些使用C语言实现且不接受关键字参数的函数(如divmod)支持。  除了 name、default和kind，inspect_Parameter对象还有一个annotation(注解)属性，它的值通常是inspect._empty，但是可能包含Python3新的注解句法提供的函数签名元数据。  inspect.Signature对象有个bind方法，它可以把任意个参数绑定到签名中的形参上，所用的规则与实参到形参的匹配方式一样。框架可以使用这个方法在真正调用函数前验证参数。

>>> import inspect

>>> sig = inspect.signature(tag)

>>> my_tag = {'name': 'img', 'title': 'Sunset Boulevard', 'src': 'sunset.jpg', 'cls': 'framed'}

>>> bound_args = sig.bind(**my_tag)

>>> for name, value in bound_args.arguments.items():

print(name, '=', value)

name = img

cls = framed

attrs = {'title': 'Sunset Boulevard', 'src': 'sunset.jpg}

>>> del my_tag['name']

>>> bound_args = sig.bind(**my_tag)

Traceback (most recent call last):

...

TypeError: 'name' parameter lacking default value

这个示例在inspect模块的帮助下，展示了Python数据模型把实参绑定给函数调用中的形参的机制，这与解释器使用的机制相同。

5.9 函数注解 Page 131

def clip(text:str, max_len:'int > 0'=80) -> str:

pass

函数声明中的各个参数可以在:之后增加注解表达式。如果参数有默认值，注解放在参数名和=之间。如果想注解返回值，在)和函数声明末尾的:之间添加->和一个表达式。那个表达式可以是任何类型。注解中最常用的类型是类(如str或int)和字符串(如'int > 0')。  注解作为元数据存储在函数的__annotations__属性(一个字典)中，其中return键保存的是返回值注解。Python对于注解什么操作都不做，不检查，不强制，不验证。但是注解可以供IDE、框架和装饰器等工具使用。目前标准库中唯有inspect.signature()函数知道怎么提取注解。

>>> from inspect import signature

>>> sig = signature(clip)

>>> sig.return_annotation

>>> for param in sig.parameters.value():

note = repr(param.annotation).ljust(13)

print(note, ':', param.name, '=', param.default)

: text =

'int > 0'     : max_len = 80

signature函数返回一个Signature对象，它有一个return_annotation属性和一个parameters属性，后者是一个字典，把参数名映射到Parameter对象上。每个Parameter对象自己也有annotation属性。

5.10.1 operator模块 Page 132

>>> [name for name in dir(operator) if not name.startswith('_')]

['abs', 'add', 'and_', 'attrgetter', 'concat', 'contains', 'countOf', 'delitem', 'eq', 'floordiv', 'ge', 'getitem', 'gt', 'iadd', 'iand', 'iconcat', 'ifloordiv', 'ilshift', 'imatmul', 'imod', 'imul', 'index', 'indexOf', 'inv', 'invert', 'ior', 'ipow', 'irshift', 'is_', 'is_not', 'isub', 'itemgetter', 'itruediv', 'ixor', 'le', 'length_hint', 'lshift', 'lt', 'matmul', 'methodcaller', 'mod', 'mul', 'ne', 'neg', 'not_', 'or_', 'pos', 'pow', 'rshift', 'setitem', 'sub', 'truediv', 'truth', 'xor']

这54个名称中大部分的作用不言而喻。以i开头、后面是另一个运算符的那些名称(如iadd、iand等)，对应的是增量赋值运算符(如+=、&=等)。如果第一个参数是可变的，那么这些运算符函数会修改它；否则，作用与不带i的函数一样，直接返回运算结果。  利用reduce和operator.mul计算阶乘

from functools import redece

from operator import mul

def fact(n):

return reduce(mul, range(1, n+1))

这样可以避免编写lambda a, b: a*b这种平凡的匿名函数。  利用operator.itemgetter排序一个元祖列表

>>> metro_data = [

('Tokyo', 'JP', 36.933, (35.6, 139.6)),

('Delhi NCR', 'IN', 21.935, (28.6, 77.2)),

('Mexico City', 'MX', 20.142, (19.4, -99.1)),

('New York-Newark', 'US', 20.104, (40.8, -74.0)),

('Sao Paulo', 'BR', 19.649, (-23.5, -46.6)),

]

>>> from operator import itemgetter

>>> for city in sorted(metro_data, key=itemgetter(2)): # 利用元祖第3个元素排序，它是个浮点数

print(city)

('Sao Paulo', 'BR', 19.649, (-23.5, -46.6))

('New York-Newark', 'US', 20.104, (40.8, -74.0))

('Mexico City', 'MX', 20.142, (19.4, -99.1))

('Delhi NCR', 'IN', 21.935, (28.6, 77.2))

('Tokyo', 'JP', 36.933, (35.6, 139.6))

如果把多个参数传给itemgetter，它构建的函数会返回提取的值构成的元祖：(当然也可以作为key排序)

>>> 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')

itemgetter 使用[]运算符，因此它不仅支持序列，还支持映射和任何实现__getitem__方法的类。  attrgetter  attrgetter与itemgetter作用类似，它创建的函数根据名称提取对象的属性。如果把多个属性名传给attrgetter，它也会返回提取的值构成的元祖。此外，如果参数名中包含.(点号)，attrgetter会深入嵌套对象，获取指定的属性。  下面的示例构建了一个嵌套结构，展示了attrgetter如何嵌套获取对象属性。它按照城市的纬度排序，并输出城市名和纬度。

>>> from collections import namedtuple

>>> LatLong = namedtuple('LatLong', 'lat long')

>>> Metropolis = namedtuple('Metropolis', 'name cc pop coord')

>>> metro_data = [

('Tokyo', 'JP', 36.933, (35.6, 139.6)),

('Delhi NCR', 'IN', 21.935, (28.6, 77.2)),

('Mexico City', 'MX', 20.142, (19.4, -99.1)),

('New York-Newark', 'US', 20.104, (40.8, -74.0)),

('Sao Paulo', 'BR', 19.649, (-23.5, -46.6)),

]

>>> metro_areas = [Metropolis(name, cc, pop, LatLong(lat, long)) for name, cc, pop, (lat, long) in metro_data]

>>> metro_areas[0].coord.lat

35.6

>>> from operator import attrgetter

>>> name_lat = attrgetter('name', 'coord.lat')

>>> for city in sorted(metro_areas, key=attrgetter('coord.lat')):

print(name_lat(city))

('Sao Paulo', -23.5)

('Mexico City', 19.4)

('Delhi NCR', 28.6)

('Tokyo', 35.6)

('New York-Newark', 40.8)

methodcaller

>>> from operator import methodcaller

>>> s = 'The time has come'

>>> upcase = methodcaller('upper')

>>> upcase(s)

'THE TIME HAS COME'

>>> hiphenate = methodcaller('replace', ' ', '-')

>>> hiphenate(s)

'The-time-has-come'

>>> str.upper(s)

'THE TIME HAS COME'

这个示例展示了methodcaller的用法。methodcaller还可以冻结某些参数，也就是部分应用(partial application)，这与functools.partial函数的作用类似。

5.10.2 使用functools.partial冻结参数 Page 135

functools模块提供了一些列高阶函数，其中最为人熟知的或许是reduce。余下的函数中，最有用的是partial及其变体，partialmethod。  functools.partial这个高阶函数用于部分应用一个函数。部分应用指，基于一个函数创建一个新的可调用对象，把原函数的某些参数固定。使用这个函数可以把接收一个或多个参数的函数改编成需要回调的API，这样参数更少。

>>> from operator import mul

>>> from functools import partial

>>> triple = partial(mul, 3) # 把第一个定位参数定位3

>>> triple(7)

21

>>> [triple(i) for i in range(1, 10)]

[3, 6, 9, 12, 15, 18, 21, 24, 27]

partial的第一个参数是一个可调用对象，后面跟着任意个要绑定的定位参数和关键字参数。  functools.partialmethod函数(Python3.4新增)的作用与partial一样，不过是用于处理方法的。  functools模块中的lru_cache函数令人印象深刻，它会做备忘(memorization)，这是一种自动优化措施，它会存储耗时的函数调用结果，避免重新计算。第7章将会介绍它，以及旨在用作装饰器的其他高阶函数：singledispatch和wraps。