How to copy a list in Python

To duplicate a list in Python is a common operation. It's crucial to create a true copy, not just a reference, to prevent unexpected changes to the original data.

You'll learn several techniques, from the slice operator [:] to the copy module. You'll also find practical tips for real-world applications and get 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 [:] is a concise way to create a shallow copy of a list. This is important for a few key reasons:

• It creates an entirely new list object in memory, not just a reference to the original.
• Modifications made to the new list won't affect the original list.
• This avoids the common pitfall of simple assignment, like copied_list = original_list, where both variables point to the exact same data.

Basic copying methods

While the slice operator is a popular shortcut, Python offers a few other built-in methods that achieve the same shallow copy with slightly different syntax.

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 provides a readable and explicit way to create a shallow copy. When you pass an existing list into the list() function, it generates an entirely new list populated with the elements from the original.

• This approach is often preferred for its clarity. The code list(original_list) clearly communicates the intent to create a new list.
• As the example shows, the is operator returns False, confirming that the new list is a separate object in memory. You can now modify the copy without altering the original.

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 is another built-in tool for creating a shallow copy. It's often favored for its directness since you call it right on the list object you want to duplicate. This approach makes your code's intention very clear.

• Like the other methods, it creates a new, independent list object.
• As the example demonstrates, when you modify the copied list with a method like .append(), the original list remains completely untouched.

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]

List comprehension offers a flexible, readable way to duplicate a list. The expression [item for item in original_list] works by iterating through each element in the original list and building an entirely new list from those elements. This process inherently creates a separate, shallow copy.

• While more verbose for a simple copy, its real power lies in its flexibility. You can modify or filter items during the copying process.
• For instance, you could create a new list containing only certain elements or transformed versions of the original values—all in one line.

Advanced copying techniques

While the built-in methods are great for simple lists, Python's copy module and the map() function offer more control, especially for complex, nested data.

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's copy.copy() function also creates a shallow copy. With simple lists, it works just like the other methods. But with nested lists, you'll see a key difference. A shallow copy creates a new outer list but fills it with references to the original items.

• This means both the original and the copy point to the exact same inner list.
• So, when you modify that inner list—for example, with nested_list[1][0] = 'X'—the change shows up in both places. They're sharing the nested data.

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 duplicate of a nested list, copy.deepcopy() is the solution. It recursively copies not just the outer list but every object inside it, creating a brand-new structure that’s entirely separate from the original.

• This process ensures that even nested lists are duplicated, not just referenced.
• As the example shows, modifying the original’s nested list leaves the deep_copy completely untouched. They are truly independent, which prevents unexpected side effects in your code.

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 function—in this case, a lambda x: x identity function—to every item in the original list. This function simply returns each item unchanged.

• Because map() returns a special map object, which is an iterator, you must wrap it in list() to construct the new list.
• This process results in a new, shallow copy that’s completely separate from the original.

Move faster with Replit

Replit is an AI-powered development platform that transforms natural language into working applications. With Replit Agent, you can describe what you want to build, and it will create a complete app—including databases, APIs, and deployment—directly from your description.

The list copying techniques you've learned, like using .copy() or copy.deepcopy(), can be turned into production-ready applications with Replit Agent:

• Build a session history tracker that duplicates user event logs for analysis without altering the original data stream.
• Create a configuration sandbox that lets you safely test changes to application settings before applying them.
• Deploy a data comparison tool that highlights differences between two datasets by working on independent copies.

Turn your own concepts into reality. Describe your app idea, and Replit Agent will write the code, test it, and fix issues for you, all within your browser.

Common errors and challenges

Even with the right tools, a few common pitfalls can trip you up when duplicating lists in Python.

One of the most frequent errors is using the assignment operator, =, with the expectation that it creates a new list. In reality, it only creates a new reference, meaning both variables point to the exact same list object in memory.

• This creates an alias, not a copy.
• Any modification made to one list will be reflected in the other, leading to unexpected side effects that can be difficult to debug.

It’s tempting to remove items from a list while looping through it with a for loop, but this often leads to unpredictable behavior. As you remove elements, the list's indices shift, causing the loop to skip items because it advances to the next index of the now-shorter list.

• This can result in incomplete processing or an IndexError if the loop tries to access an index that no longer exists.
• To avoid this, you should always iterate over a shallow copy of the list while making modifications to the original.

Shallow copying methods like .copy() or the slice operator [:] are effective for simple lists but can be misleading when dealing with nested structures. If your list contains other mutable objects like dictionaries, a shallow copy only duplicates the outer list—not the inner objects themselves.

• Both the original and the copied list will contain references to the very same nested dictionaries.
• Modifying a nested dictionary in the copy will also alter it in the original, a subtle bug that can only be avoided by using copy.deepcopy().

Mistaking = assignment for copying

Using the = operator to copy a list is a common pitfall. It doesn't create a new list; it just creates a second reference pointing to the original. This means any modification to one variable will unexpectedly alter the other. See this in action below.

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 6 was added to both lists. Since copied_list is just a reference, not a real copy, modifying it also changes the original_list. See how to fix this in the code below.

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 fix is simple: use the slice operator [:] to create a shallow copy. This generates a new list in memory, so copied_list is no longer just a reference. Now, when you append an item to copied_list, the original_list remains untouched. It's a crucial distinction when you need to modify a list while preserving the original version, a common scenario in data processing and state management.

Problems when removing items during for loop iteration

Removing items from a list while iterating over it with a for loop often leads to bugs. As you remove elements, the list's indices shift, causing the loop to skip items. The following code shows this unexpected behavior in practice.

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

The output is `[1, 3, 4, 5]`. After `numbers.remove(2)`, the list becomes `[1, 3, 4, 5]`. The loop then moves to the next item, `4`, completely skipping `3`. See the correct approach below.

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

The solution uses list comprehension to build a new list containing only the desired items. By creating a new list with [num for num in numbers if num % 2 != 0], you avoid modifying the list you're iterating over, which prevents the index-shifting bug entirely.

This is the standard, predictable way to filter a list in Python. You should use this technique whenever you need to remove items based on a condition during an iteration.

Shallow copy limitations with nested dictionaries

Shallow copying a list of dictionaries using the slice operator [:] can lead to unexpected behavior. While it creates a new list, the dictionaries inside are only referenced, not duplicated. This means a change in the copy affects the original. See what happens below.

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 copy only holds pointers to the original dictionaries. When you update the "role" for "Alice" in the copy, you're actually modifying the single dictionary object that both lists share.

The code below demonstrates how to create a truly independent copy, ensuring changes in one list don't affect the other.

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 solution is to use copy.deepcopy(), which creates a truly independent duplicate. It works by recursively copying not just the list, but every nested object inside it.

• This ensures that modifying a dictionary in the new list won't affect the original.
• You should use this method whenever your lists contain other mutable objects, like dictionaries or other lists, to prevent unintended side effects and keep your data clean.

Real-world applications

With the common pitfalls in mind, you can use these copying methods to safely handle data in many real-world applications.

Creating a filtered product list with [:] slice operator

In an e-commerce setting, you can use the slice operator [:] to create a separate, filtered list of products for a special promotion without altering your main product catalog.

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 a practical use for list copying. By creating electronics_copy with the slice operator [:], you get a new list that’s independent of the original products list. This separation is key.

• It allows you to safely modify the copy using methods like .remove() and .append().
• The original data source remains untouched, preventing unintended side effects.

This technique is fundamental when you need to prepare a subset of data for a specific task without altering the master list.

Managing server configurations with copy.deepcopy()

For complex, nested data like server settings, copy.deepcopy() lets you create fully independent configurations for environments such as development or production without altering the original.

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]}")

This code uses copy.deepcopy() to create distinct configurations for development and production from a single template. Notice how changing the server name in dev_config and prod_config has no effect on the base_config. Even nested items, like the admin username, are modified independently.

• This is because deepcopy() recursively duplicates every object, preventing shared references between the lists.
• As a result, each configuration becomes a self-contained snapshot, which is critical for maintaining separate, stable environments without unintended data leaks.

Get started with Replit

Turn your knowledge into a tool. Tell Replit Agent: "Build a config manager using copy.deepcopy()" or "Create a data comparison tool that works on independent list copies."

The agent writes the code, tests for errors, and deploys your application directly from your prompt. Start building with Replit.