《深入 Python 调用栈：*args 与 **kwargs 在内存里到底长什么样？》

原创于 2025-12-23 05:26:43 发布 · 719 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#python #前端 #算法

学习笔记同时被 3 个专栏收录

319 篇文章

订阅专栏

课程教程

299 篇文章

订阅专栏

提升学习

70 篇文章

订阅专栏

2025博客之星年度评选已开启 10w+人浏览 1.8k人参与

**《深入 Python 调用栈：*args 与 kwargs 在内存里到底长什么样？》

在我教授 Python 的这些年里，有两个语法元素几乎贯穿所有课程、项目与面试：*args 和 **kwargs。它们看似简单，却是 Python 函数调用体系中最具代表性的“动态能力”。初学者常把它们当作“可变参数”的语法糖，而资深开发者则知道，它们背后隐藏着 Python 调用栈、对象模型、内存布局与解释器机制的深层逻辑。

这篇文章，我想带你真正走进 Python 内部：
当你写下 def func(*args, **kwargs): 时，解释器到底做了什么？
args 和 kwargs 在内存里是什么结构？
它们如何参与函数调用、栈帧构建与参数绑定？

无论你是刚入门的学习者，还是追求极致性能与理解的高级开发者，我希望这篇文章都能给你带来新的视角与启发。

**一、从 Python 的发展说起：为什么需要 *args 与 kwargs？

Python 自 1991 年诞生以来，一直以“简洁、优雅、灵活”著称。它的函数系统尤其体现了这一点：

支持默认参数
支持关键字参数
支持可变参数
支持解包调用
支持动态绑定

这些能力让 Python 成为“胶水语言”的核心原因之一。你可以轻松写出高度抽象、可扩展的 API，也可以构建灵活的装饰器、回调系统、事件机制。

而 *args 与 **kwargs 正是 Python 函数系统中最关键的两个“动态入口”。

**二、基础回顾：*args 与 kwargs 到底是什么？

在语法层面：

*args：接收任意数量的位置参数，并将其打包成一个 tuple
**kwargs：接收任意数量的关键字参数，并将其打包成一个 dict

示例：

def demo(*args, **kwargs):
    print(args, type(args))
    print(kwargs, type(kwargs))

demo(1, 2, 3, name="Alice", age=20)

输出：

(1, 2, 3) <class 'tuple'>
{'name': 'Alice', 'age': 20} <class 'dict'>

这只是表象。
真正的问题是：

解释器是如何把这些参数“打包”成 tuple 和 dict 的？
它们在内存里是什么结构？
为什么是 tuple 和 dict？

接下来，我们将深入 CPython 内部。

三、深入 CPython：函数调用时发生了什么？

当你调用一个函数时，例如：

demo(1, 2, 3, name="Alice")

CPython 会经历以下步骤：

1. 创建调用栈帧（Frame Object）

每个函数调用都会创建一个 PyFrameObject，其中包含：

局部变量表（locals）
全局变量表（globals）
栈空间（value stack）
指令指针（f_lasti）
参数绑定表（fast locals）

2. 参数绑定（Argument Binding）

CPython 使用 PyArg_ParseTupleAndKeywords 机制，将传入的参数绑定到函数定义的参数列表。

当遇到 *args 时：

所有未被绑定的位置参数会被打包成一个 tuple
这个 tuple 是一个真正的 PyTupleObject

当遇到 **kwargs 时：

所有未被绑定的关键字参数会被打包成一个 dict
这个 dict 是一个真正的 PyDictObject

四、args 在内存里长什么样？*

让我们从最简单的例子开始：

def foo(*args):
    pass

foo(10, 20, 30)

1. CPython 会创建一个 PyTupleObject

其结构大致如下（伪结构）：

PyTupleObject
 ├── ob_refcnt
 ├── ob_type
 ├── ob_size = 3
 ├── ob_item[0] → PyLongObject(10)
 ├── ob_item[1] → PyLongObject(20)
 └── ob_item[2] → PyLongObject(30)

也就是说：

args 是一个 tuple
tuple 内部是一个 指针数组
每个元素指向一个 Python 对象（如 PyLongObject）

2. 为什么是 tuple？

因为：

tuple 是不可变对象
不可变意味着可以安全共享
解释器可以优化（如缓存小 tuple）

这也是为什么：

def foo(*args):
    args[0] = 100  # ❌ 会报错

五、kwargs 在内存里长什么样？**

示例：

def bar(**kwargs):
    pass

bar(a=1, b=2)

1. CPython 会创建一个 PyDictObject

其结构大致如下：

PyDictObject
 ├── ma_used = 2
 ├── ma_keys
 │     ├── dk_size
 │     ├── dk_entries
 │     │     ├── entry 0: key="a", hash=..., value=PyLongObject(1)
 │     │     └── entry 1: key="b", hash=..., value=PyLongObject(2)
 └── ma_values (可能为空，取决于版本)

dict 的内部结构非常复杂（涉及哈希表、探测、稀疏数组等），但你只需要记住：

kwargs 是一个 dict
dict 内部是哈希表
key 是字符串（PyUnicodeObject）
value 是任意 Python 对象

六、真实内存示例：用 dis 看看解释器做了什么

我们用 dis 模块反编译：

import dis

def demo(*args, **kwargs):
    return args, kwargs

dis.dis(demo)

输出（部分）：

LOAD_FAST                0 (args)
LOAD_FAST                1 (kwargs)
BUILD_TUPLE              2
RETURN_VALUE

解释器做的事情非常明确：

args 已经是 tuple
kwargs 已经是 dict
它们在进入函数之前就被构造好了

**七、实战：*args 与 kwargs 的真实应用场景

1. 构建灵活 API

def api_call(url, *args, **kwargs):
    print("extra args:", args)
    print("options:", kwargs)

2. 装饰器

def logger(func):
    def wrapper(*args, **kwargs):
        print("call:", func.__name__)
        return func(*args, **kwargs)
    return wrapper

3. 元编程：动态代理

class Proxy:
    def __init__(self, target):
        self.target = target

    def __getattr__(self, name):
        def wrapper(*args, **kwargs):
            print("proxy call:", name)
            return getattr(self.target, name)(*args, **kwargs)
        return wrapper

4. 解包调用

params = (1, 2)
options = {"debug": True}

func(*params, **options)

**八、性能分析：*args 与 kwargs 的代价

1. tuple 和 dict 的创建是有成本的

每次函数调用：

*args → 创建 tuple
**kwargs → 创建 dict

2. 关键字参数比位置参数慢

因为：

需要计算 key 的哈希
需要查找哈希表
需要构造 dict

3. 如何优化？

尽量使用位置参数
避免在高频函数中使用 **kwargs
使用 __slots__ 减少 dict 开销
使用 functools.lru_cache 缓存结果

九、案例实战：构建一个通用事件系统

下面是一个真实项目中使用 *args 和 **kwargs 的例子：

class EventBus:
    def __init__(self):
        self.handlers = {}

    def on(self, event):
        def decorator(func):
            self.handlers.setdefault(event, []).append(func)
            return func
        return decorator

    def emit(self, event, *args, **kwargs):
        for func in self.handlers.get(event, []):
            func(*args, **kwargs)

bus = EventBus()

@bus.on("login")
def handle_login(user, ip):
    print(f"{user} login from {ip}")

bus.emit("login", "Alice", ip="127.0.0.1")