《流畅的Python》读书笔记第5章一等函数 20231025

1|0第5章一等函数

第四章相对偏僻，但时间上一样要花我很久，就先跳过了，回头再补。而这个第5章节是非常重要的。只是最近工作有点忙，我读的越来越慢了~继续坚持吧。

在 Python 中，所有函数都是一等对象，整数、字符串和字典都是一等对象(注:first-class object)

要成为一等对象，需要满足

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

2|05.1 把函数视作对象

def factorial(n):
    '''returns n!'''
    return 1 if n < 2 else n * factorial(n-1)

result = factorial(5)
print(result) # 120
print(factorial.__doc__) # returns n!
print(type(factorial)) # <class 'function'>

函数对象本身是 function 类的实例

__doc__ 是函数对象众多属性中的一个

def factorial(n):
    '''returns n!'''
    return 1 if n < 2 else n * factorial(n-1)

fact = factorial
print(fact(5))
print(list(map(fact,range(1,5))))

从上面的例子，你看到了2个特点

能赋值给变量
能作为参数传给函数

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

3|05.2 高阶函数

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

在函数式编程范式中，最为人熟知的高阶函数有 map、filter、reduce

内置函数 sorted 也是：可选的 key 参数用于提供一个函数，它会应用到各个元素上进行排序

示例 5-4

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

3|1map、filter和reduce的现代替代品

列表推导或生成器表达式具有 map 和 filter 两个函数的功能，map 和 filter 还是内置函数

>>> 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(factorial, filter(lambda n: n % 2, range(6)))) ➌
[1, 6, 120]
>>> [factorial(n) for n in range(6) if n % 2] ➍
[1, 6, 120]

➊ 构建 0! 到 5! 的一个阶乘列表。
➋ 使用列表推导执行相同的操作。
➌ 使用 map 和 filter 计算直到 5! 的奇数阶乘列表。
➍ 使用列表推导做相同的工作，换掉 map 和 filter，并避免了使用 lambda 表达式

map 和 filter 返回生成器（一种迭代器），因此现在它们的直接替代品是生成器表达式

在Python3.9中我看到是一个map、filter对象，当然它也是可以迭代的

reduce在 Python 3 中放到 functools 模块里了。这个函数最常用于求和，自 2003 年发布的 Python 2.3 开始，最好使用内置的 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 的每个元素都是真值，返回 True；all([]) 返回 True。
any(iterable)
只要 iterable 中有元素是真值，就返回 True；any([]) 返回 False

4|05.3 匿名函数

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

示例 5-7 改写自5-4

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

除了作为参数传给高阶函数之外，Python 很少使用匿名函数。

由于句法上的限制，非平凡的 lambda 表达式要么难以阅读，要么无法写出。

如果使用 lambda 表达式导致一段代码难以理解，Fredrik Lundh 建议像下面这样重构。
(1) 编写注释，说明 lambda 表达式的作用。
(2) 研究一会儿注释，并找出一个名称来概括注释。
(3) 把 lambda 表达式转换成 def 语句，使用那个名称来定义函数。
(4) 删除注释。
这几步摘自“Functional Programming HOWTO”（https://docs.python.org/3/howto/functional.
html），这是一篇必读文章

5|05.4 可调用对象

可调用对象	说明
用户定义的函数	使用 def 语句或 lambda 表达式创建。
内置函数	使用 C 语言（CPython）实现的函数，如 len 或 time.strftime
内置方法	使用 C 语言实现的方法，如 dict.get。
方法	在类的定义体中定义的函数
类	调用类时会运行类的 `__new__` 方法创建一个实例，然后运行`__init__` 方法，初始化实例，最后把实例返回给调用方。因为 Python 没有 new 运算符，所以调用类相当于调用函数。（通常，调用类会创建那个类的实例，不过覆盖`__new__`方法的话，也可能出现其他行为。
类的实例	如果类定义了 `__call__` 方法，那么它的实例可以作为函数调用。
生成器函数	使用 yield 关键字的函数或方法。调用生成器函数返回的是生成器对象。
Native coroutine functions本地协程函数	Functions or methods defined with `async def`. When called, they return a coroutine object. Added in Python 3.5.
synchronous generator functions异步生成器函数	Functions or methods defined with async def that `have yield` in their body. When called, they return an asynchronous generator for use with async for. Added in Python 3.6

前7个是比较好理解的，最后两个是第二版加进来的，第一个是协程；

下面程序运行完毕后，时间就2s

import asyncio

async def simulate_task1():
    await asyncio.sleep(2)
    print("Task 1 done")

async def simulate_task2():
    await asyncio.sleep(1)
    print("Task 2 done")

async def main():
    await asyncio.gather(simulate_task1(), simulate_task2())

if __name__ == "__main__":
    start_time = time.time()
    
    asyncio.run(main())
    
    end_time = time.time()
    print("All tasks completed in", end_time - start_time, "seconds")

与之相对的，下面这个代码就要执行3s

import time

def simulate_task1():
    time.sleep(2)
    print("Task 1 done")

def simulate_task2():
    time.sleep(1)
    print("Task 2 done")

if __name__ == "__main__":
    start_time = time.time()
    
    simulate_task1()
    simulate_task2()
    
    end_time = time.time()
    print("All tasks completed in", end_time - start_time, "seconds")

第二个是异步生成器

import asyncio

# 定义一个异步生成器函数
async def async_generator():
    for i in range(5):
        await asyncio.sleep(1)  # 模拟异步操作
        yield i

# 使用异步 for 循环来迭代异步生成器
async def main():
    async for value in async_generator():
        print(f"Received: {value}")

# 运行主函数
asyncio.run(main())

判断对象能否调用，最安全的方法是使用内置的 callable() 函数

>>> abs, str, 13
(<built-in function abs>, <class 'str'>, 13)
>>> [callable(obj) for obj in (abs, str, 13)]
[True, True, False]

6|05.5 用户定义的可调用类型

任何 Python 对象都可以表现得像函数。为此，只需实现实例方法 __call__。

示例

import random


class BingoCage:
    def __init__(self, items):
        self._items = list(items)  # ➊
        random.shuffle(self._items)  # ➋

    def pick(self):  # ➌
        try:
            return self._items.pop()
        except IndexError:
            raise LookupError('pick from empty BingoCage')  # ➍

    def __call__(self):  # ➎
        return self.pick()

➊ __init__ 接受任何可迭代对象；在本地构建一个副本，防止列表参数的意外副作用。
➋ shuffle 定能完成工作，因为 self._items 是列表。
➌ 起主要作用的方法。
➍ 如果 self._items 为空，抛出异常，并设定错误消息。
➎ bingo.pick() 的快捷方式是 bingo()。

bingo = BingoCage(range(5))
print(bingo._items) # [0, 2, 3, 4, 1] # 每次的结果不一样
bingo.pick()
print(bingo._items) # [0, 2, 3, 4]
bingo()
print(bingo._items) # [0, 2, 3]
print(callable(bingo))  # True

实现 __call__ 方法的类是创建函数类对象的简便方式，此时必须在内部维护一个状态，让它在调用之间可用，例如 BingoCage 中的剩余元素。

装饰器就是这样。装饰器必须是函数，而且有时要在多次调用之间“记住”某些事 [ 例如备忘（memoization），即缓存消耗大的计算结果，供后面使用 ]。

创建保有内部状态的函数，还有一种截然不同的方式——使用闭包

装饰器不是可以是类吗？

class MyDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("Before the function call.")
        result = self.func(*args, **kwargs)
        print("After the function call.")
        return result


@MyDecorator
def my_function():
    print("This is my function.")


my_function()

看了下英文的第二版，是这么描述的：Decorators must be callable，也不知道是改进了，还是中译错了~

7|05.6 函数内省

>>> def func():pass
...
>>> dir(func)
['__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__']

大多数属性是 Python 对象共有的

函数使用 __dict__ 属性存储赋予它的用户属性，这相当于一种基本形式的注解

def userinfo():
    '''hello'''
    name = 'wuxianfeng'
    print(name)
userinfo.age = 18
print(userinfo.__dict__) # {'age': 18} 注意name没有
print(userinfo.__doc__) # hello

Django 框架为函数赋予属性，但不是很常见的做法

# https://docs.djangoproject.com/en/4.2/ref/contrib/admin/
# 摘录一段
def my_property(self):
    return self.first_name + " " + self.last_name


my_property.short_description = "Full name of the person"
my_property.admin_order_field = "last_name"

full_name = property(my_property)

示例 5-9 列出常规对象没有而函数有的属性

>>> class Person: pass
...
>>> def func(): pass
...
>>> sorted(set(dir(func)) - set(dir(Person)))
['__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（参阅 PEP 3155，https://wwW.Python.org/dev/peps/pep-3155/）

8|05.7 从定位参数到仅限关键字参数

关键字参数（keyword-only argument）

调用函数时使用 * 和 **展开可迭代对象，映射到单个参数

示例 5-10 tag 函数用于生成 HTML 标签

使用名为 cls 的关键字参数传入“class”属性，这是一种变通方法，因为“class”是 Python 的关键字

def tag(name, *content, cls=None, **attrs):
    """生成一个或多个HTML标签"""
    if cls is not None:
        attrs['class'] = cls
    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>%s</%s>' % (name, attr_str, c, name) for c in content)
    else:
        return '<%s%s />' % (name, attr_str)


print(tag('br')) # 1
print(tag('p', 'hello')) # 2
print(tag('p', 'hello', 'world')) # 
print(tag('p', 'hello', id='nodep')) # 3
print(tag('p', 'hello', 'world', 'type',cls='pn')) # 4
print(tag(content='testing', name='img')) # 5 
my_tags = {'name': 'img', 'title':'Sunset Boulevard' ,'src': 'sunset.jpg', 'cls': 'framed'}
print(tag(**my_tags)) # 6

➊ 传入单个定位参数，生成一个指定名称的空标签。
➋ 第一个参数后面的任意个参数会被 *content 捕获，存入一个元组。
➌ tag 函数签名中没有明确指定名称的关键字参数会被 **attrs 捕获，存入一个字典。
➍ cls 参数只能作为关键字参数传入。
➎ 调用 tag 函数时，即便第一个定位参数也能作为关键字参数传入。
➏ 在 my_tag 前面加上**，字典中的所有元素作为单个参数传入，同名键会绑定到对应的具名参数上，余下的则被 **attrs 捕获

输出

<br />
<p>hello</p>
<p>hello</p>
<p>world</p>
<p id="nodep">hello</p>
<p class="pn">hello</p>
<p class="pn">world</p>
<p class="pn">type</p>
<img content="testing" />
<img class="framed" src="sunset.jpg" title="Sunset Boulevard" />

cls 参数只能通过关键字参数指定，它一定不会捕获未命名的定位参数。

定义函数时若想指定仅限关键字参数，要把它们放到前面有 * 的参数后面。

如果不想支持数量不定的定位参数，但是想支持仅限关键字参数，在签名中放一个 *

示例代码

def f(a, *, b):
  print(f'a:{a},b:{b}')
# 前面3个都是对的
f(1,b=2)
f(a=1,b=2)
f(**{'a':1,'b':2})
f(*[1,2]) # 这是错的
f(1,2) # 这是错的

报错

TypeError: f() takes 1 positional argument but 2 were given

第二版中代码是这么写的

def tag(name, *content, class_=None, **attrs):
    """Generate one or more HTML tags"""
    if class_ is not None:
        attrs['class'] = class_
    attr_pairs = (f' {attr}="{value}"' for attr, value in sorted(attrs.items()))
    attr_str = ''.join(attr_pairs)
    if content:
        elements = (f'<{name}{attr_str}>{c}</{name}>' for c in content)
        return '\n'.join(elements)
    else:
        return f'<{name}{attr_str} />'

就几个变化

参数从cls编程了class_
attr_str没任何处理，如果不传attr，那你得到的attr_str也是''
之前用%s这样的方式，现在用的是f-string

8|15.7.1 仅限位置参数 Positional-Only Parameters

这是第二版才有的内容

自Python 3.8版本以后，用户自定义的函数签名可以指定位置参数（positional-only parameters）

可以参考官网:https://docs.python.org/zh-cn/3.8/whatsnew/3.8.html#positional-only-parameters

也可以参考: https://peps.python.org/pep-0570/

最典型的就是divmod

divmod(x, y, /)
    Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.

>>> divmod(x=3,y=2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: divmod() takes no keyword arguments
>>> divmod(3,2)
(1, 1)

意思就很明显了，/前面的参数必须是位置参数，其后的不管

类似的*后面的必须是关键字参数

9|05.8 获取关于参数的信息

这个章节，新版去掉了，放到了这里：https://www.fluentpython.com/extra/function-introspection/

示例 5-12 Bobo 知道 hello 需要 person 参数，并且从 HTTP 请求中获取它

import bobo
@bobo.query('/')
def hello(person):
	return 'Hello %s!' % person

要安装bobo

然后bobo -f demo.py

# console
Serving ['bobo__main__'] on port 8080...

就可以curl了

C:\Users\songqin008>curl -i http://127.0.0.1:8080
HTTP/1.0 403 Forbidden
Date: Wed, 18 Oct 2023 07:58:05 GMT
Server: WSGIServer/0.2 CPython/3.9.6
Content-Type: text/html; charset=UTF-8
Content-Length: 103

<html>
<head><title>Missing parameter</title></head>
<body>Missing form variable person</body>
</html>

C:\Users\songqin008>curl -i http://127.0.0.1:8080/?person=wuxianfeng
HTTP/1.0 200 OK
Date: Wed, 18 Oct 2023 07:58:27 GMT
Server: WSGIServer/0.2 CPython/3.9.6
Content-Type: text/html; charset=UTF-8
Content-Length: 17

Hello wuxianfeng!

这个时候console

127.0.0.1 - - [18/Oct/2023 15:58:05] "GET / HTTP/1.1" 403 103
127.0.0.1 - - [18/Oct/2023 15:58:27] "GET /?person=wuxianfeng HTTP/1.1" 200 17

跟当代的web框架：flask、Django的输出类似

这个框架是怎么做到知道你要传一个person参数的呢？

bobo.query 装饰器把一个普通的函数（如 hello）与框架的请求处理机制集成起来了

Bobo 会内省 hello 函数，发现它需要一个名为 person 的参数，然后从请求中获取那个名称对应的参数，将其传给
hello 函数，因此程序员根本不用触碰请求对象

怎么做到的呢？

Bobo 是怎么知道函数需要哪个参数的呢？它又是怎么知道参数有没有默认值呢？
函数对象有个 __defaults__ 属性，它的值是一个元组，里面保存着定位参数和关键字参
数的默认值。仅限关键字参数的默认值在 __kwdefaults__ 属性中。然而，参数的名称在
__code__ 属性中，它的值是一个 code 对象引用，自身也有很多属性

def func(name='wuxianfeng',*,age=18):
    print(f'{name} is {age} years old!')


print(func.__defaults__) # ('wuxianfeng',)
print(func.__kwdefaults__) # {'age': 18}
print(func.__code__.co_varnames) # ('name', 'age')

__code__的属性非常多

参考： https://docs.python.org/zh-cn/3.9/library/inspect.html?highlight=co_name

参数	解释
co_argcount	参数数量（不包括仅关键字参数、* 或 ** 参数）
co_code	原始编译字节码的字符串
co_cellvars	单元变量名称的元组(通过包含作用域引用)
co_consts	字节码中使用的常量元组
co_filename	创建此代码对象的文件的名称
co_firstlineno	第一行在Python源码的行号
co_flags	`CO_*` 标志的位图，详见此处
co_lnotab	编码的行号到字节码索引的映射
co_freevars	自由变量的名字组成的元组（通过函数闭包引用）
co_posonlyargcount	仅限位置参数的数量
co_kwonlyargcount	仅限关键字参数的数量（不包括 ** 参数）
co_name	定义此代码对象的名称
co_names	局部变量名称的元组
co_nlocals	局部变量的数量
co_stacksize	需要虚拟机堆栈空间
co_varnames	参数名和局部变量的元组

关于函数参数的个数

def func(name,/,type_,*,hometome,age=18,sex='man'):
    pass

# 参数数量（不包括仅关键字参数、* 或 ** 参数） 
# 此处是 name 和 type_
print(func.__code__.co_argcount) 
# 此处是 name
print(func.__code__.co_posonlyargcount)
# 此处是 hometome age sex
print(func.__code__.co_kwonlyargcount)
# 函数一共有几个参数
print(func.__code__.co_argcount+func.__code__.co_kwonlyargcount)

这种做法并不是最便利的

参数名称在 __code__.co_varnames 中，不过里面还有函数定义体中创建的局部变量。因此，参数名称是前 N 个字符串，N 的值由__code__.co_argcount 确定。顺便说一下，这里不包含前缀为 * 或 ** 的变长参数。参数的
默认值只能通过它们在 __defaults__ 元组中的位置确定，因此要从后向前扫描才能把参数和默认值对应起来

书中还提供了一个例子，你可以参考

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()
print(clip.__defaults__) # (80,) 
print(clip.__code__) # <code object clip at 0x000001EBC00F8EA0, file ...
print(clip.__code__.co_varnames) # ('text', 'max_len', 'end', 'space_before', 'space_after')

更好的方式——使用 inspect 模块

示例 5-17 提取函数的签名

import inspect
def clip(text:str, flag:'biaoji ' = None, max_len:'int > 20'=80):
    pass
sig = inspect.signature(clip)
print(sig) # inspect.Signature 对象  # (text, flag = None, max_len=80)
for name ,param in sig.parameters.items():
    print(param.kind,":",name,"=",param.default)
    print('参数注解:',param.annotation)

(text: str, flag: 'biaoji ' = None, max_len: 'int > 20' = 80)
POSITIONAL_OR_KEYWORD : text = <class 'inspect._empty'>
参数注解: <class 'str'>
POSITIONAL_OR_KEYWORD : flag = None
参数注解: biaoji 
POSITIONAL_OR_KEYWORD : max_len = 80
参数注解: int > 20

inspect.signature 函数返回一个 inspect.Signature 对象，它有一个 parameters属性，这是一个有序映射，把参数名和 inspect.Parameter 对象对应起来

各个 Parameter 属性也有自己的属性，例如 name、default 和 kind。特殊的 inspect._empty 值表示没有默认值

但要注意=None是默认值，不是_empty

kind的取值可能

class _ParameterKind(enum.IntEnum):
    POSITIONAL_ONLY = 0 # 仅限定位参数
    POSITIONAL_OR_KEYWORD = 1 #可以通过定位参数和关键字参数传入的形参（多数 Python 函数的参数属于此类）
    VAR_POSITIONAL = 2 # 定位参数元组
    KEYWORD_ONLY = 3 # 仅限关键字参数
    VAR_KEYWORD = 4  # 关键字参数字典

inspect.Parameter 对象还有一个 annotation（注解）属性，它的值通常是 inspect._empty，但是可能包含 Python 3 新的注解句法提供的函数签名元数据

inspect.Signature 对象有个 bind 方法，它可以把任意个参数绑定到签名中的形参上，所用的规则与实参到形参的匹配方式一样。框架可以使用这个方法在真正调用函数前验证参数

import inspect
def clip(text:str, flag:'biaoji ' = None, max_len:'int > 20'=80):
    pass
sig = inspect.signature(clip)
sig_params = {'text':'hello','flag':'true','max_len':60}
bound_args = sig.bind(**sig_params)
print(bound_args) # BoundArguments
for name , value in bound_args.arguments.items():
    print(name,":",value)
sig_params_2 = {'flag':'true','max_len':60}
bound_args_2 = sig.bind(**sig_params_2)

输出

D:\Python39\python.exe demo.py 
Traceback (most recent call last):
  File "demo.py", line 11, in <module>
    bound_args_2 = sig.bind(**sig_params_2)
  File "D:\Python39\lib\inspect.py", line 3062, in bind
    return self._bind(args, kwargs)
  File "D:\Python39\lib\inspect.py", line 2977, in _bind
    raise TypeError(msg) from None
TypeError: missing a required argument: 'text'

<BoundArguments (text='hello', flag='true', max_len=60)>
text : hello
flag : true
max_len : 60

10|05.9 函数注解

这个章节在第二版中也挪到了typing部分中去

Python 3 提供了一种句法，用于为函数声明中的参数和返回值附加元数据

函数声明中的各个参数可以在 : 之后增加注解表达式。

如果参数有默认值，注解放在参数名和 = 号之间。

如果想注解返回值，在 ) 和函数声明末尾的 : 之间添加 -> 和一个表达式。那个表达式可以是任何类型。

注解中最常用的类型是类（如 str 或 int）和字符串（如'int > 0'）

def clip(text:str, flag:'biaoji ' = None, max_len:'int > 20'=80):
    pass
print(clip.__annotations__) # {'text': <class 'str'>, 'flag': 'biaoji ', 'max_len': 'int > 20'}

Python 对注解所做的唯一的事情是，把它们存储在函数的 __annotations__ 属性里。仅此而已，Python 不做检查、不做强制、不做验证，什么操作都不做。换句话说，注解对Python 解释器没有任何意义。注解只是元数据，可以供 IDE、框架和装饰器等工具使用

示例 5-20 从函数签名中提取注解

import inspect
def clip(text:str, flag:'biaoji ' = None, max_len:'int > 20'=80):
    pass
sig = inspect.signature(clip)
for param in sig.parameters.values():
    print(param.annotation)

<class 'str'>
biaoji 
int > 20

函数注解的最大影响或许不是让 Bobo 等框架自动设置，而是为 IDE 和 lint 程序等工具中的静态类型检查功能提供额外的类型信息

11|05.10 支持函数式编程的包

operator 和functools 等包的支持，函数式编程风格也可以信手拈来

11|15.10.1 operator模块

在函数式编程中，经常需要把算术运算符当作函数使用。例如，不使用递归计算阶乘。求和可以使用 sum 函数，但是求积则没有这样的函数。我们可以使用 reduce 函数，但是需要一个函数计算序列中两个元素之积

示例 5-21 使用 reduce 函数和一个匿名函数计算阶乘

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

示例 5-22 使用 reduce 和 operator.mul 函数计算阶乘

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

operator 模块中还有一类函数，能替代从序列中取出元素或读取对象属性的 lambda 表达式

itemgetter 和 attrgetter 其实会自行构建函数

示例

from operator import itemgetter
a = [1,2,3,4,5]
b = itemgetter(0)   # itemgetter(1) 的 作用与 lambda fields: fields[1] 一样：创建一个接受集合的函数，返回索引位 1 上的元素
print(b(a)) # 1 , 类似于a[0]
c = itemgetter(0,2,3)  # 如果把多个参数传给 itemgetter，它构建的函数会返回提取的值构成的元组：
print(c(a)) # (1,3,4)

再看个示例，结合sorted进行排序

from operator import itemgetter

scores = [
    {"语文": 80, "英语": 70},
    {"语文": 82, "英语": 78},
    {"语文": 86, "英语": 73},
    {"语文": 76, "英语": 60}
]
# 使用itemgetter,按照语文成绩排序
x_yuwen = sorted(scores, key=itemgetter("语文"))
# 跟使用lambda 的效果是类似的
x_yingyu = sorted(scores, key=lambda x: x["英语"])
print(x_yuwen)
print(x_yingyu)

书里的示例 5-23 演示使用 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
for city in sorted(metro_data, key=itemgetter(1)):
	print(city)

根据metro_data中的子元素的第2个元素进行排序

('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，它构建的函数会返回提取的值构成的元组

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

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

attrgetter 与 itemgetter 作用类似，它创建的函数根据名称提取对象的属性。如果把多个属性名传给 attrgetter，它也会返回提取的值构成的元组

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

示例 5-24 定义一个 namedtuple，名为 metro_data

from collections import namedtuple
from operator import itemgetter
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)),
('New York-Newark', 'US', 20.104, (40.808611, -74.020386)),
('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)),]

LatLong = namedtuple('LatLong', 'lat long') # 1
Metropolis = namedtuple('Metropolis', 'name cc pop coord') # 2
metro_areas = [Metropolis(name, cc, pop, LatLong(lat, long)) # 3
	for name, cc, pop, (lat, long) in metro_data]
print(metro_areas[0])
print(metro_areas[0].coord.lat) # 4
name_lat = attrgetter('name', 'coord.lat') # 5
for city in sorted(metro_areas, key=attrgetter('coord.lat')): # 2
	print(name_lat(city)) # 7

➊ 使用 namedtuple 定义 LatLong。
➋ 再定义 Metropolis。
➌ 使用 Metropolis 实例构建 metro_areas 列表；注意，我们使用嵌套的元组拆包提取(lat, long)，然后使用它们构建 LatLong，作为 Metropolis 的 coord 属性。
➍ 深入 metro_areas[0]，获取它的纬度。
➎ 定义一个 attrgetter，获取 name 属性和嵌套的 coord.lat 属性。
➏ 再次使用 attrgetter，按照纬度排序城市列表。
➐ 使用标号➎中定义的 attrgetter，只显示城市名和纬度。

输出

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)

operator 模块中定义的部分函数

['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']

methodcaller。它的作用与 attrgetter和 itemgetter 类似，它会自行创建函数。methodcaller 创建的函数会在对象上调用参数指定的方法

示例 5-25 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'

第一个测试并不推荐，纯粹的替换

第二个测试就略有意义，它绑定或称之为冻结了参数

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

等价于s.replace(' ','-')

11|25.10.2 使用functools.partial冻结参数

functools.partial 这个高阶函数用于部分应用一个函数。部分应用是指，基于一个函数创建一个新的可调用对象，把原函数的某些参数固定

使用这个函数可以把接受一个或多个参数的函数改编成需要回调的 API，这样参数更少

示例 5-26 使用 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]

➊ 使用 mul 创建 triple 函数，把第一个定位参数定为 3。
➋ 测试 triple 函数。
➌ 在 map 中使用 triple；在这个示例中不能使用 mul

实际上，mul这个函数必须要传2个参数：乘数和被乘数

当你做了triple = partial(mul, 3)后，就固定了一个乘数

书中还提供了多个例子

示例 5-27 使用 partial 构建一个便利的 Unicode 规范化函数

>>> import unicodedata, functools
>>> nfc = functools.partial(unicodedata.normalize, 'NFC')
>>> s1 = 'café'
>>> s2 = 'cafe\u0301'
>>> s1, s2
('café', 'café')
>>> s1 == s2
False
>>> nfc(s1) == nfc(s2)
True

示例 5-28 把 partial 应用到示例 5-10 中定义的 tag 函数上

>>> from tagger import tag
>>> tag
<function tag at 0x10206d1e0> ➊
>>> from functools import partial
>>> picture = partial(tag, 'img', cls='pic-frame') ➋
>>> picture(src='wumpus.jpeg')
'<img class="pic-frame" src="wumpus.jpeg" />' ➌
>>> picture
functools.partial(<function tag at 0x10206d1e0>, 'img', cls='pic-frame') ➍
>>> picture.func ➎
<function tag at 0x10206d1e0>
>>> picture.args
('img',)
>>> picture.keywords
{'cls': 'pic-frame'}

➊ 从示例 5-10 中导入 tag 函数，查看它的 ID。
➋ 使用 tag 创建 picture 函数，把第一个定位参数固定为 'img'，把 cls 关键字参数固定为 'pic-frame'。
➌ picture 的行为符合预期

➍ partial() 返回一个 functools.partial 对象。
➎ functools.partial 对象提供了访问原函数和固定参数的属性

functools 模块中的 lru_cache 函数令人印象深刻，它会做备忘（memoization），这是一种自动优化措施，它会存储耗时的函数调用结果，避免重新计算

12|05.11 本章小结

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

高阶函数是函数式编程的重要组成部分，即使现在不像以前那样经常使用 map、filter 和 reduce 函数了，但是还有列表推导（以及类似的结构，如生成器表达式）以及 sum、all 和 any 等内置的归约函数。

Python 中常用的高阶函数有内置函数 sorted、min、max 和 functools.partial。
Python 有 9 种可调用对象，从 lambda 表达式创建的简单函数到实现 __call__ 方法的类实例。这些可调用对象都能通过内置的 callable() 函数检测。每一种可调用对象都支持使用相同的丰富句法声明形式参数，包括仅限关键字参数和注解——二者都是 Python 3 引入的新特性。
Python 函数及其注解有丰富的属性，在 inspect 模块的帮助下，可以读取它们。例如，Signature.bind 方法使用灵活的规则把实参绑定到形参上，这与 Python 使用的规则一样。
最后，本章介绍了 operator 模块中的一些函数，以及 functools.partial 函数，有了这些函数，函数式编程就不太需要功能有限的 lambda 表达式

13|05.12 延伸阅读

素材	URL	相关信息
Python Cookbook（第 3 版）中文版》		第 7 章是对`本书的`本章和第 7 章很好的补充
Python 语言参考手册中的“3.2. The standard type hierarchy”	https://docs.python.org/3/reference/datamodel.html#the-standard-type-hierarchy	对 7 种可调用类型和其他所有内置类型做了介绍
PEP 3102—Keyword-Only Arguments	https://www.python.org/dev/peps/pep-3102
PEP 3107—Function Annotations	www.python.org/dev/peps/pep-3107
What are good uses for Python3’s ‘Function Annotations’	http://stackoverflow.com/questions/3038033/what-are-good-uses-for-python3s-function-annotations
What good are Python function annotations?	http://stackoverflow.com/questions/13784713/what-good-are-python-function-annotations
PEP 362—Function Signature Object	https://www.python.org/dev/peps/pep-0362
Python Functional Programming HOWTO	http://docs.python.org/3/howto/functional.html
fn.py	https://github.com/kachayev/fn.py	是为 Python 2 和 Python 3 提供函数式编程支持的包；这个包提供的 @recur.tco 装饰器为 Python 中的无限递归实现了尾调用优化
Python: Why is functools.partial necessary?	http://stackoverflow.com/questions/3252228/python-why-is-functools-partial-necessary
Bobo	http://bobo.readthedocs.io/en/latest/	面向对象的 Web 框架

map、filter 和 reduce 的最初目的是为 Python 增加 lambda 表达式

lambda、map、filter 和 reduce 首次出现在 Lisp 中，这是最早的一门函数式语言

在任何一门语言中，匿名函数都有一个严重的缺点：没有名称。函数有名称，栈跟踪更易于阅读

__EOF__

本文作者：博客已废弃
本文链接：https://www.cnblogs.com/wuxianfeng023/p/17787439.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！

posted @ 2023-10-25 15:53 博客已废弃阅读(70) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· (转载)PYTHON修饰器的函数式编程--纪念下陈皓老师

· 《流畅的Python》读书笔记第7章_函数装饰器和闭包

· 流畅的 Python 第二版（GPT 重译）（四）

· 流畅的python--第七章

· Fluent-Python-第05章：一等函数

阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET10 - 预览版1新功能体验（一）

公告

《流畅的Python》读书笔记第5章一等函数 20231025

发表于 2023-10-25 15:53阅读：70评论：0推荐：2

读书笔记

关注

跳至底部

昵称：博客已废弃
园龄： 3年7个月
粉丝： 100
关注： 2

+加关注

博客已废弃

《流畅的Python》读书笔记第5章一等函数 20231025

1|0第5章一等函数

2|05.1 把函数视作对象

3|05.2 高阶函数

3|1map、filter和reduce的现代替代品

4|05.3 匿名函数

5|05.4 可调用对象

6|05.5 用户定义的可调用类型

7|05.6 函数内省

8|05.7 从定位参数到仅限关键字参数

8|15.7.1 仅限位置参数 Positional-Only Parameters

9|05.8 获取关于参数的信息

10|05.9 函数注解

11|05.10 支持函数式编程的包

11|15.10.1 operator模块

11|25.10.2 使用functools.partial冻结参数

12|05.11 本章小结

13|05.12 延伸阅读

公告

博客已废弃

《流畅的Python》读书笔记第5章一等函数 20231025

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

推荐排行榜

博客已废弃

《流畅的Python》 读书笔记 第5章 一等函数 20231025

1|0第5章 一等函数

2|05.1 把函数视作对象

3|05.2 高阶函数

3|1map、filter和reduce的现代替代品

4|05.3 匿名函数

5|05.4 可调用对象

6|05.5 用户定义的可调用类型

7|05.6 函数内省

8|05.7 从定位参数到仅限关键字参数

8|15.7.1 仅限位置参数 Positional-Only Parameters

9|05.8 获取关于参数的信息

10|05.9 函数注解

11|05.10 支持函数式编程的包

11|15.10.1 operator模块

11|25.10.2 使用functools.partial冻结参数

12|05.11 本章小结

13|05.12 延伸阅读

公告

博客已废弃

《流畅的Python》 读书笔记 第5章 一等函数 20231025

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

推荐排行榜

《流畅的Python》读书笔记第5章一等函数 20231025

1|0第5章一等函数

《流畅的Python》读书笔记第5章一等函数 20231025