#Python functools.partial Tutorial: A modern approach to creating partial functions

I don’t know if you have ever had such an experience: a function has many parameters, but several parameters always have fixed values ​​every time it is called. Repeated writing is troublesome and makes the code look bloated. For example, useintWhen converting a binary string, add it every timebase=2, or useroundAlways write when retaining two decimal placesndigits=2. At this time, the Python standard libraryfunctools.partialcan help us solve this problem.

#What is a partial function?

In functional programming, the core idea of ​​partial functions is partial application: generating a new function by "freezing" some parameters of the original function in advance (which can be positional parameters or keyword parameters). When calling the new function later, you only need to pass in the remaining parameters.

💡 Don't get confused: The "partial function" here is completely different from the "partial function" in mathematics. In mathematics, we talk about functions whose domain is not the complete set; and in programming, partial functions are simply "functions that fill in some parameters first."

#Why do we need partial functions?

Partial functions can make our code cleaner and easier to maintain, which is reflected in the following aspects:

1. Simplify repeated calls: When certain parameters remain unchanged in most scenarios, there is no need to write them again every time they are called;
2. Improve readability: Give the newly generated partial function a semantically clear name so that the intent of the code is clear at a glance;
3. Reduce duplicate code: There is no need to encapsulate a new function specifically for a few fixed parameters and avoid boilerplate code.

#Basic usage

Let’s first look at the two most commonly used introductory examples to get a feel for it.functools.partialconvenience.

#Example 1: Convert fixed base string to integer

int()You can convert a string into an integer, the default is decimal. If you want to parse in binary or octal, you must pass it every timebaseparameter. usepartialJust put itbasePin it in advance:

from functools import partial

# 预先固定 base=2，生成专门转二进制的函数
int2 = partial(int, base=2)
# 预先固定 base=8，生成专门转八进制的函数
int8 = partial(int, base=8)

print(int2('1010'))  # 相当于 int('1010', base=2) → 输出: 10
print(int8('12'))    # 相当于 int('12', base=8) → 输出: 10

#Example 2: Fixed precision rounding

round()FunctionalndigitsThe parameter controls how many decimal places are retained. If we only need to keep two digits most of the time, we can also usepartialEncapsulate it:

from functools import partial

# 固定 ndigits=2
round2 = partial(round, ndigits=2)

print(round2(3.14159))  # 输出: 3.14
print(round2(1.23456))  # 输出: 1.23

#Advanced usage

In addition to simply fixed keyword parameters,partialIt can also handle more flexible parameter combinations.

#1. Fixed position parameters

partialParameters can be passed in directly by position, and these parameters will be placed at the front of all parameters when the new function is called:

from functools import partial

# 固定 max() 的第一个位置参数为 10
max_with_10 = partial(max, 10)

print(max_with_10(5, 6))    # 相当于 max(10, 5, 6) → 10
print(max_with_10(15, 20))  # 相当于 max(10, 15, 20) → 20

#2. Fixed positional parameters and keyword parameters at the same time

For custom functions, we have more flexibility in mixing fixed positional and keyword arguments:

from functools import partial

def power(base, exponent, modulo=None):
    """计算幂，可选取模"""
    if modulo is not None:
        return pow(base, exponent, modulo)
    return base ** exponent

# 只固定关键字参数 exponent=2，生成平方函数
square = partial(power, exponent=2)
# 先固定位置参数 base=2，再固定关键字参数 exponent=3
cube_of_2 = partial(power, 2, exponent=3)

print(square(5))         # 输出: 25
print(cube_of_2())       # 输出: 8

#3. How to "update" the parameters of a partial function?

partialThe original function is saved in the object (funcproperties) and fixed parameters (argsandkeywordsproperty). However, it is usually not recommended to modify these properties directly. A safer approach is to regenerate a new partial function based on the original function:

from functools import partial

# 初始偏函数
int_base8 = partial(int, base=8)
# 不想改 int_base8，直接利用它的 func 属性（也就是原始的 int）重新生成
int_base16 = partial(int_base8.func, base=16)

print(int_base8('10'))   # 输出: 8
print(int_base16('10'))  # 输出: 16

#Improvements in modern Python

Before Python 3.10,partialObject__name__and__doc__Properties are not friendly, you may see when debugging'partial'Such a name. Starting from 3.10,partialThese two attributes of the original function will be inherited by default, making debugging and documentation clearer:

from functools import partial

def greet(name, greeting="Hello"):
    """向某人打招呼"""
    return f"{greeting}, {name}!"

say_hi = partial(greet, greeting="Hi")

print(say_hi.__name__)  # Python 3.10+ 输出: 'greet'
print(say_hi.__doc__)   # Python 3.10+ 输出: '向某人打招呼'

#Comparison with lambda expressions

In some scenarioslambdaSimilar functions can also be achieved, butpartialUsually more advantageous:

# 用 lambda 实现
int2_lambda = lambda x: int(x, base=2)
# 用 partial 实现
int2_partial = partial(int, base=2)

Both have the same effect, butpartialThere are several benefits:

1. When there are many fixed parameters,partialMore concise, no need to write repeated parameter lists;
2. partialWill retain the meta-information of the original function (such as 3.10+'s__name__、__doc__),andlambdaWon't;
3. For those familiar with functional programming,partialThe intention is clearer.

Of course, if in addition to parameter fixation, you need to do some additional simple logic processing, you still have to uselambda。

#Best Practices

in order to letpartialTo use it better, here are a few suggestions:

1. Name should be semantic: Give the partial function a name that expresses its purpose, such asint2、round2, instead of just callingp1、p2；
2. Prioritize using keyword parameters to fix later parameters: If the fixed parameter is not the first positional parameter, using keyword parameters is safer and can avoid bugs caused by parameter order changes;
3. Don’t overuse: Only use fixed parameters when it can really simplify the code. Using them for the sake of use will increase the reading burden;
4. Added type hints (Python 3.10+): It can make the type of partial functions clearer and the editor prompts more accurate:

   from typing import Callable
   from functools import partial
   
   # 声明 int2 是一个接收 str 返回 int 的函数
   int2: Callable[[str], int] = partial(int, base=2)

#Actual application scenarios

partialIt is used a lot in daily development, such as:

1. GUI / Asynchronous callback: The button click callback needs to pass in the button ID, usepartialFix the ID first so you don’t have to write it every timelambdaThe trouble of passing parameters;
2. Data processing pipeline: When cleaning data, most parameters of a certain cleaning function are fixed. UsepartialEncapsulated into dedicated cleaning steps;
3. API packaging: Simplify the common calling methods of third-party complex APIs and fill in common configurations in advance.

#Summarize

functools.partialIt is a small but very practical tool. Its core is to "fill in some parameters first and talk about the rest later." Reasonable use of it can help us reduce repeated code and make the code more concise and readable.

Next time you encounter a scenario where you need to pass the same parameters repeatedly, you might as well try it to make the code cleaner~