Python `*args` 和 `**kwargs`：优雅处理可变参数的终极指南 & 配合 frozenset 实现通用缓存装饰器

在Python开发中，我们经常会遇到需要处理不定数量参数的场景。今天就来聊聊Python中的*args和**kwargs，看看它们如何帮我们优雅地解决这类问题。

从一个实际场景说起

假设你正在开发一个数据处理框架，需要实现一个通用的函数装饰器来记录函数执行时间：

import time
from functools import wraps

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} 执行耗时: {end - start:.6f} 秒")
        return result
    return wrapper

@timer
def process_data(data, threshold=0.5):
    # 模拟数据处理
    time.sleep(1)
    return [x for x in data if x > threshold]

# 使用示例
result = process_data([1, 2, 3, 0.1, 0.4])
# 输出：process_data 执行耗时: 1.003865 秒

注意到装饰器中的*args和**kwargs了吗？它们让我们的装饰器可以适配任意参数的函数。

*args ：处理位置参数

*args允许函数接收任意数量的位置参数，这些参数会被打包成一个元组。

def sum_all(*numbers):
    return sum(numbers)

# 以下调用都是有效的
print(sum_all(1, 2))          # 3
print(sum_all(1, 2, 3, 4))    # 10

**kwargs ：处理关键字参数

**kwargs则用于接收任意数量的关键字参数，这些参数会被打包成一个字典。

def print_user_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

# 可以传入任意数量的命名参数
print_user_info(name="Alice", age=30, city="Shanghai")

解包操作： * 和 ** 的另一面

除了在函数定义时使用，*和**还可以用于解包序列和字典：

def greet(name, age, city):
    print(f"你好，{name}！你{age}岁了，来自{city}？")

# 使用*解包列表/元组
user_data = ["Bob", 25, "Beijing"]
greet(*user_data)  # 你好，Bob！你25岁了，来自Beijing？

# 使用**解包字典
user_dict = {"name": "Charlie", "age": 35, "city": "Guangzhou"}
greet(**user_dict)   # 你好，Charlie！你35岁了，来自Guangzhou？

高级应用：混合使用与顺序规则

在实际开发中，我们经常需要混合使用这些特性：

def complex_function(x, y, *args, default=None, **kwargs):
    print(f"x: {x}")
    print(f"y: {y}")
    print(f"args: {args}")
    print(f"default: {default}")
    print(f"kwargs: {kwargs}")

# 调用示例
complex_function(1, 2, 3, 4, default="test", extra=True, debug=False)

这里有个重要的顺序规则：

1. 普通位置参数
2. *args
3. 默认参数
4. **kwargs

实用技巧：使用 *args 和 **kwargs 实现通用缓存装饰器

在开发中，经常需要在不修改原函数签名的情况下添加新功能：

import time
from typing import Any, Callable
from functools import wraps

class Cache:
    def __init__(self):
        self._cache = {}
    
    def cached_call(self, func: Callable[..., Any], *args, **kwargs) -> Any:
        # 使用frozenset处理kwargs，确保{a:1, b:2}和{b:2, a:1}被视为相同的调用
        key = (func.__name__, args, frozenset(kwargs.items()))

        if key not in self._cache:
            print(f"Cache miss for {func.__name__}, calculating...")
            start = time.perf_counter()
            self._cache[key] = func(*args, **kwargs)
            end = time.perf_counter()
        else:
            print(f"Cache hit for {func.__name__}, returning cached result")
        
        return self._cache[key]

# 创建缓存实例
cache = Cache()

def expensive_operation(x: int, y: int, z: int = 1) -> int:
    """模拟耗时操作"""
    time.sleep(2)  # 模拟耗时计算
    return x + y + z

def measure_time(func: Callable, *args, **kwargs) -> None:
    """测量函数执行时间"""
    start = time.perf_counter()
    result = func(*args, **kwargs)
    end = time.perf_counter()
    print(f"Result: {result}")
    print(f"Time taken: {end - start:.2f} seconds\n")
    return result

# 演示不同场景下的缓存效果
print("第一次调用（无缓存）:")
measure_time(cache.cached_call, expensive_operation, 1, 2, z=3)

print("第二次调用（使用缓存）:")
measure_time(cache.cached_call, expensive_operation, 1, 2, z=3)

print("不同参数顺序的调用（展示frozenset的作用）:")
# 注意这里kwargs的顺序不同，但应该命中相同的缓存
result3 = cache.cached_call(expensive_operation, x=1, y=2, z=3)
result4 = cache.cached_call(expensive_operation, y=2, x=1, z=3)

输出：

第一次调用（无缓存）:
Cache miss for expensive_operation, calculating...
Result: 6
Time taken: 2.01 seconds

第二次调用（使用缓存）:
Cache hit for expensive_operation, returning cached result
Result: 6
Time taken: 0.00 seconds

不同参数顺序的调用（展示frozenset的作用）:
Cache miss for expensive_operation, calculating...
Cache hit for expensive_operation, returning cached result

注意，在实现缓存时，我们需要一个可哈希（hashable）的键来唯一标识函数调用。但是普通的set和dict是可变的，因此不能作为字典的键。Python 的 frozenset 就是为了解决这个问题 - 它是不可变的集合类型。

关于frozenset的几个重要特点

1. 不可变性：一旦创建就不能修改，这使它可以作为字典的键

# 这是允许的
d = {frozenset([1, 2, 3]): "value"}

# 这会报错
s = set([1, 2, 3])
d = {s: "value"}  # TypeError: unhashable type: 'set'

2. 顺序无关性：

# 这两个frozenset是相等的
fs1 = frozenset([1, 2, 3])
fs2 = frozenset([3, 1, 2])
print(fs1 == fs2)  # True

3. 性能考虑：

# 下面这种写法更高效
key = (func.__name__, args, frozenset(kwargs.items()))

# 而不是
key = (func.__name__, args, tuple(sorted(kwargs.items())))

关于frozenset的注意事项

1. frozenset只能包含可哈希的元素。例如，你不能创建包含列表或字典的frozenset。

2. 在我们的缓存实现中，如果函数参数包含不可哈希的类型（如列表），需要额外处理：

def make_hashable(obj):
    """将对象转换为可哈希的形式"""
    if isinstance(obj, (tuple, list)):
        return tuple(make_hashable(o) for o in obj)
    elif isinstance(obj, dict):
        return frozenset((k, make_hashable(v)) for k, v in obj.items())
    elif isinstance(obj, set):
        return frozenset(make_hashable(o) for o in obj)
    return obj

# 改进的缓存键生成
key = (func.__name__, make_hashable(args), make_hashable(kwargs))

一些 *args 和 **kwargs 的注意事项

1. 参数名称不一定非要用args和kwargs，但这是约定俗成的命名。
2. 在函数定义中，*args必须在**kwargs之前。
3. 在Python3 中，可以在*args之后定义强制关键字参数。

总结

*args和**kwargs是Python中非常强大的特性，它们让我们能够：

• 编写更灵活的函数和装饰器
• 实现参数转发
• 处理不定量的参数

掌握这些特性，可以让我们的代码更加优雅和通用。在日常开发中，合理使用这些特性可以大大提高代码的可维护性和可扩展性。

希望这篇文章对你有帮助！如果你有任何问题或见解，欢迎在评论区讨论。