如何通过变量引用列表元素并直接修改原列表？

Hey there! I totally get where you're coming from—trying to use variables to reference list elements and update the original list directly makes sense, but it doesn't work as expected with immutable types like integers, floats, or strings. Let's break down why, and then cover the solutions that do work.

Why Your Initial Approach Didn't Work #

When you assign a list element (like an integer) to a variable, you're actually creating a copy of the value, not a reference to the element's position in the list. So when you modify the variable, you're only changing that copied value—not the original list entry. For example:

my_list = [0, 0, 0, 0, 0]
elem = my_list[2]
elem = 5  # This only changes the 'elem' variable, not my_list
print(my_list)  # Still outputs [0, 0, 0, 0, 0]

Solutions to Modify the Original List via Variables #

Here are a few straightforward ways to achieve what you want:

1. Store the Index (Not the Value) in the Variable

Instead of storing the element's value, store its position in the list. Then use that index to modify the original list directly:

my_list = [0, 0, 0, 0, 0]
elem_index = 2  # Store the index of the element you want to target
my_list[elem_index] = 5  # Modify the list using the index variable
print(my_list)  # Outputs [0, 0, 5, 0, 0]

This is the simplest approach for most cases.

2. Use Mutable Elements (If Applicable)

If your list contains mutable types (like nested lists, dictionaries, or custom objects), assigning the element to a variable will create a reference to the original object. Modifying this variable will update the original list because you're altering the object itself, not a copy of its value:

my_list = [[0], [0], [0], [0], [0]]
elem = my_list[2]
elem[0] = 5  # Modifies the nested list, which reflects in the original list
print(my_list)  # Outputs [[0], [0], [5], [0], [0]]

3. Create a Wrapper Class for Direct References

If you really need a variable that acts like a direct "pointer" to a list element, you can create a simple wrapper class. This lets you get and set the value while automatically updating the original list:

class ListElement:
    def __init__(self, target_list, index):
        self.list = target_list
        self.index = index
    
    @property
    def value(self):
        return self.list[self.index]
    
    @value.setter
    def value(self, new_val):
        self.list[self.index] = new_val

# Usage example
my_list = [0, 0, 0, 0, 0]
my_elem = ListElement(my_list, 3)
my_elem.value = 7  # Updates the original list via the wrapper
print(my_list)  # Outputs [0, 0, 0, 7, 0]

Key Takeaway #

For immutable elements (int, str, float), you can't directly reference the list entry with a variable—you need to work with the element's index instead. For mutable elements, variables will reference the original object, so modifications will carry over to the list. The wrapper class is a handy tool if you want a more intuitive "pointer" experience.

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