How to copy a list in Python

You will often need to copy a list in Python. It is vital to know the difference between shallow and deep copies to prevent unexpected bugs and ensure your data behaves as intended.

In this article, you'll learn several techniques to copy lists, from the slice operator to the copy module. You'll also find practical tips, real-world applications, and advice on how to debug common issues.

Using the slice operator [:]

original_list = [1, 2, 3, 4, 5]
copied_list = original_list[:]
print(f"Original: {original_list}")
print(f"Copy: {copied_list}")--OUTPUT--Original: [1, 2, 3, 4, 5]
Copy: [1, 2, 3, 4, 5]

The slice operator [:] offers a quick and idiomatic way to create a shallow copy. By assigning original_list[:] to copied_list, you're creating an entirely new list populated with all the elements from the original. This means the two lists exist independently in different memory locations.

Because they are separate objects, modifying one won't affect the other, which is crucial for preventing unintended side effects in your code. This method is especially handy because it's built-in, requiring no external modules, and is widely understood by Python developers.

Basic copying methods

In addition to the slice operator, you can also create shallow copies using the list() constructor, the .copy() method, or a simple list comprehension.

Using the list() constructor

original_list = [1, 2, 3, 4, 5]
copied_list = list(original_list)
print(copied_list)
print(f"Same object? {copied_list is original_list}")--OUTPUT--[1, 2, 3, 4, 5]
Same object? False

The list() constructor is another straightforward way to create a shallow copy. When you pass an existing list to it, Python generates a brand new list containing all the elements from the original.

• As the code demonstrates, the expression copied_list is original_list evaluates to False. This confirms they are separate objects, so you can modify one without affecting the other.

Using the .copy() method

original_list = ["apple", "banana", "cherry"]
copied_list = original_list.copy()
copied_list.append("date")
print(f"Original: {original_list}")
print(f"Modified copy: {copied_list}")--OUTPUT--Original: ['apple', 'banana', 'cherry']
Modified copy: ['apple', 'banana', 'cherry', 'date']

The .copy() method, available on all list objects, provides an explicit and readable way to create a shallow copy. It functions just like the slice operator and the list() constructor, generating a new list object.

• As the example shows, appending "date" to the copied_list doesn't alter the original_list, confirming they are separate entities.

This method is often favored for its self-documenting nature—its name clearly communicates the intent to create a copy.

Using list comprehension

original_list = [10, 20, 30, 40]
copied_list = [item for item in original_list]
original_list[0] = 99
print(f"Original (modified): {original_list}")
print(f"Copy (unchanged): {copied_list}")--OUTPUT--Original (modified): [99, 20, 30, 40]
Copy (unchanged): [10, 20, 30, 40]

A list comprehension also provides a flexible way to create a shallow copy. The expression [item for item in original_list] iterates through each element in the original list and builds an entirely new one from them, resulting in a separate object.

• While more verbose than other methods for a simple copy, its power lies in its flexibility. You could easily filter or transform items during the copy process with vibe coding.
• As the code demonstrates, the resulting copy is a distinct object, so modifications to the original don't impact it.

Advanced copying techniques

Beyond the basic techniques, Python provides the copy module for both shallow and deep copies, along with the flexible map() function for more specialized needs.

Using copy module for shallow copies

import copy
nested_list = [1, [2, 3], 4]
shallow_copy = copy.copy(nested_list)
nested_list[1][0] = 'X'
print(f"Original: {nested_list}")
print(f"Shallow copy: {shallow_copy}")--OUTPUT--Original: [1, ['X', 3], 4]
Shallow copy: [1, ['X', 3], 4]

The copy module provides the copy.copy() function, which is another way to create a shallow copy. While it creates a new top-level list, it doesn't create copies of the objects inside. Instead, it populates the new list with references to the original items.

• This distinction is critical when your list contains other mutable objects, like a nested list. As the code shows, modifying the inner list with nested_list[1][0] = 'X' affects both the original and the shallow_copy because they both point to the exact same inner list object.

Using copy module for deep copies

import copy
nested_list = [1, [2, 3], 4]
deep_copy = copy.deepcopy(nested_list)
nested_list[1][0] = 'X'
print(f"Original: {nested_list}")
print(f"Deep copy: {deep_copy}")--OUTPUT--Original: [1, ['X', 3], 4]
Deep copy: [1, [2, 3], 4]

When you need a completely independent copy of a list and all its contents, use the copy.deepcopy() function. Unlike a shallow copy, a deep copy recursively duplicates every object it finds. This creates a brand new structure that shares nothing with the original, following the same principles of deep copying in Python.

• As the code shows, modifying the nested list in the original_list has no effect on the deep_copy. This is because deepcopy created a separate copy of the inner list, not just a reference to it.

Using map() function to copy a list

original_list = ["hello", "world", "python"]
copied_list = list(map(lambda x: x, original_list))
print(copied_list)
print(f"Same list? {copied_list is original_list}")--OUTPUT--['hello', 'world', 'python']
Same list? False

The map() function provides a functional programming approach to copying. It works by applying a given function to every item in your list. In this case, the lambda x: x function is an identity function—it simply returns each element as is, creating a shallow copy.

• The map() function itself returns a special map object, which is an iterator. That's why you need to wrap the result in the list() constructor to create an actual new list.
• While more verbose for a simple copy, this method is powerful if you need to transform elements during the process.

Move faster with Replit

Replit is an AI-powered development platform that comes with all Python dependencies pre-installed, so you can skip setup and start coding instantly. But knowing individual techniques is just the first step. To go from an idea to a working product, you can use Agent 4, which handles everything from writing code to managing databases and APIs, all from a simple description.

Instead of piecing together different copying methods, you can describe the final tool you want, and Agent will build it:

• A configuration manager that creates shallow copies of a base template for different environments.
• A version control system for a document that uses deep copies to save completely independent historical snapshots.
• A data processing utility that filters and transforms items from a source list into a new one for reports.

Simply describe your app, and Replit will write the code, test it, and fix issues automatically, all within your browser.

Common errors and challenges

Even with the right tools, you can run into tricky situations if you're not careful about how you copy lists in Python.

Mistaking = assignment for copying

A frequent mistake is thinking the assignment operator = creates a copy. It doesn't. Instead, it just creates a new variable that points to the exact same list object in memory. Think of it as giving two different names to the same list.

Because both variables reference the same object, any change made through one variable—like adding or removing an element—will be visible through the other. This can lead to confusing bugs where data changes unexpectedly.

Problems when removing items during for loop iteration

Modifying a list while iterating over it with a for loop can cause unpredictable behavior. When you remove an item, you're changing the list's size and shifting the indices of the remaining elements, which can cause the loop to skip over items.

The iterator doesn't know the list has changed, so it proceeds to the next index, which might now be an entirely different element than you expected. The safe way to handle this is to iterate over a shallow copy, like for item in original_list[:]:, while modifying the original list.

Shallow copy limitations with nested dictionaries

The limitations of shallow copies aren't just for nested lists; they also apply when your list contains other mutable objects like dictionaries. A shallow copy will create a new list but populate it with references to the original dictionaries inside, similar to the challenges when copying dictionaries in Python.

If you change a value within a dictionary in the copied list, that change will also appear in the original list because both lists point to the same dictionary objects. For true independence, you need to use copy.deepcopy() to ensure every nested object is duplicated.

Mistaking = assignment for copying

It's a classic beginner's mistake to think the assignment operator (=) copies a list. It doesn't—it just creates another name pointing to the same list in memory. Because both variables reference the same object, any change will affect both.

The code below demonstrates this behavior. Watch what happens to the original list when the "copy" is modified.

original_list = [1, 2, 3, 4, 5]
copied_list = original_list
copied_list.append(6)
print(f"Original: {original_list}")
print(f"Copy: {copied_list}")

The output shows that appending 6 to copied_list also modifies original_list. This is a classic side effect of simple assignment. The code below demonstrates how to achieve the expected behavior.

original_list = [1, 2, 3, 4, 5]
copied_list = original_list[:]
copied_list.append(6)
print(f"Original: {original_list}")
print(f"Copy: {copied_list}")

By using the slice operator [:], you're creating a shallow copy. This means copied_list is an entirely new and separate object, not just another name for the original. As a result, when you append 6 to the copy, the original list remains completely unchanged, preventing unexpected side effects.

This is the proper way to duplicate a list when you intend to modify the copy independently. It's especially important when passing lists to functions that might alter them.

Problems when removing items during for loop iteration

It's a common trap: trying to remove items from a list while you're still looping over it. This can cause the loop to skip elements, leading to incomplete results. Proper techniques for removing items from a list can help avoid these issues. The following code attempts to remove all even numbers—but the output isn't what you'd expect.

numbers = [1, 2, 3, 4, 5]
for num in numbers:
if num % 2 == 0:
numbers.remove(num)
print(numbers)

The loop skips checking the number 3. When 2 is removed, the list shrinks, and the iterator advances to the next index, which now contains 4. The following code shows how to solve this problem.

numbers = [1, 2, 3, 4, 5]
numbers = [num for num in numbers if num % 2 != 0]
print(numbers)

The list comprehension [num for num in numbers if num % 2 != 0] solves the problem by building an entirely new list. It iterates over the original list and includes only the elements that satisfy the condition—in this case, the odd numbers. This new list then replaces the old one.

• This approach is much safer because you aren't modifying the list you're iterating over, which prevents the loop from skipping elements unexpectedly.

Shallow copy limitations with nested dictionaries

Shallow copies are deceptive when your list contains dictionaries. You get a new top-level list, but the dictionaries inside are just references, not new copies. This means changing a dictionary in the copied list also alters the original. The code below shows this in action.

users = [{"name": "Alice", "role": "admin"}, {"name": "Bob", "role": "user"}]
users_copy = users[:]
users_copy[0]["role"] = "guest"
print(f"Original: {users}")
print(f"Copy: {users_copy}")

The output shows both lists changed because the shallow copy only duplicated the list, not the dictionaries inside. Both lists point to the same dictionary objects. The following code demonstrates how to achieve true independence between the two.

import copy
users = [{"name": "Alice", "role": "admin"}, {"name": "Bob", "role": "user"}]
users_copy = copy.deepcopy(users)
users_copy[0]["role"] = "guest"
print(f"Original: {users}")
print(f"Copy: {users_copy}")

The copy.deepcopy() function solves this by creating a truly independent copy. It recursively duplicates every object, including the nested dictionaries inside. As a result, modifying a dictionary in the users_copy list leaves the original users list completely untouched.

• This is essential whenever your lists contain other mutable objects, like dictionaries or other lists, to prevent unintended data corruption and ensure the original data remains pristine.

Real-world applications

Knowing when to use [:] versus copy.deepcopy() is key for building reliable features like filtered lists and configuration managers, especially when using AI coding.

Creating a filtered product list with [:] slice operator

When you need to create a filtered version of a list without changing the original, making a shallow copy with the slice operator [:] is a simple and effective solution. This approach works well alongside other techniques for filtering a list in Python.

products = ["Laptop", "Phone", "Tablet", "Headphones", "Monitor"]
electronics_copy = products[:] # Create a copy using slice operator

# Filter out certain products from the copy
electronics_copy.remove("Headphones")
electronics_copy.append("Keyboard")

print(f"All products: {products}")
print(f"Electronics selection: {electronics_copy}")

This example shows how a shallow copy preserves your original data. The slice operator [:] creates electronics_copy as a completely separate list from products. This separation is key.

• When you modify electronics_copy by removing "Headphones" or appending "Keyboard", the changes are isolated to that copy.
• As a result, the original products list remains completely unchanged, which is essential for preventing unintended side effects in your program.

Managing server configurations with copy.deepcopy()

When you need to create distinct configurations from a base template with nested settings, copy.deepcopy() ensures each copy is completely independent.

import copy

# Base configuration as a nested list [name, [settings]]
base_config = ["AppServer", ["localhost", 8080, ["admin", "password"]]]

# Create configurations for different environments
dev_config = copy.deepcopy(base_config)
prod_config = copy.deepcopy(base_config)

# Modify configurations for different environments
dev_config[1][0] = "dev-server"
prod_config[1][0] = "prod-server"
prod_config[1][2][0] = "prod-admin"

print(f"Base server: {base_config[1][0]}")
print(f"Dev server: {dev_config[1][0]}")
print(f"Prod server: {prod_config[1][0]}")
print(f"Prod username: {prod_config[1][2][0]}")

The copy.deepcopy() function is essential here because the base_config list contains other lists inside it. This function creates entirely new versions of dev_config and prod_config, duplicating not just the outer list but all the nested data as well.

• Because every part is a fresh copy, you can safely change a nested value like the server name in dev_config without accidentally altering the base_config template. This prevents bugs where different environments unintentionally share and overwrite settings.

Get started with Replit

Turn your knowledge into a real tool. Describe what you want to build to Replit Agent, like "create a playlist shuffler that copies and randomizes a song list" or "build a config manager for dev and prod environments."

Replit Agent writes the code, tests for errors, and deploys your app, handling the tedious work for you. Start building with Replit.