Python学习之路24-一等函数

可以看出，这种信息的组织方式并不方便：

参数名在__code__.co_varnames中，它同时还存储了函数定义体中的局部变量，因此，只有前__code__.co_argcount个元素是参数名（不包含前缀为*何**的的变长参数）；

如果想将参数名和默认值对应上，只能从后向前扫描__default__属性，比如上例中关键字参数b的默认值10。

不过，我们并不是第一个发现这种方式很不方便。已经有人为我们造好了轮子。

>>> from mytest import func
>>> from inspect import signature
>>> sig = signature(func) # 返回一个inspect.Signature对象（签名对象）
>>> sig

>>> str(sig)
"(a, b=10)"
>>> for name, param in sig.parameters.items():
...     print(param.kind, ":", name, "=",param.default) 
...
POSITIONAL_OR_KEYWORD : a =  # 表示没有默认值
POSITIONAL_OR_KEYWORD : b = 10

inspect.Signature对象有一个属性parameters，该属性是个有序映射，把参数名和inspect.Parameter对象对应起来。inspect.Parameter也有自己的属性，如：

name：参数的名称；

default：参数的默认值；

kind：参数的类型，有5种，POSITIONAL_OR_KEYWORD，VAR_POSITIONAL（任意数量参数，以一个*号开头的那种参数），VAR_KEYWORD（任意数量的关键字参数，以**开头的那种参数），KEYWORD_ONLY（命名关键字参数）和POSITIONAL_ONLY（Python句法不支持该类型）

annotation和return_annotation：参数和返回值的注解，后面会讲到。

inspect.Signature对象有个bind方法，它可把任意个参数绑定到Singature中的形参上，框架可使用这个方法在真正调用函数前验证参数是否正确。比如你自己写的框架中的某函数A自动获取用户输入的参数，并根据这些参数调用函数B，但在调用B之前，你想检测下这些参数是否符合函数B对形参的要求，此时你就有可能用到这个bind方法，看能不能将这些参数绑定到函数B上，如果能，则可认为能够根据这些参数调用函数B：

>>> from mytest import func
>>> from inspect import signature
>>> sig = signature(func)
>>> my_tag = {"a":10, "b":20}
>>> bound_args = sig.bind(**my_tag)
>>> bound_args

>>> for name, value in bound_args.arguments.items():
...    print(name, "=", value)
a = 10
b = 20

>>> del my_tag["a"]
>>> bound_args = sig.bind(**my_tag)
Traceback (most recent call last):
TypeError: missing a required argument: "a"

Python3提供了一种句法，用于为函数声明中的参数和返回值附加元数据。如下：

# 未加注解
def func(a, b=10):
    return a + b
# 添加注解
def func(a: int, b: "int > 0" = 10) -> int:
    return a + b

各个参数可以在冒号后面增加注解表达式，如果有默认值，注解放在冒号和等号之间。上述-> int是对返回值添加注解的形式。

这些注解都存放在函数的__annotations__属性中，它是一个字典：

print(func.__annotations__)

# 结果
# "return"表示返回值
{"a": , "b": "int > 0", "return": }

Python只是将注解存储在函数的__annotations__属性中，除此之外，再无任何操作。换句话说，这些注解对Python解释器来说没有意义。而这些注解的真正用途是提供给IDE、框架和装饰器等工具使用，比如Mypy静态类型检测工具，它就会根据你写的这些注解来检测传入的参数的类型是否符合要求。

inspect模块可以获取这些注解。inspect.Signature有个一个return_annotation属性，它保存返回值的注解；inspect.Parameter对象中的annotation属性保存了参数的注解。

函数内省的内容到此结束。后面将介绍标准库中为函数式编程提供支持的常用包。

Python并不是一个函数式编程语言，但通过operator和functools等包的支持，也可以写出函数式风格的代码。

在函数式编程中，经常需要把算术运算符当做函数使用，比如非递归求阶乘，实现如下：

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

operator模块为多个算术运算符提供了对应的函数。使用算术运算符函数可将上述代码改写如下：

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

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

以下代码展示了itemgetter的常见用途：

from operator import itemgetter

test_data = [
    ("A", 1, "Alpha"),
    ("B", 3, "Beta"),
    ("C", 2, "Coco"),
]
# 相当于 lambda fields: fields[1]
for temp in sorted(test_data, key=itemgetter(1)):
    print(temp)

# 传入多个参数时，它构建的函数返回下标对应的值构成的元组
part_tuple = itemgetter(1, 0)
for temp in test_data:
    print(part_tuple(temp))
    
# 结果：
("A", 1, "Alpha")
("C", 2, "Coco")
("B", 3, "Beta")
(1, "A")
(3, "B")
(2, "C")

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

attrgetter和itemgetter作用类似，它创建的函数根据名称提取对象的属性。如果传入多个属性名，它也会返回属性名对应的值构成的元组。这里要展示的是，如果参数名中包含句点.，attrgetter会深入嵌套对象，获取指定的属性：

from collections import namedtuple
from operator import 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)),
]

LatLong = namedtuple("LatLong", "lat long")
Metropolis = namedtuple("Metropolis", "name, cc, pop, coord")
metro_areas = [Metropolis(name, cc, pop, LatLong(lat, long)) for
               name, cc, pop, (lat, long) in metro_data]
# 返回新的元组，获取name属性和嵌套的coord.lat属性
name_lat = attrgetter("name", "coord.lat")   
for city in sorted(metro_areas, key=attrgetter("coord.lat")): # 嵌套
    print(name_lat(city))

# 结果：
("Mexico City", 19.433333)
("Delhi NCR", 28.613889)
("Tokyo", 35.689722)

从名字也可看出，它创建的函数会在对象上调用参数指定的方法（注意是方法，而不是函数）。

>>> from operator import methodcaller
>>> s = "The time has come"
>>> upcase = methodcaller("upper")
>>> upcase(s)  # 相当于s.upper()
"THE TIME HAS COME"
>>> hiphenate = methodcaller("replace"," ","-")
>>> hiphenate(s)  # 相当于s.replace(" ", "-")
"The-time-has-come"

从hiphenate这个例子可以看出，methodcaller还可以冻结某些参数，即部分应用（partial application），这与functools.partial函数的作用类似。

functool模块提供了一系列高阶函数，reduce函数相信大家已经很熟悉了，本节主要介绍其中两个很有用的函数partial和它的变体partialmethod。

functools.partial用到了一个“闭包”的概念，这个概念的详细内容下一篇再介绍。使用这个函数可以把接收一个或多个参数的函数改编成需要回调的API，这样参数更少。

>>> from operator import mul
>>> from functools import partial
>>> triple = partial(mul, 3)
>>> triple(7)
21
>>> list(map(triple, range(1,10))) # 这里无法直接使用mul函数
[3, 6, 9, 12, 15, 18, 21, 24, 27]
>>> triple.func  # 访问原函数

>>> triple.args # 访问固定参数
(3,)
>>> triple.keywords  # 访问关键字参数
{}

functools.partialmethod函数的作用于partial一样，只不过partialmethod用于方法，partial用于函数。

补充：回调函数(callback function)可以简单理解为，当一个函数X被传递给函数A时，函数X就被称为回调函数，函数A调用函数X的过程叫做回调。

本篇首先介绍了函数，包括函数与对象的关系，高阶函数和匿名函数，重点是函数就是对象；随后介绍了函数和可调用对象的关系，以及函数的内省；最后，我们介绍了关于函数式编程的概念以及与之相关的两个重要模块。

迎大家关注我的微信公众号"代码港" & 个人网站 www.vpointer.net ~