Why Did Changing My Python List Also Change My Other List?

You're working with data, and you have a list of items. You need to make a "copy" of this list so you can modify the copy without affecting the original. It seems straightforward enough:

Python

original_scores = [85, 90, 78]

# Attempt to "copy" the list
new_scores = original_scores

# Now, let's modify the 'new_scores' list
new_scores[0] = 95

print(f"Original Scores: {original_scores}")
print(f"New Scores: {new_scores}")

You run this code, expecting original_scores to remain [85, 90, 78] and new_scores to become [95, 90, 78].

But the output is a shocker:

Original Scores: [95, 90, 78]
New Scores: [95, 90, 78]

Both lists changed! What just happened? You only modified new_scores, yet original_scores was also altered. This isn't a bug in Python; it's a fundamental concept about how Python handles variables and memory, and understanding it is crucial to avoid unexpected side effects in your programs.

The Problem: References, Not Copies

When you wrote new_scores = original_scores, you didn't create a new list. Instead, you created a new reference to the exact same list object in your computer's memory.

Think of it like this:

• original_scores is a label tied to a box of scores.

• When you say new_scores = original_scores, you're just tying another label (new_scores) to that very same box.

So, when you modify the contents of the box using either label, you're changing the one and only box. Both labels still point to that single, modified box.

This is true for all mutable objects in Python, such as lists, dictionaries, and sets. Immutable objects (like numbers, strings, and tuples, as we discussed in [Why Did Python Give a TypeError When I Tried to Change My Tuple?] (<- INTERNAL LINK)) behave differently, but for lists, this reference behavior is key.

The Solution: Explicitly Making a Copy

To truly create an independent copy that you can modify without affecting the original, you need to explicitly tell Python to make a new object in memory. There are several ways to do this, depending on the complexity of your list.

1. Slicing (For Simple Lists - Shallow Copy)

The simplest way to make a copy of a list is by using slicing. This creates a new list containing all the elements of the original.

Python

original_scores = [85, 90, 78]

# Create a true copy using slicing
new_scores = original_scores[:]

new_scores[0] = 95

print(f"Original Scores: {original_scores}") # Output: Original Scores: [85, 90, 78]
print(f"New Scores: {new_scores}")           # Output: New Scores: [95, 90, 78]

Now, the original_scores list remains untouched.

2. Using list() Constructor (For Simple Lists - Shallow Copy)

Another straightforward method is to pass the original list to the list() constructor.

Python

original_scores = [85, 90, 78]

# Create a true copy using list() constructor
new_scores = list(original_scores)

new_scores[0] = 95

print(f"Original Scores: {original_scores}") # Output: Original Scores: [85, 90, 78]
print(f"New Scores: {new_scores}")           # Output: New Scores: [95, 90, 78]

Both slicing and list() create a shallow copy. For lists containing only immutable items (like numbers, strings, tuples), a shallow copy is usually sufficient.

3. The copy Module (For Complex Lists - Shallow vs. Deep Copy)

What if your list contains other lists (a "list of lists") or dictionaries? This is where it gets tricky, and you need the copy module.

Python

import copy

original_data = [[1, 2], [3, 4]]

# A. Shallow copy (using slicing or list() or copy.copy())
shallow_copy = original_data[:] # or list(original_data) or copy.copy(original_data)

shallow_copy[0][0] = 99 # Change an item in the INNER list of the shallow copy

print(f"Original data (after shallow change): {original_data}") # Output: [[99, 2], [3, 4]] - OH NO, original changed!
print(f"Shallow copy: {shallow_copy}")                           # Output: [[99, 2], [3, 4]]

A shallow copy creates a new list, but if the original list contains other mutable objects (like sub-lists), the new list will still contain references to those original inner objects. So, changing an inner item in the shallow copy will still affect the original.

This is where a deep copy comes in. It creates a completely independent copy of the original object and all the objects nested inside it.

Python

import copy

original_data = [[1, 2], [3, 4]]

# B. Deep copy (using copy.deepcopy())
deep_copy = copy.deepcopy(original_data)

deep_copy[0][0] = 99 # Change an item in the INNER list of the deep copy

print(f"Original data (after deep change): {original_data}") # Output: [[1, 2], [3, 4]] - Original is SAFE!
print(f"Deep copy: {deep_copy}")                             # Output: [[99, 2], [3, 4]]

Frequently Asked Questions (FAQs)

1. Why does Python behave this way? It seems confusing.

It's an optimization. Copying large data structures is expensive in terms of memory and processing time. By default, Python assumes you want a reference unless you explicitly ask for a copy. This is efficient when you just need multiple ways to access the same data.

2. How can I tell if two variables refer to the exact same object?

Use the is operator. variable_a is variable_b will return True if they point to the exact same object in memory, and False if they are different objects (even if their contents are identical).

3. Does this apply to dictionaries too?

Yes, exactly the same. dict_a = dict_b creates a reference. Use dict_a = dict_b.copy() (shallow) or dict_a = copy.deepcopy(dict_b) (deep) for true copies.

Conclusion: Understanding Your Data's Identity

The mystery of one list changing when you modified another is solved by understanding references vs. copies. This distinction is fundamental to working with mutable objects in Python and is a common source of subtle bugs for new programmers.

You now have the tools to control how your data is duplicated, ensuring your modifications don't unexpectedly affect other parts of your program. This precision in data handling is a hallmark of robust and error-free Python code.