This is one of the most important conceptual posts in this entire section. Understanding the difference between assigning a list and copying a list will save you from hours of debugging mysterious and frustrating bugs.
Because lists are mutable (a concept we covered in Post #49), the way we duplicate them is critically important. A simple equals sign (=) does not do what you might think it does. In this post, we’ll demonstrate this common pitfall and show you the correct ways to create an independent copy of a list.
The Pitfall: Assignment Creates a Reference, Not a Copy
When you’re starting out, it’s natural to assume that new_list = old_list creates a new, independent list. Let’s test that theory and see what happens.
# Let's start with an original list
original_list = [1, 2, 3]
# We might think this creates a copy
new_list = original_list
# Now, let's modify the 'new' list
print(f"Before modification, new_list is: {new_list}")
new_list.append(4)
print(f"After modification, new_list is: {new_list}")
# Here is the surprise... let's check the original list
print(f"The original_list is now: {original_list}")The output is surprising and often the source of bugs:
Before modification, new_list is: [1, 2, 3]
After modification, new_list is: [1, 2, 3, 4]
The original_list is now: [1, 2, 3, 4]Even though we only modified new_list, the original_list was also changed!
Why does this happen? A list variable is not the list itself; it’s more like a label or a pointer to a list object that exists in your computer’s memory. When you write new_list = original_list, you are not creating a new list. You are simply putting a second label on the exact same list object. Any changes made through either label will affect the one and only list.
The Solution: Creating a True (Shallow) Copy
To get a truly separate and independent list, you must explicitly create a copy. Here are the two most common ways to do this for simple lists.
Method 1: Using a Full Slice [:]
As we briefly saw in Post #48, taking a full slice of a list is a concise and “Pythonic” way to create a copy.
original_list = [1, 2, 3]
# Create a true copy using slicing
copied_list = original_list[:]
# Now, modify the copy
copied_list.append(4)
print(f"The copied list is: {copied_list}")
print(f"The original list is UNCHANGED: {original_list}")The output is now what we expect:
The copied list is: [1, 2, 3, 4]
The original list is UNCHANGED: [1, 2, 3]Method 2: Using the .copy() Method
For clarity, Python lists also have a built-in .copy() method that does the same thing. This is often preferred because it makes your intention to create a copy very clear to anyone reading your code.
original_list = [1, 2, 3]
# Create a true copy using the .copy() method
copied_list = original_list.copy()
# Modify the copy
copied_list.append(4)
print(f"The copied list is: {copied_list}")
print(f"The original list is UNCHANGED: {original_list}")The result is identical to using the slicing method.
A Note on Shallow vs. Deep Copies
The methods we’ve just learned ([:] and .copy()) create what are called shallow copies. This works perfectly for simple lists like the ones we’ve used. However, if you have a list that contains other lists (a nested list), a shallow copy will still share the inner lists. Copying these nested structures requires a deep copy, which is a more advanced topic we’ll save for later.
What’s Next?
Remember this crucial rule: assignment (=) makes a second name for the same list; slicing ([:]) or the .copy() method makes a new, independent list. Understanding this is vital when working with mutable data.
Our brief mention of “nested lists” is the perfect segue to our next topic. How do we represent data that has rows and columns, like a spreadsheet, a tic-tac-toe board, or a map? We can do this by putting lists inside other lists. In Post #55, we will get started with 2D lists.
Author
Experienced Cloud & DevOps Engineer with hands-on experience in AWS, GCP, Terraform, Ansible, ELK, Docker, Git, GitLab, Python, PowerShell, Shell, and theoretical knowledge on Azure, Kubernetes & Jenkins. In my free time, I write blogs on ckdbtech.com