如何实现支持任意变量修改、按预定义优先级自动更新关联变量的函数？

我有一个基于基础算术运算的简单公式，示例代码如下：

a = 1
b = 2
c = a + b #3=1+2 
d = 4
e = c + d #7=3+4

变量间的关系可概括为：a和b共同决定c，c和d共同决定e。

理论上这些变量间的关系应始终成立，我希望编写一个函数，允许用户修改任意变量，其余变量自动更新；若存在多种更新方式，按预定义优先级执行（例如优先更新最右侧节点）。函数示例及预期输出如下：

def f():
    #default state
    state = {'a':1, 'b':2, 'c':3, 'd':4, 'e':7}
    ...
    return state

f(a=0) == {'a':0, 'b':2, 'c':2, 'd':4, 'e':6}
f(c=4) == {'a':1, 'b':3, 'c':4, 'd':4, 'e':8}
f(b=2, c=4) == {'a':2, 'b':2, 'c':4, 'd':4, 'e':8}

当修改c=4时，优先调整b的值而非a，再同步更新e。

我尝试用**kwargs和*args支持用户传入任意变量，但需要硬编码每个被修改变量的更新逻辑，请问有没有更优的实现思路？

注：此示例仅作演示，实际场景包含更多变量，且变量间的数学关系更为复杂（如对数、指数等）。

硬编码更新逻辑在变量多、关系复杂时会变得难以维护，推荐采用**「依赖规则定义+优先级驱动更新」**的模式，核心是把变量间的关系和更新规则抽象出来，而非写死每个变量的处理逻辑。

1. 定义变量的依赖与计算规则 #

为每个变量定义：

• 正向计算表达式（从其他变量推导当前变量的逻辑）
• 反向更新优先级列表（当前变量被修改时，优先推导更新的依赖变量顺序）

用字典存储这些规则，示例如下：

import math

# 变量规则：key为变量名，value=(正向计算函数, 反向更新优先级列表)
var_rules = {
    'a': (lambda s: s['c'] - s['b'], []),  # a只能由c、b推导，修改a时无需反向更新其他变量
    'b': (lambda s: s['c'] - s['a'], []),
    'c': (lambda s: s['a'] + s['b'], ['b', 'a']),  # 修改c时，优先更新b，再更新a
    'd': (lambda s: s['e'] - s['c'], []),
    'e': (lambda s: s['c'] + s['d'], ['d', 'c']),  # 修改e时，优先更新d，再更新c
    # 复杂运算示例：x=ln(y), y=exp(x)
    'x': (lambda s: math.log(s['y']), []),
    'y': (lambda s: math.exp(s['x']), ['x'])
}

# 默认状态
default_state = {'a':1, 'b':2, 'c':3, 'd':4, 'e':7}

2. 实现通用更新逻辑 #

编写通用函数，按以下步骤执行：

1. 初始化状态，覆盖用户传入的修改值，标记这些变量为「已锁定」（避免被反向更新）
2. 处理反向更新：遍历被锁定变量的反向优先级列表，更新未锁定的依赖变量
3. 正向更新所有未锁定的变量，确保所有变量关系最终一致

示例实现：

def update_state(**kwargs):
    state = default_state.copy()
    # 应用用户修改，锁定这些变量不被反向更新
    locked_vars = set(kwargs.keys())
    state.update(kwargs)

    # 处理反向更新：当锁定变量是推导变量时，按优先级更新依赖变量
    for var in locked_vars:
        if var in var_rules:
            _, reverse_priority = var_rules[var]
            for dep_var in reverse_priority:
                if dep_var not in locked_vars:
                    # 反向推导计算依赖变量的值
                    state[dep_var] = var_rules[dep_var][0](state)
                    locked_vars.add(dep_var)

    # 正向更新未锁定的变量，按依赖链顺序（c依赖a/b，e依赖c/d）
    update_order = ['c', 'e', 'x', 'y']
    for var in update_order:
        if var not in locked_vars:
            state[var] = var_rules[var][0](state)

    return state

# 测试验证
print(update_state(a=0) == {'a':0, 'b':2, 'c':2, 'd':4, 'e':6})  # True
print(update_state(c=4) == {'a':1, 'b':3, 'c':4, 'd':4, 'e':8})  # True
print(update_state(b=2, c=4) == {'a':2, 'b':2, 'c':4, 'd':4, 'e':8})  # True

3. 复杂场景扩展 #

• 若变量依赖链更长，可引入拓扑排序生成更新顺序，确保每个变量的依赖先被处理，避免计算错误
• 新增变量时，只需在var_rules中添加对应的计算函数和优先级，无需修改核心更新逻辑

核心优势 #

• 可维护性：修改或新增变量关系时，仅需更新规则字典，无需改动核心逻辑
• 灵活性：轻松支持对数、指数等复杂运算，反向更新优先级可自由配置
• 扩展性：可快速适配大量变量，避免硬编码带来的冗余代码

内容的提问来源于stack exchange，提问作者B.Mr.W.