如何在Python中实现列表元素引用复制及二维数组列双向同步？

1. Copying List Elements by Reference #

In Python, how you "copy" a list element depends entirely on whether the element is mutable or immutable:

• For mutable objects (like lists, dictionaries, custom classes): Assigning the element to a variable creates a reference automatically. Any changes to the variable will reflect in the original list, since they point to the same underlying object:

  my_list = [[1], [2], [3]]
  elem = my_list[0]
  elem[0] = 100  # This modifies my_list[0] too!
  print(my_list)  # Output: [[100], [2], [3]]
  

• For immutable objects (like int, str, tuple): You can't modify the object itself—any "change" creates a new object. To update the original list, you have to modify the list directly instead of the stored element:

  my_list = [1, 2, 3]
  elem = my_list[0]
  elem = 100  # This doesn't affect my_list
  my_list[0] = 100  # This does
  print(my_list)  # Output: [100, 2, 3]
  

So if you want a dynamic reference to a list element, mutable types work out of the box. For immutables, you need to interact with the list's index directly rather than storing the element value.

2. Creating Synced Column References (C-like Pointer Behavior) #

Python's built-in lists don't support dynamic column views natively—your list comprehension creates a static copy of current values, not a live reference. But there are two efficient ways to replicate the C-like behavior you want:

Option 1: Build a Custom Proxy Class #

You can create a lightweight wrapper class that dynamically accesses or modifies the original 2D list's column elements. This avoids generating new lists and keeps everything in sync:

class ColumnProxy:
    def __init__(self, arr, col_idx):
        self.arr = arr
        self.col_idx = col_idx
    
    def __getitem__(self, row_idx):
        return self.arr[row_idx][self.col_idx]
    
    def __setitem__(self, row_idx, value):
        self.arr[row_idx][self.col_idx] = value
    
    def __repr__(self):
        return str([self.arr[i][self.col_idx] for i in range(len(self.arr))])

# Usage example
foo_arr = [[None]*4 for _ in range(4)]
column_0 = ColumnProxy(foo_arr, 0)

# Modify original array
foo_arr[0][0] = (0, 0)
foo_arr[1][0] = (0, 1)
print(column_0)  # Output: [(0, 0), (0, 1), None, None]

# Modify via column proxy
column_0[2] = (0, 2)
print(foo_arr[2][0])  # Output: (0, 2)

This class uses Python's special methods (__getitem__, __setitem__) to act as a dynamic window into the original array. It doesn't store any duplicate data—every access or modification hits the original list directly.

Option 2: Use NumPy Arrays (Simpler for Data Workloads) #

NumPy is purpose-built for this kind of scenario. Array slicing creates views (references to the original data) instead of copies, so column access is efficient and automatically synced:

import numpy as np

# Create a 4x4 array with None (use object dtype for non-numeric values)
foo_arr = np.full((4, 4), None, dtype=object)

# Get column 0 as a live view
column_0 = foo_arr[:, 0]

# Modify original array
foo_arr[0, 0] = (0, 0)
foo_arr[1, 0] = (0, 1)
print(column_0)  # Output: [(0, 0) (0, 1) None None]

# Modify via column view
column_0[2] = (0, 2)
print(foo_arr[2, 0])  # Output: (0, 2)

For numerical data (ints, floats), use a numeric dtype (like int or float) instead of object for even better performance. NumPy handles all the memory management under the hood, so changes to either the original array or column view are instantly reflected in both.

Key Takeaways #

• The custom proxy class works with standard Python lists and supports any data type, but requires a small amount of boilerplate.
• NumPy is the optimal choice for large datasets or numerical work—it's optimized for speed and has native support for dynamic views.
• Both approaches avoid creating new lists on every column access, making them efficient for repeated operations.

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