Skip to content
SRE运维进阶之路SRE运维进阶之路
github icon
    • 1 Python 简介

      • 1.1 初识Python
        • 1.2 Python 代码规范
          • 1.3 Python 虚拟环境
            • 1.4 使用 vscode 打造 python 开发环境
              • 1.5 pypi 配置国内镜像
              • 2 Python 基础

                • 2.1 Python基础语法
                  • 2.2 程序控制
                    • 2.3 Python数据类型

                      • 2.3.1 数值型
                        • 2.3.2 字符串 str
                          • 2.3.3 字节序列
                            • 2.3.4 列表 list & 元组 tuple
                              • 2.3.5 集合 set & 字典 dict
                            • 3 高级特性

                              • 3.1 线性结构特征 可迭代 & 切片
                                • 3.2 列表、集合、字典解析式
                                  • 3.3 生成器
                                    • 3.4 迭代器
                                    • 4 函数

                                      • 4.1 函数的定义 & 调用 & 返回值
                                        • 4.2 函数参数
                                          • 4.3 作用域
                                            • 4.4 递归函数
                                            • 5 函数式编程

                                              • 5.1 高阶函数
                                                • 5.2 返回函数
                                                  • 5.3 匿名函数
                                                    • 5.4 装饰器
                                                      • 5.5 偏函数
                                                      • 6 模块

                                                        • 6.1 Python 模块常用的几种安装方式
                                                          • 6.2 Python 的 setup.py 详解
                                                          • 7 IO编程

                                                            • 7.1 操作文件和目录
                                                              • 7.2 序列化和反序列化
                                                              • 8 异常、调试和测试

                                                                • 8.1 异常处理
                                                                • 9 面向对象编程

                                                                  • 9.1 类、实例和封装
                                                                    • 9.2 访问控制和属性装饰器
                                                                      • 9.3 继承、多态和Mixin
                                                                      • 10 进程和线程

                                                                        • 10.1 多进程
                                                                          • 10.2 多线程
                                                                            • 10.2 线程同步
                                                                            • 11 网络编程

                                                                              • 11.1 SocketServer
                                                                                • 11.2 TCP 编程
                                                                                • 11 魔术方法
                                                                                  • 17 IO 模型
                                                                                    • python 实际工作中的实例
                                                                                    • 前端学习笔记

                                                                                      5.5 偏函数

                                                                                      author iconClaycalendar icon2021年6月23日category icon
                                                                                      • Python
                                                                                      timer icon大约 2 分钟

                                                                                      # 5.5 偏函数

                                                                                      Python的functools模块提供了很多有用的功能,其中一个就是偏函数(Partial function)。要注意,这里的偏函数和数学意义上的偏函数不一样。

                                                                                      在介绍函数参数的时候,我们讲到,通过设定参数的默认值,可以降低函数调用的难度。而偏函数也可以做到这一点。举例如下:

                                                                                      int()函数可以把字符串转换为整数,当仅传入字符串时,int()函数默认按十进制转换:

                                                                                      >>> int('12345')
                                                                                      12345
                                                                                      
                                                                                      1
                                                                                      2

                                                                                      但int()函数还提供额外的base参数,默认值为10。如果传入base参数,就可以做N进制的转换:

                                                                                      >>> int('12345', base=8)
                                                                                      5349
                                                                                      >>> int('12345', 16)
                                                                                      74565
                                                                                      
                                                                                      1
                                                                                      2
                                                                                      3
                                                                                      4

                                                                                      假设要转换大量的二进制字符串,每次都传入int(x, base=2)非常麻烦,于是,我们想到,可以定义一个int2()的函数,默认把base=2传进去:

                                                                                      def int2(x, base=2):
                                                                                          return int(x, base)
                                                                                      
                                                                                      1
                                                                                      2

                                                                                      这样,我们转换二进制就非常方便了:

                                                                                      >>> int2('1000000')
                                                                                      64
                                                                                      >>> int2('1010101')
                                                                                      85
                                                                                      
                                                                                      1
                                                                                      2
                                                                                      3
                                                                                      4

                                                                                      functools.partial就是帮助我们创建一个偏函数的,不需要我们自己定义int2(),可以直接使用下面的代码创建一个新的函数int2:

                                                                                      >>> import functools
                                                                                      >>> int2 = functools.partial(int, base=2)
                                                                                      >>> int2('1000000')
                                                                                      64
                                                                                      >>> int2('1010101')
                                                                                      85
                                                                                      
                                                                                      1
                                                                                      2
                                                                                      3
                                                                                      4
                                                                                      5
                                                                                      6

                                                                                      所以,简单总结functools.partial的作用就是,把一个函数的某些参数给固定住(也就是设置默认值),返回一个新的函数,调用这个新函数会更简单。

                                                                                      注意到上面的新的int2函数,仅仅是把base参数重新设定默认值为2,但也可以在函数调用时传入其他值:

                                                                                      >>> int2('1000000', base=10)
                                                                                      1000000
                                                                                      
                                                                                      1
                                                                                      2

                                                                                      最后,创建偏函数时,实际上可以接收函数对象、*args和**kw这3个参数,当传入:

                                                                                      int2 = functools.partial(int, base=2)
                                                                                      
                                                                                      1

                                                                                      实际上固定了int()函数的关键字参数base,也就是:

                                                                                      int2('10010')
                                                                                      
                                                                                      1

                                                                                      相当于:

                                                                                      kw = { 'base': 2 }
                                                                                      int('10010', **kw)
                                                                                      
                                                                                      1
                                                                                      2

                                                                                      当传入:

                                                                                      max2 = functools.partial(max, 10)
                                                                                      
                                                                                      1

                                                                                      实际上会把10作为*args的一部分自动加到左边,也就是:

                                                                                      max2(5, 6, 7)
                                                                                      
                                                                                      1

                                                                                      相当于:

                                                                                      args = (10, 5, 6, 7)
                                                                                      max(*args)
                                                                                      
                                                                                      1
                                                                                      2

                                                                                      结果为10。

                                                                                      小结

                                                                                      当函数的参数个数太多,需要简化时,使用functools.partial可以创建一个新的函数,这个新函数可以固定住原函数的部分参数,从而在调用时更简单。

                                                                                      edit icon编辑此页open in new window
                                                                                      上次编辑于: 2021/6/23 05:56:39
                                                                                      贡献者: clay-wangzhi
                                                                                      上一页
                                                                                      5.4 装饰器
                                                                                      备案号:冀ICP备2021007336号
                                                                                      Copyright © 2023 Clay