第 5 章一等函数

在这里插入图片描述

5.1 把函数视作对象

>>> def factorial(n):
...     """return n!"""
...     return 1 if n < 2 else n * factorial(n - 1)
...
>>> factorial(42)
1405006117752879898543142606244511569936384000000000
>>> factorial.__doc__
'return n!'
>>> type(factorial)
<class 'function'>
>>> fact = factorial
>>> fact
<function factorial at 0x0000017B71F1B740>
>>> fact(5)
120
>>> list(map(fact, range(10)))
[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]

有了一等函数，就可以使用函数式风格编程。函数式编程的特点之一是使用高阶函数

5.2 高阶函数

接受函数为参数，或者把函数作为结果返回的函数是高阶函数（higher-order function），map 函数就是一例

按单词长度排序：

>>> fruits = ['strawberry', 'fig', 'apple', 'cherry', 'raspberry', 'banana']
>>> sorted(fruits, key=len)
['fig', 'apple', 'cherry', 'banana', 'raspberry', 'strawberry']

按韵脚排序：

>>> def reverse(word):
...     return word[::-1]
...
>>> sorted(fruits, key=reverse)
['banana', 'apple', 'fig', 'raspberry', 'strawberry', 'cherry']

在这里插入图片描述

5.3 匿名函数

>>> sorted(fruits, key=lambda x: x[::-1])
['banana', 'apple', 'fig', 'raspberry', 'strawberry', 'cherry']

lambda 句法只是语法糖：与 def 语句一样，lambda 表达式会创建函数对象。这是 Python 中几种可调用对象的一种

5.4 可调用对象

python 定义了 7 中可调用对象：

用户定义的函数：包括 def 和 lambda
内置函数：如 len()
内置方法：如 dict.get
方法：在类的定义体中定义的函数。
类：因为 Python 没有 new 运算符，所以调用类相当于调用构造函数
类的实例：如果类定义了 call 方法，那么它的实例可以作为函数调用
生成器函数：使用 yield 关键字的函数或方法。调用生成器函数返回的是生成器对象

在这里插入图片描述

5.5 用户定义的可调用类型

不仅 Python 函数是真正的对象，任何 Python 对象都可以表现得像函数。为此，只需实现实例方法 call

class BingoCage:def __init__(self, item):self._item = list(item)shuffle(self._item)def pick(self):try:return self._item.pop()except IndexError:raise LookupError('pick from empty BingoCage')def __call__(self):return self.pick()

>>> b1 = BingoCage(range(3))
>>> b1.pick()
2
>>> b1()
3
>>> callable(b1)
True

5.6 函数内省

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

在这里插入图片描述

5.8 获取关于参数的信息

在这里插入图片描述

5.9 函数注解

注解：为函数声明中的参数和返回值附加元数据

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

在这里插入图片描述

5.10 支持函数式编程的包

operator模块

operator 模块为多个算术运算符提供了对应的函数，从而避免编写 lambda a, b: a*b 这种平凡的匿名函数

from functools import reduce
from operator import muldef fact(n):return reduce(mul, range(1, n + 1))if __name__ == '__main__':print(fact(5))

在这里插入图片描述

itemgetter 的常见用途：根据元组的某个字段给元组列表排序

在这里插入图片描述

第 6 章使用一等函数实现设计模式

6.1 重构“策略”模式

使用函数实现“策略”模式

在这里插入图片描述

from collections import namedtupleCustomer = namedtuple('Customer', 'name fidelity')class LineItem:def __init__(self, product, quantity, price):self.product = productself.quantity = quantityself.price = pricedef total(self):return self.price * self.quantityclass Order:  # 上下文def __init__(self, customer, cart, promotion=None):self.customer = customerself.cart = list(cart)self.promotion = promotion      # function: dynamic binddef total(self):if not hasattr(self, '__total'):self.__total = sum(item.total() for item in self.cart)return self.__totaldef due(self):if self.promotion is None:discount = 0else:discount = self.promotion(self)return self.total() - discountdef __repr__(self):fmt = '<Order total: {:.2f} due: {:.2f}>'return fmt.format(self.total(), self.due())def fidelity_promo(order):return order.total() * .05 if order.customer.fidelity >= 1000 else 0def bulk_item_promo(order):discount = 0for item in order.cart:if item.quantity >= 20:discount += item.total() * .1return discountdef large_order_promo(order):distinct_items = {item.product for item in order.cart}if len(distinct_items) >= 10:return order.total() * .07return 0if __name__ == '__main__':joe = Customer('John Doe', 0)ann = Customer('Ann Smith', 1100)cart = [LineItem('banana', 4, .5),LineItem('apple', 10, 1.5),LineItem('watermelon', 5, 5.0)]# 为了把折扣策略应用到 Order 实例上，只需把促销函数作为参数传入Order(joe, cart, fidelity_promo)

选择最佳策略：简单的方式

在这里插入图片描述

找出模块中的全部策略

使用 globals() 获取全局符号表：

在这里插入图片描述

promos = [globals()[name] for name in globals() if name.endwith('_promo') and name != 'best_promo']
def best_promo(order):return max(promo(order) for promo in promos)

或者内省 promotions 模块，构建策略函数列表：

promos = [func for name, func in inspect.getmemebers(promotions, inspect.isfunction)]

6.2 “命令”模式

“命令”设计模式也可以通过把函数作为参数传递而简化

在这里插入图片描述

第 7 章函数装饰器和闭包

7.1 装饰器基础知识

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

在这里插入图片描述

def deco(fn):def inner():print("inner")return inner@deco
def foo():print("foo")if __name__ == '__main__':foo()		# "inner"

在这里插入图片描述

7.2 Python 何时执行装饰器

在这里插入图片描述

registry = []def register(fn):print(f'running register({fn})')registry.append(fn)return fn@register
def f1():print('running f1()')@register
def f2():print('running f2()')def f3():print('running f3()')if __name__ == '__main__':print('running main')print('registry -> ', registry)f1()f2()f3()

running register(<function f1 at 0x7f2fb6b36268>)
running register(<function f2 at 0x7f2fb6b362f0>)
running main
registry ->  [<function f1 at 0x7f2fb6b36268>, <function f2 at 0x7f2fb6b362f0>]
running f1()
running f2()
running f3()Process finished with exit code 0

在这里插入图片描述

7.4 变量作用域规则

在这里插入图片描述
Python 编译函数的定义体时，它判断 b 是局部变量，因为在函数中给它赋值了

Python 不要求声明变量，但是假定在函数定义体中赋值的变量是局部变量

在这里插入图片描述

7.5 闭包

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

在这里插入图片描述
使用类 + 可调用对象实现：

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)

在这里插入图片描述
使用高阶函数实现：

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

调用 make_averager 时，返回一个 averager 函数对象。每次调用 averager 时，它会把参数添加到系列值中，然后计算当前平均值
在这里插入图片描述
综上，闭包是一种函数，它会保留定义函数时存在的自由变量的绑定，这样调用函数时，虽然定义作用域不可用了，但是仍能使用那些绑定

7.6 nolocal 声明

在这里插入图片描述

def make_averager():count = 0total = 0def averager(new_value):nonlocal count, totalcount += 1total += new_valuereturn total / countreturn averager

7.7 实现一个简单的装饰器

下面定义了一个装饰器，它会在每次调用被装饰的函数时计时，然后把经过的时间、传入的参数和调用的结果打印出来：

import timedef clock(func):def clocked(*args):t0 = time.perf_counter()result = func(*args)  # func is a freevarelapsed = time.perf_counter() - t0name = func.__name__arg_str = ', '.join(repr(arg) for arg in args)print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result))return resultreturn clocked@clock
def snooze(seconds):time.sleep(seconds)@clock
def factorial(n):return n 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))pass

**************************************** Calling snooze(.123)
[0.12306906s] snooze(0.123) -> None
**************************************** Calling factorial(6)
[0.00000069s] factorial(1) -> 1
[0.00001145s] factorial(2) -> 2
[0.00001898s] factorial(3) -> 6
[0.00002650s] factorial(4) -> 24
[0.00003265s] factorial(5) -> 120
[0.00004110s] factorial(6) -> 720
6! = 720

在这里插入图片描述
设计模式中定义的装饰器模式：动态地给一个对象添加一些额外的职责。这与函数装饰器是相同的

改进后的装饰器：

def clock(func):@functools.wraps(func)def clocked(*args, **kwargs):t0 = time.time()result = func(*args, **kwargs)  # func is a freevarelapsed = time.time() - t0name = func.__name__arg_lst = []if args:arg_lst.append(', '.join(repr(arg) for arg in args))if kwargs:pairs = [f'{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 resultreturn clocked

7.8 标准库中的装饰器

lru_cache

使用 DP 的思想优化递归程序
在这里插入图片描述

@clock
def fibonacci(n):return n if n < 2 else fibonacci(n - 2) + fibonacci(n - 1)

进行了大量重复运算：

[0.00000030s] fibonacci(0) -> 0
[0.00000040s] fibonacci(1) -> 1
[0.00004730s] fibonacci(2) -> 1
[0.00000030s] fibonacci(1) -> 1
[0.00000040s] fibonacci(0) -> 0
[0.00000030s] fibonacci(1) -> 1
[0.00002010s] fibonacci(2) -> 1
[0.00003850s] fibonacci(3) -> 2
[0.00010310s] fibonacci(4) -> 3
[0.00000020s] fibonacci(1) -> 1
[0.00000020s] fibonacci(0) -> 0
[0.00000020s] fibonacci(1) -> 1
[0.00001670s] fibonacci(2) -> 1
[0.00003420s] fibonacci(3) -> 2
[0.00000010s] fibonacci(0) -> 0
[0.00000030s] fibonacci(1) -> 1
[0.00001650s] fibonacci(2) -> 1
[0.00000020s] fibonacci(1) -> 1
[0.00000020s] fibonacci(0) -> 0
[0.00000020s] fibonacci(1) -> 1
[0.00001700s] fibonacci(2) -> 1
[0.00003310s] fibonacci(3) -> 2
[0.00006550s] fibonacci(4) -> 3
[0.00011620s] fibonacci(5) -> 5
[0.00023630s] fibonacci(6) -> 8

使用 lru_cache 改善性能后：

@functools.lru_cache()		# () 接受参数，functools.lru_cache(maxsize=128, typed=False)
@clock
def fibonacci(n):return n if n < 2 else fibonacci(n - 2) + fibonacci(n - 1)

[0.00000030s] fibonacci(0) -> 0
[0.00000040s] fibonacci(1) -> 1
[0.00004980s] fibonacci(2) -> 1
[0.00000050s] fibonacci(3) -> 2
[0.00006920s] fibonacci(4) -> 3
[0.00000050s] fibonacci(5) -> 5
[0.00008840s] fibonacci(6) -> 8
8

singledispatch

因为 Python 不支持重载方法或函数，使用 @singledispatch 装饰的普通函数会变成泛函数（generic function）：根据第一个参数的类型，以不同方式执行相同操作的一组函数

import time
from functools import singledispatch
from collections import abc
import numbers
import html@singledispatch
def htmlize(obj):content = html.escape(repr(obj))return f'<pre>{content}</pre>'@htmlize.register(str)
def _(text):content = html.escape(text).replace('\n', '<br>\n')return '<p>{0}</p>'.format(content)@htmlize.register(numbers.Integral)
def _(n):return '<pre>{0} (0x{0:x})</pre>'.format(n)@htmlize.register(tuple)
@htmlize.register(abc.MutableSequence)
def _(seq):inner = '</li>\n<li>'.join(htmlize(item) for item in seq)return '<ul>\n<li>' + inner + '</li>\n</ul>'

在这里插入图片描述

7.9 叠放装饰器

装饰器是函数，因此可以组合起来使用

在这里插入图片描述

7.10 参数化装饰器

解析源码中的装饰器时，Python 把被装饰的函数作为第一个参数传给装饰器函数。那怎么让装饰器接受其他参数呢？答案是：创建一个装饰器工厂函数，把参数传给它，返回一个装饰器，然后再把它应用到要装饰的函数上。

一个参数化的注册装饰器

在这里插入图片描述

registry = set()def register(active=True):def decorate(func):print(f'running register(active={active}) -> decorate({func})')if active:registry.add(func)else:registry.discard(func)return funcreturn decorate@register(active=False)
def f1():print('running f1()')@register()
def f2():print('running f2()')def f3():print('running f3()')if __name__ == '__main__':print(registry)pass