Python*args和kwargs参数详解

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《Python \*args与kwargs参数详解》，文章讲解的知识点主要包括，如果你对文章方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

args和kwargs允许函数接收任意数量的位置和关键字参数，分别打包为元组和字典。它们在定义时收集参数，在调用时可通过和解包序列或字典传递参数。混合使用时需遵循参数顺序：普通参数→args→默认参数→*kwargs，避免名称冲突并注意可读性与调试难度。典型应用场景包括通用函数、装饰器和参数转发，能极大提升代码灵活性和复用性。

Python中的*args和**kwargs是两种非常强大的语法糖，它们允许函数接受数量不定的参数。简单来说，*args会把传递给函数的所有位置参数打包成一个元组（tuple），而**kwargs则会将所有关键字参数打包成一个字典（dictionary）。这使得函数在设计时能拥有极大的灵活性，不必预先知道调用者会传递多少个参数，或者这些参数的具体名称是什么。在我看来，这是Python函数设计中一个非常核心且优雅的特性，尤其在编写通用工具函数、装饰器或者需要接口扩展性的场景下，它们简直是不可或缺的。

解决方案

要理解*args和**kwargs，最直接的方式就是看它们如何在函数定义和调用中发挥作用。它们的主要目的就是处理“不确定数量的参数”。

当你在函数定义中使用*args时，它会“收集”所有额外的、未被明确命名的位置参数。这些参数会被封装到一个元组里，然后你可以在函数体内部像操作普通元组一样去访问它们。

def my_function(*args):
    print("收到的位置参数是:", args)
    for arg in args:
        print(f"  - {arg}")

my_function(1, 2, 3)
# 输出:
# 收到的位置参数是: (1, 2, 3)
#   - 1
#   - 2
#   - 3

my_function("hello", "world")
# 输出:
# 收到的位置参数是: ('hello', 'world')
#   - hello
#   - world

类似地，**kwargs则负责收集所有额外的、未被明确命名的关键字参数。这些参数会被封装到一个字典里，其中键是参数名，值是参数值。

def another_function(**kwargs):
    print("收到的关键字参数是:", kwargs)
    for key, value in kwargs.items():
        print(f"  - {key}: {value}")

another_function(name="Alice", age=30)
# 输出:
# 收到的关键字参数是: {'name': 'Alice', 'age': 30}
#   - name: Alice
#   - age: 30

another_function(city="New York", zip_code="10001", country="USA")
# 输出:
# 收到的关键字参数是: {'city': 'New York', 'zip_code': '10001', 'country': 'USA'}
#   - city: New York
#   - zip_code: 10001
#   - country: USA

当然，你也可以将它们与普通参数以及默认参数混合使用。但这里有个严格的顺序要求：普通参数必须在最前面，然后是*args，接着是默认参数，最后才是**kwargs。这个顺序不能乱，否则Python解释器会报错。

def mixed_function(a, b, *args, c=100, **kwargs):
    print(f"a: {a}")
    print(f"b: {b}")
    print(f"args: {args}")
    print(f"c (默认参数): {c}")
    print(f"kwargs: {kwargs}")

mixed_function(10, 20, 30, 40, c=50, d="hello", e="world")
# 输出:
# a: 10
# b: 20
# args: (30, 40)
# c (默认参数): 50
# kwargs: {'d': 'hello', 'e': 'world'}

可以看到，10和20被a和b接收，30和40被*args收集，c=50覆盖了默认值，而d="hello"和e="world"则被**kwargs收集。这种组合方式，让函数能够应对各种复杂的调用场景。

Python函数参数中*args和**kwargs的最佳实践是什么？

在我日常的开发中，*args和**kwargs的用途远不止于简单的参数收集，它们是实现某些设计模式的关键。我觉得，掌握它们的最佳实践，能让你的代码更具弹性。

首先，编写通用工具函数。设想你有一个日志记录函数，你希望它能接受任何数量的参数，并把它们打印出来。这时候*args就非常方便。

import datetime

def log_message(level, *messages, timestamp=True, **extra_info):
    """
    一个灵活的日志记录函数。
    level: 日志级别 (e.g., 'INFO', 'WARNING')
    *messages: 任意数量的要记录的消息
    timestamp: 是否添加时间戳 (默认True)
    **extra_info: 额外的关键字信息，如'user_id', 'module'
    """
    prefix = f"[{level}]"
    if timestamp:
        prefix = f"{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')} {prefix}"

    full_message = " ".join(map(str, messages))

    if extra_info:
        extra_str = ", ".join([f"{k}={v}" for k, v in extra_info.items()])
        print(f"{prefix} {full_message} ({extra_str})")
    else:
        print(f"{prefix} {full_message}")

log_message("INFO", "用户登录成功", "来自IP", "192.168.1.1", user_id=123, module="Auth")
# 示例输出: 2023-10-27 10:30:00 [INFO] 用户登录成功 来自IP 192.168.1.1 (user_id=123, module=Auth)

log_message("WARNING", "数据库连接失败", timestamp=False)
# 示例输出: [WARNING] 数据库连接失败

这个例子就很好地展示了如何用它们来构建一个既通用又可配置的函数。*messages收集了所有的文本内容，timestamp是个可选的布尔旗标，而**extra_info则允许我们添加任何我们认为有用的上下文信息，而无需修改函数签名。

其次，装饰器（Decorators） 的实现几乎离不开它们。装饰器需要包装任意签名的函数，并保持其原有的参数传递能力。*args和**kwargs在这里扮演了关键角色。

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs) # 关键：用*args和**kwargs转发参数
        end_time = time.time()
        print(f"函数 '{func.__name__}' 执行耗时: {end_time - start_time:.4f} 秒")
        return result
    return wrapper

@timer
def long_running_task(iterations, multiplier=1):
    total = 0
    for i in range(iterations):
        total += i * multiplier
    return total

@timer
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

long_running_task(10000000, multiplier=2)
greet("World", greeting="Hi")

如果没有*args和**kwargs，我们的wrapper函数就无法通用地接收被装饰函数的所有参数，这会大大限制装饰器的应用范围。

最后，函数转发（Function Forwarding）。有时候，一个函数的主要职责就是接收参数，然后把它们原封不动地传递给另一个函数。这在构建API接口或者中间件时很常见。

def process_data(data, config_path, **kwargs):
    # 假设这里有一些处理数据的逻辑
    print(f"处理数据: {data}, 配置路径: {config_path}")
    print(f"额外处理参数: {kwargs}")
    # 然后可能调用一个更底层的函数
    _internal_processing(data, config_path, **kwargs)

def _internal_processing(data, config_path, timeout=30, debug_mode=False, **extra_settings):
    print(f"内部处理中... 数据: {data}, 配置: {config_path}, 超时: {timeout}, 调试模式: {debug_mode}")
    print(f"内部额外设置: {extra_settings}")
    # ... 实际处理逻辑 ...

process_data("sensor_readings", "/app/config.json", timeout=60, debug_mode=True, user="admin")

在这个例子中，process_data函数将所有未识别的关键字参数直接传递给了_internal_processing，使得上层函数无需关心所有底层函数的参数细节，提高了模块的解耦性。这在我看来是构建可维护、可扩展系统的关键一环。

*args和**kwargs与普通参数混合使用时有哪些注意事项？

在使用*args和**kwargs时，尤其当它们与普通参数和默认参数混合出现时，确实有一些细节需要特别留意，否则很容易踩坑。

一个最核心的规则就是参数顺序。Python函数定义的参数顺序是固定的：

1. 普通位置参数 (Positional Arguments)
2. *`args` (Positional Arguments Tuple)**
3. 关键字参数 (Keyword-Only Arguments) - Python 3引入，这些参数必须通过关键字传递。
4. `kwargs` (Keyword Arguments Dictionary)**

你看，*args必须出现在所有普通位置参数之后，而**kwargs则必须在所有其他参数（包括*args和关键字参数）之后。如果违反这个顺序，Python解释器会直接抛出SyntaxError。

# 错误示例：*args 在普通参数之后，但在关键字参数之前
# def bad_order(a, *args, b):
#     pass
# SyntaxError: invalid syntax

# 正确的顺序
def good_order(a, *args, b_kw_only, **kwargs):
    print(f"a: {a}")
    print(f"args: {args}")
    print(f"b_kw_only: {b_kw_only}")
    print(f"kwargs: {kwargs}")

good_order(1, 2, 3, b_kw_only="hello", key="value")
# 输出:
# a: 1
# args: (2, 3)
# b_kw_only: hello
# kwargs: {'key': 'value'}

这里的b_kw_only就是一个关键字参数（Python 3 特性），它必须以b_kw_only=...的形式传递，不能作为位置参数。

另一个常见的问题是参数名冲突。如果你在函数定义中有一个明确的关键字参数，例如def func(name, **kwargs):，然后你在调用时又通过**kwargs传入了一个名为name的键，Python会报TypeError，因为name参数被指定了两次。

def my_profile(name, age, **kwargs):
    print(f"Name: {name}, Age: {age}")
    print(f"Other info: {kwargs}")

# 这是可以的，'city'不是明确的参数
my_profile("Alice", 30, city="New York")

# 这会报错：'name'参数被指定了两次
try:
    my_profile("Bob", 25, name="Robert", occupation="Engineer")
except TypeError as e:
    print(f"错误发生: {e}")
# 输出: 错误发生: my_profile() got multiple values for argument 'name'

这其实很合理，毕竟你不能同时给一个变量赋两个不同的值。所以在设计函数时，要确保**kwargs收集的键不会与函数签名中明确定义的参数名冲突。

还有就是可读性问题。过度使用*args和**kwargs，尤其是在函数签名很长、参数很多的情况下，会降低代码的可读性。当一个函数接受*args和**kwargs时，它的实际参数列表变得不那么直观，你需要查看函数体才能完全理解它能接受哪些参数。在我看来，如果一个函数真的需要非常多的可选参数，并且这些参数有明确的意义，那么考虑使用一个配置对象（比如一个字典或一个dataclass实例）来传递会是更好的选择，而不是把所有东西都塞进**kwargs。

最后，调试的挑战。当函数签名非常灵活时，调试可能会变得稍微复杂。如果一个错误发生在*args或**kwargs内部，你可能需要花更多时间来确定是哪个具体的参数导致了问题，因为它们都是打包在一起的。所以，在关键业务逻辑中，我个人倾向于使用更明确的函数签名，而在通用工具或框架层，*args和**kwargs的灵活性则显得尤为重要。这是一种权衡，没有绝对的对错，关键在于理解其利弊并根据场景做出最佳选择。

如何利用*和**操作符在函数调用时解包参数？

前面我们讨论了*args和**kwargs在函数定义时如何“收集”参数，把它们打包成元组和字典。现在，我们反过来看看，在函数调用的时候，如何使用*和**操作符来“解包”一个序列（如列表、元组）或一个字典，把它们的内容作为参数传递给函数。这在我看来是它们用法的另一半，同样强大且实用。

*1. 使用``解包序列作为位置参数**

当你有一个列表或元组，里面的元素恰好是你想要作为位置参数传递给函数的，这时就可以使用*操作符。它会将序列中的每个元素“展开”成独立的参数。

def sum_numbers(a, b, c):
    return a + b + c

my_numbers = [10, 20, 30]

# 如果不使用解包，你需要这样写：
# sum_numbers(my_numbers[0], my_numbers[1], my_numbers[2])

# 使用 * 解包列表
result = sum_numbers(*my_numbers)
print(f"解包列表调用结果: {result}") # 输出: 解包列表调用结果: 60

# 也可以是元组
my_tuple = (5, 15, 25)
result_tuple = sum_numbers(*my_tuple)
print(f"解包元组调用结果: {result_tuple}") # 输出: 解包元组调用结果: 45

这个特性非常有用，比如你从数据库查询得到了一行数据（通常是元组或列表），然后想把这行数据作为参数传递给一个处理函数。

2. 使用``解包字典作为关键字参数**

当你有一个字典，其中的键值对正好对应了函数需要接收的关键字参数，那么**操作符就能派上用场了。它会将字典中的每个键值对“展开”成key=value的形式。

def create_user(name, age, city="Unknown", email=None):
    print(f"创建用户: {name}, 年龄: {age}, 城市: {city}, 邮箱: {email}")

user_data = {
    "name": "Charlie",
    "age": 40,
    "city": "London"
}

# 不使用解包，你需要这样写：
# create_user(name=user_data["name"], age=user_data["age"], city=user_data["city"])

# 使用 ** 解包字典
create_user(**user_data)
# 输出: 创建用户: Charlie, 年龄: 40, 城市: London, 邮箱: None

# 字典中可以包含函数签名中没有的键，它们会被 **kwargs 捕获（如果函数定义有 **kwargs）
def process_settings(timeout=30, retries=3, **extra_options):
    print(f"Timeout: {timeout}, Retries: {retries}")
    print(f"Extra options: {extra_options}")

settings = {
    "timeout": 60,
    "retries": 5,
    "log_level": "DEBUG",
    "user_id": 101
}
process_settings(**settings)
# 输出:
# Timeout: 60, Retries: 5
# Extra options: {'log_level': 'DEBUG', 'user_id': 101}

这在处理配置信息、API请求参数或者从JSON/YAML文件加载的设置时特别方便。

*3. `和`的组合使用

你当然可以将这两种解包方式结合起来，甚至与普通参数一起使用。这给了你极大的灵活性来构造函数调用。

def configure_system(system_id, *components, admin_email, **settings):
    print(f"系统ID: {system_id}")
    print(f"组件: {components}")
    print(f"管理员邮箱: {admin_email}")
    print(f"系统设置: {settings}")

# 准备参数
system_components = ["web_server", "database", "cache"]
system_settings = {
    "max_connections": 100,
    "logging_level": "INFO",
    "debug_mode": True
}

# 组合调用
configure_system(
    "SYS_001",
    *system_components,  # 解包列表作为位置参数
    "monitoring_agent",  # 额外的普通位置参数

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。