Python Copy List: Comprehensive Guide

When working with lists in Python, there are many situations where you need to copy a list. Whether you want to duplicate the contents of a list, create a shallow or deep copy, or manipulate copies without altering the original list, knowing the most appropriate Python copy list technique is essential.

By the end of this guide, you’ll know multiple methods to copy lists and understand which approach is best for your use case.

Why Copy a List in Python?

In Python, lists are mutable, meaning their contents can be changed. If you assign a list to a new variable, both variables will reference the same list in memory. Any modification to one variable will also affect the other, which is often not desirable.

Example:

list1 = [1, 2, 3]
list2 = list1

list2.append(4)
print(list1)  # Output: [1, 2, 3, 4]

Here, modifying list2 also changes list1 because both variables point to the same list in memory. To avoid this, you need to create a copy of the list.

Methods to Copy a List in Python

Python offers several ways to copy a list. Each method creates a new list, but there are differences in how the copy behaves (shallow vs deep copy).

1. Using List Slicing

One of the simplest ways to copy a list is by using list slicing. Slicing creates a new list by copying the elements of the original list.

Example:

list1 = [1, 2, 3]
list2 = list1[:]

list2.append(4)
print(list1)  # Output: [1, 2, 3]
print(list2)  # Output: [1, 2, 3, 4]

In this example, list2 is a new copy of list1, and modifying list2 does not affect list1.

Advantages of List Slicing:

• Simple and concise.
• Effective for creating shallow copies of lists.

2. Using the copy() Method

Python lists have a built-in copy() method that creates a shallow copy of the list. This method is explicit and is often preferred for readability.

Example:

list1 = [1, 2, 3]
list2 = list1.copy()

list2.append(4)
print(list1)  # Output: [1, 2, 3]
print(list2)  # Output: [1, 2, 3, 4]

The copy() method is similar to slicing ([:]) but may be more readable, especially for those unfamiliar with slicing syntax.

3. Using the list() Constructor

Another way to copy a list is by using the list() constructor, which creates a new list from an existing iterable.

Example:

list1 = [1, 2, 3]
list2 = list(list1)

list2.append(4)
print(list1)  # Output: [1, 2, 3]
print(list2)  # Output: [1, 2, 3, 4]

This method works similarly to slicing and copy(), producing a shallow copy of the list.

4. Using the copy Module (for Deep Copying)

When a list contains nested lists or other complex objects, the above methods only create a shallow copy. A shallow copy only copies the references to the nested objects, meaning changes to those nested objects will affect both the original and copied lists.

To create a deep copy, where all objects are fully copied (including nested ones), you can use the copy module’s deepcopy() function.

Example:

import copy

list1 = [[1, 2], [3, 4]]
list2 = copy.deepcopy(list1)

list2[0].append(3)
print(list1)  # Output: [[1, 2], [3, 4]]
print(list2)  # Output: [[1, 2, 3], [3, 4]]

In this example, changes made to list2 do not affect list1, even though the original list contains nested lists.

Shallow vs Deep Copy in Python

Understanding the difference between a shallow copy and a deep copy is crucial when working with complex lists or objects in Python.

Shallow Copy

A shallow copy creates a new list, but it does not recursively copy nested lists or objects. If the original list contains references to other objects, those references are copied, not the objects themselves.

Example of Shallow Copy:

list1 = [[1, 2], [3, 4]]
list2 = list1.copy()

list2[0].append(3)
print(list1)  # Output: [[1, 2, 3], [3, 4]]
print(list2)  # Output: [[1, 2, 3], [3, 4]]

In this case, both list1 and list2 reference the same nested lists, so changes to one affect the other.

Deep Copy

A deep copy, on the other hand, creates an entirely new copy of the list and all of the objects it contains, including nested lists.

Example of Deep Copy:

import copy

list1 = [[1, 2], [3, 4]]
list2 = copy.deepcopy(list1)

list2[0].append(3)
print(list1)  # Output: [[1, 2], [3, 4]]
print(list2)  # Output: [[1, 2, 3], [3, 4]]

Here, list1 and list2 are completely independent, and changes to list2 do not affect list1.

When to Use:

• Shallow Copy: Use when working with lists that don’t contain nested objects or when you’re fine with the nested objects being shared between the original and copied lists.
• Deep Copy: Use when you need to ensure that all elements and nested objects are fully copied and independent of the original list.

Best Practices for Copying Lists in Python

1. Use copy() or slicing ([:]) for simple lists: If your list only contains basic elements like numbers or strings, these methods are quick and efficient.
2. Use deepcopy() for complex or nested lists: If your list contains nested lists or objects, use deepcopy() to ensure that the nested structures are fully copied.
3. Use list() when working with iterables: If you need to copy from another iterable (e.g., a tuple or set), use list() to convert and copy it to a list.
4. Consider performance: For very large lists, copying can be an expensive operation. Be mindful of performance when working with large data structures.
5. Know your use case: Choose between shallow and deep copy based on the type of data your list holds and the changes you plan to make.

Performance Considerations

For small lists, all of the methods for copying lists (slicing, copy(), list()) perform similarly. However, for large lists or deeply nested structures, the performance impact of copying can vary. In general:

• Shallow copies (using slicing, copy(), or list()) are faster because they don’t copy nested objects.
• Deep copies (using deepcopy()) are slower due to the recursive copying of all objects, especially for deeply nested or large data structures.

Example: Timing Different Copy Methods

import timeit

list1 = list(range(1000000))

# Timing list slicing
print(timeit.timeit('list1[:]', globals=globals(), number=100))

# Timing copy() method
print(timeit.timeit('list1.copy()', globals=globals(), number=100))

# Timing list() constructor
print(timeit.timeit('list(list1)', globals=globals(), number=100))

For large lists, copy() and slicing are generally faster than deepcopy(), which should only be used when necessary for nested structures.

Summary of Key Concepts

• Slicing ([:]) and copy() create shallow copies of lists, duplicating the top-level elements but not nested objects.
• deepcopy() from the copy module creates a full, independent copy of a list, including any nested objects.
• When working with simple lists, use slicing or copy() for efficiency.
• For lists with nested objects, use deepcopy() to avoid unwanted side effects caused by shared references.
• Always consider your use case and performance needs when copying large or complex lists.

Check out our FREE Learn Python Programming Masterclass to hone your skills or learn from scratch.

The course covers everything from first principles to Graphical User Interfaces and Machine Learning

You can browse the official Python documentation on lists here.

FAQ

Q1: What’s the difference between copy() and slicing ([:]) when copying a list?

A1: Both copy() and slicing ([:]) create shallow copies of a list. This means they copy the list itself but do not duplicate any nested objects within the list. The difference is primarily in readability; copy() is more explicit and may be preferred for clarity, while slicing is more concise and familiar to many Python users.

Q2: When should I use deepcopy() instead of copy()?

A2: Use deepcopy() when your list contains nested lists or objects, and you want to ensure that the copy is completely independent of the original. If you only need to copy a list with simple elements (e.g., numbers or strings), copy() is sufficient. deepcopy() is necessary when you want to avoid sharing references to nested objects between the original and copied lists.

Q3: How do I copy only a portion of a list?

A3: You can copy a portion of a list using slicing. Slicing allows you to specify the start and end indices of the portion you want to copy.

Example:

list1 = [1, 2, 3, 4, 5]
# Copy elements from index 1 to 3
list2 = list1[1:4]
print(list2)  # Output: [2, 3, 4]

Q4: Can I copy a list that contains other data types like tuples or dictionaries?

A4: Yes, you can copy a list containing other data types like tuples or dictionaries. However, both slicing and copy() create a shallow copy, so if your list contains mutable objects (like dictionaries), changes to the copied version will affect the original unless you use deepcopy().

Example:

import copy

list1 = [{'name': 'Alice'}, {'name': 'Bob'}]
list2 = copy.deepcopy(list1)

list2[0]['name'] = 'Charlie'
print(list1)  # Output: [{'name': 'Alice'}, {'name': 'Bob'}]
print(list2)  # Output: [{'name': 'Charlie'}, {'name': 'Bob'}]

Q5: Is there any performance difference between using slicing, copy(), and list() for copying a list?

A5: For small lists, the performance differences between slicing, copy(), and list() are negligible. However, for very large lists, there can be slight differences in performance:

• Slicing ([:]) is generally the fastest.
• copy() and list() are slightly slower but offer more readability and clarity.

If performance is critical, you can measure the time each method takes using the timeit module.

Q6: How do I copy a list of lists without affecting the original nested lists?

A6: To copy a list of lists without affecting the original nested lists, use deepcopy() from the copy module. This ensures that both the outer list and any nested lists are copied independently.

Example:

import copy

list1 = [[1, 2], [3, 4]]
list2 = copy.deepcopy(list1)

list2[0].append(5)
print(list1)  # Output: [[1, 2], [3, 4]]
print(list2)  # Output: [[1, 2, 5], [3, 4]]

Q7: Can I copy a list using a for loop?

A7: Yes, you can copy a list manually using a for loop, though it’s not as efficient or Pythonic as using built-in methods like slicing or copy().

Example:

list1 = [1, 2, 3, 4]
list2 = []
for item in list1:
    list2.append(item)

print(list2)  # Output: [1, 2, 3, 4]

However, this method creates a shallow copy and should only be used if built-in methods are not applicable for some reason.

Q8: Does copying a list also copy the list’s methods and properties?

A8: Yes, copying a list (whether by slicing, copy(), or another method) creates a new list with the same methods and properties as the original. However, it’s important to note that methods are part of the list’s class (which remains the same), so you are effectively copying the list’s data, not the methods themselves.

Q9: How can I create multiple copies of the same list?

A9: You can create multiple copies of a list by repeating any of the copying methods in a loop or comprehension. Here’s an example using list comprehension to create multiple copies:

Example:

list1 = [1, 2, 3]
copies = [list1.copy() for _ in range(3)]
print(copies)  # Output: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]

Each element in copies is an independent shallow copy of list1.

Q10: What happens if I use deepcopy() on a list that only contains immutable data types like integers and strings?

A10: If you use deepcopy() on a list that contains only immutable data types (such as integers, floats, strings, or tuples), the result will be the same as using a shallow copy method like slicing or copy(). This is because immutable objects do not need to be deeply copied, as they cannot be modified in place.

Example:

import copy

list1 = [1, 2, 3, "a", "b"]
list2 = copy.deepcopy(list1)
list2.append("new")

print(list1)  # Output: [1, 2, 3, 'a', 'b']
print(list2)  # Output: [1, 2, 3, 'a', 'b', 'new']

In this case, deepcopy() doesn’t provide any additional benefit over a shallow copy since the elements are immutable.