在 Python 中，函数是一等对象。编程语言理论家把“一等对象”定义为满
足下述条件的程序实体：
-
在运行时创建
-
能赋值给变量或数据结构中的元素
-
能作为参数传给函数
-
能作为函数的返回结果
把函数视作对象
Python 函数是对象。这里我们创建了一个函数，然后调用它，读取它的 __doc__ 属性，并且确定函数对象本身是 function 类的实例。
1 #创建一个函数，只有函数在调用的时候才会运行 2 def factorial(n): 3 '''returns n!''' 4 return 1 if n < 2 else n * factorial(n-1) 5 6 #factorial(42)是函数function的实例 7 print(factorial(42)) 8 print(type(factorial)) 9 10 #函数众多属性中的其中一个~ 11 print(factorial.__doc__)
以上代码执行的结果为：
1405006117752879898543142606244511569936384000000000 <class 'function'> returns n!
展示了函数对象的“一等”本性。我们可以把 factorial 函数赋值给变量 fact，然后通过变量名调用。我们还能把它作为参数传给map 函数。map 函数返回一个可迭代对象，里面的元素是把第一个参数(一个函数）应用到第二个参数（一个可迭代对象，这里是range(11)）中各个元素上得到的结果。
? 通过别的名称使用函数，再把函数作为参数传递
1 #创建一个函数，只有函数在调用的时候才会运行 2 def factorial(n): 3 '''returns n!''' 4 return 1 if n < 2 else n * factorial(n-1) 5 6 fact = factorial 7 print(fact) 8 9 map_fact = map(factorial, range(11)) 10 print('map fact:', map_fact) 11 print(list(map_fact))
以上代码执行的结果为：
<function factorial at 0x1007a2e18> map fact: <map object at 0x101c452e8> [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
高阶函数
接受函数为参数，或者把函数作为结果返回的函数是高阶函数（higherorderfunction）。map 函数就是一例。此外，内函数 sorted 也是：可选的 key 参数用于提供一个函数，它会应用到各个元素上进行排序。
举个? 根据单词的长度排序一个列表
>>> fruits = ['strawberry', 'fig', 'apple', 'cherry', 'raspberry', 'banana'] >>> sorted_fruits = sorted(fruits, key=len) >>> print(sorted_fruits) ['fig', 'apple', 'cherry', 'banana', 'raspberry', 'strawberry']
根据反向拼写给一个单词列表排序
>>> def reverse(word): ... return word[::-1] ... >>> reverse('testing') 'gnitset' >>> reverse(fruits) ['banana', 'raspberry', 'cherry', 'apple', 'fig', 'strawberry'] >>> fruits ['strawberry', 'fig', 'apple', 'cherry', 'raspberry', 'banana'] >>> sorted(fruits, key=reverse) ['banana', 'apple', 'fig', 'raspberry', 'strawberry', 'cherry']
函数式语言通常会提供 map、filter 和 reduce 三个高阶函数（有时使用不同的名称）。在 Python 3 中，map 和 filter 还是内置函数，但是由于引入了列表推导和生成器表达式，它们变得没那么重要了。列表推导或生成器表达式具有 map 和 filter 两个函数的功能，而且更易于阅读，如示例:
>>> list(map(lambda x:x*x, range(6))) [0, 1, 4, 9, 16, 25] >>> [x*x for x in range(6)] [0, 1, 4, 9, 16, 25] >>> list(map(lambda x:x*x, filter(lambda x:x>5, range(10)))) [36, 49, 64, 81] >>> [x*x for x in range(10) if x >5] [36, 49, 64, 81]
使用 reduce 和 sum 计算 0~99 之和
>>> from functools import reduce >>> reduce(lambda x,y: x+y, range(100)) 4950 >>> sum(range(100)) 4950
all 和 any 也是内置的归约函数
all(iterable)
如果 iterable 的每个元素都是真值，返回 True；all([]) 返回True
any(iterable)
只要 iterable 中有元素是真值，就返回 True；any([]) 返回False
匿名函数
lambda 关键字在 Python 表达式内创建匿名函数。然而，Python 简单的句法限制了 lambda 函数的定义体只能使用纯表达式。换句话说，lambda 函数的定义体中不能赋值，也不能使用 while和 try 等 Python 语句。
举个? 使用 lambda 表达式反转拼写，然后依此给单词列表排序
>>> fruits = ['strawberry', 'fig', 'apple', 'cherry', 'raspberry', 'banana'] >>> sorted(fruits, key=lambda word: word[::-1]) ['banana', 'apple', 'fig', 'raspberry', 'strawberry', 'cherry']
如果使用 lambda 表达式导致一段代码难以理解，Fredrik Lundh 建议像下面这样重构
-
编写注释 ，说明lambda表达式的作用
-
研究一会儿注释，并找出一个名称来概括注释
-
把lambda表达式转成def语句，使用那个名称来定义函数
-
删除注释
可调用对象
除了用户定义的函数，调用运算符（即 ()）还可以应用到其他对象上。如果想判断对象能否调用，可以使用内置的 callable() 函数。Python 数据模型文档列出了 7 种可调用对象。
用户定义的函数
使用 def 语句或 lambda 表达式创建
内置函数
使用 C 语言（CPython）实现的函数，如 len 或 time.strftime
内置方法
使用 C 语言实现的方法，如 dict.get
方法
在类的定义体中定义的函数
类
调用类时会运行类的 __new__ 方法创建一个实例，然后运行__init__ 方法，初始化实例，最后把实例返回给调用方。因为 Python没有 new 运算符，所以调用类相当于调用函数。（通常，调用类会创建那个类的实例，不过覆盖 __new__ 方法的话，也可能出现其他行为
类的实例
如果类定义了 __call__ 方法，那么它的实例可以作为函数调用
生成器函数
使用 yield 关键字的函数或方法。调用生成器函数返回的是生成器对象
举个? 判断对象是否可以被调用
>>> abs, str, 123 (<built-in function abs>, <class 'str'>, 123) >>> [callable(s) for s in [abs, str, 123]] [True, True, False]
用户定义的可调用类型
不仅 Python 函数是真正的对象，任何 Python 对象都可以表现得像函数。为此，只需实现实例方法 __call__。
1 import random 2 3 4 class BingoCage: 5 6 def __init__(self, item): #接收一个可迭代的对象，转成列表，以防止意外 7 self._item = list(item) 8 random.shuffle(self._item) 9 10 def pick(self): 11 try: 12 return self._item.pop() #每调用一次会会从删除一个值 13 except IndexError: #列表中没有值会报索引错误 14 raise LookupError('pick from empty BingoCage') 15 16 def __call__(self): 17 return self.pick() #支持函数作为实例调用 18 19 20 21 bingo = BingoCage(range(3)) 22 print(bingo.pick()) #普通的调用 23 print(bingo()) #函数作为实例调用 24 print(callable(bingo))
以上代码执行的结果为：
2
0
True
实现 __call__ 方法的类是创建函数类对象的简便方式，此时必须在内部维护一个状态，让它在调用之间可用，例如 BingoCage 中的剩余元素。装饰器就是这样。装饰器必须是函数，而且有时要在多次调用之间“记住”某些事 [ 例如备忘（memoization），即缓存消耗大的计算结果，供后面使用 ]。
函数内省
除了 __doc__，函数对象还有很多属性。使用 dir 函数可以探知factorial 具有下述属性：
>>> def factorial(): ... pass ... >>> dir(factorial) ['__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__']
下面重点说明函数专有而用户定义的一般对象没有的属性。计算两个属性集合的差集便能得到函数专有属性列表
1 class C: pass #声明一个类 2 obj = C() #实例化类 3 4 def func(): pass #声明一个函数对象 5 6 print(sorted(set(dir(func)) - set(dir(obj)))) #打印函数和类实例化类对象中的差集
以上代码执行得结果为：
['__annotations__', '__call__', '__closure__', '__code__', '__defaults__',
'__get__', '__globals__', '__kwdefaults__', '__name__', '__qualname__']
用户定义的函数的属性
| 名称 | 类型 | 说明 |
| __annotations__ | dict | 参数返回值和的注释信息 |
| __call__ | method-wrapper | 实现()运算符；即可调用对象协议 |
| __closure__ | tuple | 函数闭包，即自有变量的绑定(通常是None) |
| __code__ | code | 编译成字节码的函数元数据和函数定义体 |
| __defaults__ | tuple | 形式参数的默认值 |
| __get__ | method-wrapper | 实现只读描述符协议 |
| __globals__ | dict | 函数所在模块中的全局变量 |
| __kwdefaults__ | dict | 仅限关键字形式参数的默认值 |
| __name__ | str | 函数名称 |
| __qualname__ | str | 函数的限定名称，如Random.choice |
从定位参数到仅限关键字参数
Python 最好的特性之一是提供了极为灵活的参数处理机制，而且 Python3 进一步提供了仅限关键字参数（keyword-only argument）。与之密切相关的是，调用函数时使用 * 和 **“展开”可迭代对象，映射到单个参数。
tag 函数用于生成 HTML 标签；使用名为 cls 的关键字参数传入“class”属性，这是一种变通方法，因为“ class”是 Python的关键字
1 def tag(name, *content, cls=None, **attrs): 2 if cls is not None: 3 attrs['class'] = cls 4 if attrs: 5 attr_str = ''.join(' %s="%s"' % (attr, value) 6 for attr, value in sorted(attrs.items())) 7 else: 8 attr_str = '' 9 10 if content: 11 return ' '.join('<%s%s>%s</%s>' % 12 (name, attr_str, c, name) for c in content) 13 else: 14 return '<%s%s />' % (name, attr_str) 15 16 print(tag('br')) 17 18 print('-'*20) 19 print('位置参数：\n', tag('p', 'hello')) 20 21 print('-'*20) 22 print('位置参数，通过函数*接收到一个元祖：\n', tag('p', 'hello', 'world')) 23 24 print('-'*20) 25 print('位置参数和关键字参数：\n', tag('p', 'hello', id=33)) 26 27 print('-'*20) 28 print('cls的关键字参数传参数：\n', tag('p', 'hello', 'world', cls='sidebar')) 29 30 print('-'*20) 31 print('两个关键字参数，content传递给函数中的content,name传递给name：\n', tag(content='testing', name="img")) 32 33 print('-'*20) 34 #在 my_tag 前面加上 **，字典中的所有元素作为单个参数传入，同名键会绑定到对应的具名参数上，余下的则被 **attrs 捕获 35 my_tag = {'name': 'img', 'title': 'Sunset Boulevard', 'src': 'sunset.jpg', 'cls': 'framed'} 36 print('传递一个字典进去，通过**拆分成关键词参数：\n', my_tag)
以上代码执行的结果为：
<br /> -------------------- 位置参数： <p>hello</p> -------------------- 位置参数，通过函数*接收到一个元祖： <p>hello</p> <p>world</p> -------------------- 位置参数和关键字参数： <p id="33">hello</p> -------------------- cls的关键字参数传参数： <p class="sidebar">hello</p> <p class="sidebar">world</p> -------------------- 两个关键字参数，content传递给函数中的content,name传递给name： <img content="testing" /> -------------------- 传递一个字典进去，通过**拆分成关键词参数： {'name': 'img', 'title': 'Sunset Boulevard', 'src': 'sunset.jpg', 'cls': 'framed'}
注意：
仅限关键字参数是 Python 3 新增的特性。在示例 ，cls 参数只能通过关键字参数指定，它一定不会捕获未命名的定位参数。定义函数时若想指定仅限关键字参数，要把它们放到前面有 * 的参数后面。如果不想支持数量不定的定位参数，但是想支持仅限关键字参数，在签名中放一个 *，如下所示：
>>> def f(a, *, b): ... return a, b ... >>> f(1, b=2) (1, 2)
注意，仅限关键字参数不一定要有默认值，可以像上例中 b 那样，强制必须传入实参
函数注解
Python 3 提供了一种句法，用于为函数声明中的参数和返回值附加元数据。
? 有注释的clip函数
1 def clip(text:str, max_len:'int > 0'=80) -> str: #函数中给每个参数都设置了传递的参数的信息，包括函数最终的返回结果的类型 2 """ 3 :param text: 4 :param max_len:前面或者后面的第一个空格处截取文本 5 :return: 6 """ 7 end = None 8 if len(text) > max_len: #获取传入字符串的长度并与传递的要查找空格最大长度做判断 9 space_before = text.rfind(' ', 0, max_len) #从开头查找到max_len的长度截止，如果能找到则返回空格在字符串中的位置，否则则返回-1 10 if space_before >= 0: 11 end = space_before #查找空格的索引位置等于找到最终函数的切片的最终位置 12 else: 13 space_after = text.rfind(' ', max_len) #如果从开头没有找到空格，则从max_len的长度开始往后继续查找 14 if space_after >= 0: 15 end = space_after 16 17 if end is None: 18 end = len(text) 19 20 return text[:end].rsplit() #返回从查找截止到空格位置的所有字符串 21 22 23 s = 'testing testing' 24 result = clip(s, 10) 25 print(result)
函数声明中的各个参数可以在 : 之后增加注解表达式。如果参数有默认值，注解放在参数名和 = 号之间。如果想注解返回值，在 ) 和函数声明末尾的 : 之间添加 -> 和一个表达式。那个表达式可以是任何类型。注解中最常用的类型是类（如 str 或 int）和字符串（如 'int >0'）
注解不会做任何处理，只是存储在函数的 __annotations__ 属性（一个字典）中：
>>> from clip_annot import clip >>> clip.__annotations__ {'text': <class 'str'>, 'max_len': 'int > 0', 'return': <class 'str'>}
'return' 键保存的是返回值注解，即示例中函数声明里以 -> 标记的部分。
Python 对注解所做的唯一的事情是，把它们存储在函数的__annotations__ 属性里。仅此而已，Python 不做检查、不做强制、不做验证，什么操作都不做。换句话说，注解对 Python 解释器没有任何意义。注解只是元数据，可以供 IDE、框架和装饰器等工具使用。标准库中还没有什么会用到这些元数据，唯有inspect.signature() 函数知道怎么提取注解，如示例所示。
1 from inspect import signature 2 3 4 def clip(text:str, max_len:'int > 0'=80) -> str: #函数中给每个参数都设置了传递的参数的信息，包括函数最终的返回结果的类型 5 """ 6 :param text: 7 :param max_len:前面或者后面的第一个空格处截取文本 8 :return: 9 """ 10 end = None 11 if len(text) > max_len: #获取传入字符串的长度并与传递的要查找空格最大长度做判断 12 space_before = text.rfind(' ', 0, max_len) #从开头查找到max_len的长度截止，如果能找到则返回空格在字符串中的位置，否则则返回-1 13 if space_before >= 0: 14 end = space_before #查找空格的索引位置等于找到最终函数的切片的最终位置 15 else: 16 space_after = text.rfind(' ', max_len) #如果从开头没有找到空格，则从max_len的长度开始往后继续查找 17 if space_after >= 0: 18 end = space_after 19 20 if end is None: 21 end = len(text) 22 23 return text[:end].rsplit() #返回从查找截止到空格位置的所有字符串 24 25 sig = signature(clip) 26 print(sig.return_annotation) 27 28 for param in sig.parameters.values(): 29 note = repr(param.annotation).ljust(13) 30 print(note, ':', param.name, '=', param.default)
以上代码执行的结果为：
<class 'str'> <class 'str'> : text = <class 'inspect._empty'> 'int > 0' : max_len = 80
signature 函数返回一个 Signature 对象，它有一个return_annotation 属性和一个 parameters 属性，后者是一个字典，把参数名映射到 Parameter 对象上。每个 Parameter 对象自己也有 annotation 属性。
支持函数式编程的包
operator模块
在函数式编程中，经常需要把算术运算符当作函数使用。例如，不使用递归计算阶乘。求和可以使用 sum 函数，但是求积则没有这样的函数。我们可以使用 reduce 函数，但是需要一个函数计算序列中两个元素之积。展示如何使用 lambda 表达式解决这个问题
>>> from functools import reduce >>> reduce(lambda x,y:x*y, range(1,11)) 3628800
operator 模块为多个算术运算符提供了对应的函数，从而避免编写lambda x, y: x*y 这种平凡的匿名函数
>>> from operator import mul >>> from functools import reduce >>> reduce(mul, range(1, 11)) 3628800
operator 模块中还有一类函数，能替代从序列中取出元素或读取对象属性的 lambda 表达式：因此，itemgetter 和 attrgetter 其实会自行构建函数。
? 演示使用itemgetter排序一个元祖列表
>>> from operator import 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)), ... ] >>> for city in sorted(metro_data, key=itemgetter(1)): ... print(city) ... ('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)) ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)) ('Tokyo', 'JP', 36.933, (35.689722, 139.691667)) ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)) ('New York-Newark', 'US', 20.104, (40.808611, -74.020386))
上面代码中的itemgetter(1)等同于lambda fields:fields[1]的效果，也就是每个元素中的第一个索引进行排序
如果把多个参数传给 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')
attrgetter 与 itemgetter 作用类似，它创建的函数根据名称提取对象的属性。如果把多个属性名传给 attrgetter，它也会返回提取的值构成的元组。此外，如果参数名中包含 .（点号），attrgetter 会深入嵌套对象，获取指定的属性。这些行为如示例 5-24 所示。这个控制台会话不短，因为我们要构建一个嵌套结构，这样才能展示attrgetter 如何处理包含点号的属性名。
? 定义一个 namedtuple，名为 metro_data，演示使用 attrgetter 处理它
1 from collections import namedtuple 2 from operator import attrgetter 3 4 5 LatLong = namedtuple('LatLong', 'lat long') 6 Metropolis = namedtuple('Metropolis', 'name cc pop coord') 7 metro_data = [ 8 ('Tokyo', 'JP', 36.933, (35.689722, 139.691667)), 9 ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)), 10 ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)), 11 ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)), 12 ('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)), 13 ] 14 15 metro_areas = [Metropolis(name, cc, pop, LatLong(lat, long)) 16 for name, cc, pop, (lat, long) in metro_data] 17 18 print(metro_areas[0]) 19 print(metro_areas[0].coord.lat) 20 21 name_lat = attrgetter('name', 'coord.lat') #等同于调用Metropolis中的name和coord字段。coord字段对应LatLong，然后在去LatLong中的lat 22 23 for city in sorted(metro_areas, key=attrgetter('coord.lat')): 24 print(name_lat(city)) #等同于Metropolis中获取每一个name的字段和coord.lat的字段
以上代码执行的结果为：
Metropolis(name='Tokyo', cc='JP', pop=36.933, coord=LatLong(lat=35.689722, long=139.691667)) 35.689722 ('Sao Paulo', -23.547778) ('Mexico City', 19.433333) ('Delhi NCR', 28.613889) ('Tokyo', 35.689722) ('New York-Newark', 40.808611)
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....'
使用functools.partial冻结参数
functools.partial 这个高阶函数用于部分应用一个函数。部分应用是指，基于一个函数创建一个新的可调用对象，把原函数的某些参数固定。使用这个函数可以把接受一个或多个参数的函数改编成需要回调的API，这样参数更少。
? 使用 partial 把一个两参数函数改编成需要单参数的可调用对象
from functools import partial from operator import mul triple = partial(mul, 3) print(triple(7)) print(list(map(triple, range(1, 10))))
以上代码执行的结果为：
21
[3, 6, 9, 12, 15, 18, 21, 24, 27]
在来个举个简单的 ?
def sum(x, y): return x + y s = partial(sum, 10) print(s(20)) #使用lambda表达式实现 sum = lambda x,y:x+y s1 = partial(sum, 30) print(s1(50))
以上代码执行的结果为：
30 80
120
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
