如何查询列表中指定索引的历史变更记录？

Great question! Unfortunately, Python's built-in list doesn't have any native functionality to track the historical values of specific indices after modifications. When you perform operations like inserting, deleting, or overwriting elements, the list modifies its data directly without automatically keeping a log of past states or index values.

But don't worry—for your use case (where the list goes through multiple modifications and you need to trace back what was in a specific index at some point), there are a few solid solutions:

1. Build a Custom Tracked List Class #

This is the most flexible approach. We can create a subclass of list that logs every change to index values, so you can query the history of any index later. Here's a working example:

class TrackedList(list):
    def __init__(self, *args):
        super().__init__(*args)
        # Dictionary to store history: key = index, value = list of past values
        self.index_history = {}
        # Initialize history with the original list elements
        for idx, val in enumerate(self):
            self.index_history[idx] = [val]

    def insert(self, idx, value):
        # Shift history for all indices >= the insertion point (since they'll move right)
        for existing_idx in list(self.index_history.keys()):
            if existing_idx >= idx:
                self.index_history[existing_idx + 1] = self.index_history.pop(existing_idx)
        # Log the new value for the inserted index
        self.index_history[idx] = [value]
        super().insert(idx, value)

    def __setitem__(self, idx, value):
        # Add the new value to the index's history before updating
        if idx in self.index_history:
            self.index_history[idx].append(value)
        else:
            self.index_history[idx] = [value]
        super().__setitem__(idx, value)

    def pop(self, idx=-1):
        popped_val = super().pop(idx)
        # Remove the popped index's history and shift subsequent indices left
        self.index_history.pop(idx, None)
        for existing_idx in list(self.index_history.keys()):
            if existing_idx > idx:
                self.index_history[existing_idx - 1] = self.index_history.pop(existing_idx)
        return popped_val

    def get_index_history(self, idx):
        # Retrieve all past values for a given index
        return self.index_history.get(idx, [])

How to Use It: #

my_list = TrackedList([1, 2, 3])
my_list.insert(0, 4)  # Now my_list is [4, 1, 2, 3]
my_list[0] = 5        # Update index 0 to 5
my_list.insert(1, 6)  # Insert 6 at index 1

print(my_list.get_index_history(0))  # Output: [1, 4, 5]
# Breakdown: Original index 0 was 1, then we inserted 4 there, then updated to 5
print(my_list.get_index_history(1))  # Output: [2, 6]
# Breakdown: Original index 1 was 2, then we inserted 6 at index 1 (shifting 2 to index 2)

You can extend this class to handle other list operations like append, remove, or clear if you need to track those too.

2. Log All Operations to Revert States #

If you need to roll back the entire list to a previous state (instead of just checking an index's history), you can log every operation and replay them up to a certain point. Here's a simple implementation:

class LoggedList(list):
    def __init__(self, *args):
        super().__init__(*args)
        self.operation_log = []
        # Log the initial state of the list
        self.operation_log.append(("init", list(self)))

    def insert(self, idx, value):
        self.operation_log.append(("insert", idx, value))
        super().insert(idx, value)

    def __setitem__(self, idx, value):
        # Log both the old and new value for the index
        old_val = self[idx]
        self.operation_log.append(("set", idx, old_val, value))
        super().__setitem__(idx, value)

    def pop(self, idx=-1):
        popped_val = self[idx] if idx != -1 else self[-1]
        self.operation_log.append(("pop", idx, popped_val))
        return super().pop(idx)

    def revert_to_step(self, step_num):
        # Reset the list and replay operations up to the target step
        self.clear()
        if step_num == 0:
            self.extend(self.operation_log[0][1])
            return
        # Start with the initial state and apply operations up to step_num
        self.extend(self.operation_log[0][1])
        for op in self.operation_log[1:step_num+1]:
            if op[0] == "insert":
                super().insert(op[1], op[2])
            elif op[0] == "set":
                super().__setitem__(op[1], op[3])
            elif op[0] == "pop":
                super().pop(op[1])

How to Use It: #

my_list = LoggedList([1, 2, 3])
my_list.insert(0, 4)  # Step 1: List becomes [4,1,2,3]
my_list[0] = 5        # Step 2: List becomes [5,1,2,3]

# Revert to step 1 (right after inserting 4)
my_list.revert_to_step(1)
print(my_list)  # Output: [4, 1, 2, 3]

# Revert back to the initial state
my_list.revert_to_step(0)
print(my_list)  # Output: [1, 2, 3]

3. Third-Party Libraries (If You Prefer Not to Code) #

If you don't want to build your own solution, there are third-party tools that handle data versioning. For example, if you're working with structured data, pandas DataFrames have built-in functionality to track changes. For more general use cases, libraries like dvc (Data Version Control) can help, but these are usually overkill for simple list tracking—custom classes are lighter and more tailored to your needs.

In short: Python's default list can't do this out of the box, but with a little custom code, you can easily track index history or revert to past states.

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