如何通过Python字典修改变量引用指向而非仅更新字典值？

Great question! Let's break down how Python's variable binding works, then answer whether (and how) you can do this with a dictionary.

First, let's recap your core confusion: when you store a variable like n2 in a dictionary, modifying the dictionary's entry doesn't change what n2 points to. That's because in Python, variables are just names bound to objects—n2 and d['hi_n2'] are separate bindings that happen to point to the same object initially. Changing one binding doesn't affect the other.

So can you use a dictionary to make n2 point to n3, just like running n2 = n3? Yes—but you need to work with how Python's naming system works instead of against it. Here are two reliable approaches:

Approach 1: Modify the variable's namespace directly #

Python stores global variables in a dictionary accessible via globals(), and local variables (in functions) via locals() (though locals() has some quirks). You can store the variable's name in your dictionary, then use the namespace dict to reassign its binding.

Example with global variables: #

class Node:
    def __init__(self, val):
        self.val = val

n2 = Node(2)
# Store the NAME of the variable in the dictionary, not the object
d = {'target_var': 'n2'}

n3 = Node(3)
# Use globals() to find and reassign the variable's binding
globals()[d['target_var']] = n3

print(n2.val)  # Outputs 3—success!

Example with local variables (in a function): #

For function-local variables, it's safer to use a custom namespace dict instead of relying on locals():

def update_reference():
    class Node:
        def __init__(self, val):
            self.val = val
    
    # Custom namespace to hold our variables
    local_ns = {}
    local_ns['n2'] = Node(2)
    d = {'target_var': 'n2'}

    local_ns['n3'] = Node(3)
    # Reassign the binding in our custom namespace
    local_ns[d['target_var']] = local_ns['n3']

    print(local_ns['n2'].val)  # Outputs 3

update_reference()

Approach 2: Use a mutable container to hold the reference #

Instead of storing the variable directly in the dictionary, wrap it in a mutable object (like a list or custom class). This way, you can modify the object inside the container, and any code that accesses the container will see the updated reference.

Example with a list container: #

class Node:
    def __init__(self, val):
        self.val = val

# Wrap n2's object in a list (mutable)
ref_container = [Node(2)]
# Access the object via the container if you want the latest version
n2 = ref_container[0]

d = {'hi_n2': ref_container}

n3 = Node(3)
# Modify the container's contents to point to n3
d['hi_n2'][0] = n3

# Note: If you already bound n2 to the old object, you'll need to re-bind it
n2 = ref_container[0]
print(n2.val)  # Outputs 3

Example with a custom holder class: #

For clearer code, you can create a simple class to manage the reference:

class Node:
    def __init__(self, val):
        self.val = val

class RefHolder:
    def __init__(self, obj):
        self.obj = obj

holder = RefHolder(Node(2))
d = {'hi_n2': holder}

n3 = Node(3)
# Update the holder's stored object
d['hi_n2'].obj = n3

# Access the latest object via the holder
print(holder.obj.val)  # Outputs 3
# If you want n2 to point to this new object, re-bind it
n2 = holder.obj
print(n2.val)  # Outputs 3

Why your original approach didn't work #

To clarify, when you did:

val_in_d = d['hi_n2']
val_in_d = Node(3)

You weren't modifying the dictionary's entry or the n2 variable—you were just re-binding the val_in_d name to a new object. n2 and d['hi_n2'] still pointed to the original Node(2) because they're separate bindings.

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