Python中如何通过单次哈希完成字典元素的读取与更新？

问题描述 #

在密集循环场景中，Python字典常规的「读取旧值+更新」操作会触发两次哈希计算：一次是dict_obj[key]读取时，另一次是dict_obj[key] = new_value赋值时，导致不必要的性能开销。需要实现类似C++ map.find的逻辑：仅通过一次哈希操作，同时获取键对应的旧值并更新字典，且不能通过将哈希值作为键的方式规避（哈希冲突会导致逻辑失效）。

常规实现示例（两次哈希）：

my_dict = {"A":5}

def read_and_update(dict_obj, key, new_value):
    old_value = dict_obj[key]
    dict_obj[key] = new_value
    return old_value

old_value = read_and_update(my_dict, "A", 3)
print(old_value)
print(my_dict)

输出：

5
{'A': 3}

解决方案 #

核心结论 #

Python标准库的公开接口中没有直接支持单次哈希完成读旧值+更新的方法，必须通过直接操作字典底层实现来达成目标，以下是两种可行方案：

1. 编写C扩展（推荐生产环境）

CPython的字典底层通过哈希值定位槽位，我们可以通过C扩展调用内部API，仅计算一次哈希值就完成查找旧值和更新操作：

简化的C扩展核心代码：

#include <Python.h>

static PyObject* dict_read_and_update(PyObject* self, PyObject* args) {
    PyObject *dict, *key, *new_val;
    if (!PyArg_ParseTuple(args, "OOO", &dict, &key, &new_val)) {
        return NULL;
    }

    if (!PyDict_Check(dict)) {
        PyErr_SetString(PyExc_TypeError, "First argument must be a dictionary");
        return NULL;
    }

    // 仅计算一次哈希值
    Py_hash_t hash_val = PyObject_Hash(key);
    if (hash_val == -1) {
        return NULL;
    }

    // 复用哈希值查找槽位
    Py_ssize_t pos = _PyDict_GetItem_KnownHash(dict, key, hash_val);
    if (pos == -1) {
        PyErr_SetString(PyExc_KeyError, PyUnicode_AsUTF8(key));
        return NULL;
    }

    // 获取旧值并增加引用计数
    PyObject* old_val = PyDict_GetItem(dict, key);
    Py_INCREF(old_val);

    // 复用哈希值更新字典
    if (PyDict_SetItemWithHash(dict, key, new_val, hash_val) != 0) {
        Py_DECREF(old_val);
        return NULL;
    }

    return old_val;
}

static PyMethodDef DictMethods[] = {
    {"read_and_update", dict_read_and_update, METH_VARARGS, "Read old value and update dict with single hash"},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef dictmodule = {
    PyModuleDef_HEAD_INIT,
    "fastdict",
    NULL,
    -1,
    DictMethods
};

PyMODINIT_FUNC PyInit_fastdict(void) {
    return PyModule_Create(&dictmodule);
}

编译扩展后，即可在Python中导入使用，整个过程仅执行一次哈希计算。

2. 用ctypes调用内部API（仅适合测试/临时场景）

如果不想编写完整的C扩展，可以通过ctypes直接调用CPython的内部字典函数，但该方法依赖Python版本和实现细节，兼容性差：

import ctypes
from ctypes import pythonapi, py_object, c_ssize_t

# 绑定CPython内部函数
pythonapi.PyDict_GetItemWithHash.argtypes = [py_object, py_object, c_ssize_t]
pythonapi.PyDict_GetItemWithHash.restype = py_object
pythonapi.PyDict_SetItemWithHash.argtypes = [py_object, py_object, py_object, c_ssize_t]
pythonapi.PyDict_SetItemWithHash.restype = ctypes.c_int

def read_and_update(dict_obj, key, new_value):
    hash_val = hash(key)
    # 复用哈希值获取旧值
    old_val = pythonapi.PyDict_GetItemWithHash(dict_obj, key, hash_val)
    if old_val is None:
        raise KeyError(key)
    # 复用哈希值更新字典
    if pythonapi.PyDict_SetItemWithHash(dict_obj, key, new_value, hash_val) != 0:
        raise RuntimeError("Failed to update dictionary")
    return old_val

# 测试
my_dict = {"A":5}
old_val = read_and_update(my_dict, "A", 3)
print(old_val)
print(my_dict)

注意：该方法在CPython版本更新后可能失效，不建议用于生产环境。

纯Python的局限性 #

纯Python中，即使使用dict.pop(key)后再赋值，本质上还是两次哈希计算（pop一次，赋值一次），无法实现单次哈希的目标。只有直接操作底层哈希定位逻辑，才能满足性能需求。

内容的提问来源于stack exchange，提问作者Ahmed AEK