Python函数传递字典多值避免参数过多的优化方案

AI 小北

2026-8-27

问题场景

def my_function():
    payload = {
        "key1": f"{value1}",
        "key2": "default value",
        "propertySet": [
            {
                "key3": f"{value3}",
                "key4": f"{value4}",
                "key5": f"{value5}",
                "content": [
                    {
                        "key6": "default value",
                        "key7": "default value",                                  
                        "key8": f"{value8}",
                    },
                    {
                        "key9": "value9",
                        "key10": "value10"
                    }
                ],
                "key11": "value11"
            }
        ],
        "newRule": {
            "key12": f"{value12}"
        },
        "key13": "value13"
    }

现有上述Python代码逻辑，需要将value1至value13的取值传入my_function()函数内部用于构造payload字典；如果直接将所有值逐一列为函数形参，会出现参数数量过多、代码可读性与可维护性下降的问题，求更优的传值实现方式。

推荐实现方案

以下是Python工程中处理这类多参数字典构造场景的常用方案，按推荐优先级排序：

方案1：用dataclass按payload结构封装参数
你的payload本身有清晰的嵌套层级，用Python标准库自带的dataclass对应每一层结构即可，自带类型提示，IDE能自动补全字段，既不用写一长串形参，后续增删字段只要调整对应数据类的定义，维护成本很低。
示例实现：

from dataclasses import dataclass
from typing import List

# 按payload嵌套结构定义对应数据类，固定值直接写默认值
@dataclass
class PayloadConfig:
    key1: str
    key3: str
    key4: str
    key5: str
    key8: str
    key12: str
    key2: str = "default value"
    key9: str = "value9"
    key10: str = "value10"
    key11: str = "value11"
    key13: str = "value13"

def my_function(config: PayloadConfig):
    payload = {
        "key1": config.key1,
        "key2": config.key2,
        "propertySet": [
            {
                "key3": config.key3,
                "key4": config.key4,
                "key5": config.key5,
                "content": [
                    {
                        "key6": "default value",
                        "key7": "default value",
                        "key8": config.key8
                    },
                    {
                        "key9": config.key9,
                        "key10": config.key10
                    }
                ],
                "key11": config.key11
            }
        ],
        "newRule": {
            "key12": config.key12
        },
        "key13": config.key13
    }
    return payload

调用时只需要构造一个PayloadConfig实例传入即可，传参时IDE会自动提示字段名，不容易传错。

方案2：接收动态值字典入参，配合默认模板合并
如果不想额外定义数据类，直接把所有需要动态传入的字段打包成一个字典作为唯一入参就行。函数内部提前定义好带默认值的payload模板，深拷贝模板后把传入的动态值替换到对应位置即可，实现简单直接。
示例实现：

import copy

# 提前定义全局默认payload模板，固定值直接写死
DEFAULT_PAYLOAD = {
    "key1": "",
    "key2": "default value",
    "propertySet": [
        {
            "key3": "",
            "key4": "",
            "key5": "",
            "content": [
                {
                    "key6": "default value",
                    "key7": "default value",
                    "key8": ""
                },
                {
                    "key9": "value9",
                    "key10": "value10"
                }
            ],
            "key11": "value11"
        }
    ],
    "newRule": {
        "key12": ""
    },
    "key13": "value13"
}

def my_function(dynamic_values: dict):
    payload = copy.deepcopy(DEFAULT_PAYLOAD)
    # 替换动态传入的字段
    payload["key1"] = dynamic_values["key1"]
    payload["propertySet"][0]["key3"] = dynamic_values["key3"]
    payload["propertySet"][0]["key4"] = dynamic_values["key4"]
    payload["propertySet"][0]["key5"] = dynamic_values["key5"]
    payload["propertySet"][0]["content"][0]["key8"] = dynamic_values["key8"]
    payload["newRule"]["key12"] = dynamic_values["key12"]
    return payload

调用时只需要把需要传的键值对拼成字典传入即可，非必填字段可以在取的时候用dict.get()设置兜底值。

方案3：拆分嵌套结构的构造逻辑
如果后续payload还会持续扩展，可以把每一层嵌套的构造拆成独立的小函数，每个小函数只负责自己那部分的参数接收和结构生成，最后在主函数里拼接成完整payload，避免单个函数参数堆积、逻辑过长。

注意：不要直接用**kwargs无声明接收所有动态参数，这种方式没有明确的参数定义，IDE无法做字段补全和校验，后续维护时根本不知道函数需要接收哪些字段，排查问题的成本比罗列13个形参还高。

内容的提问来源于stack exchange，提问作者Ghazal Saeed