Duplicate a List in Python

In Python, you can duplicate a list using various methods such as slicing, the copy() method, the list() constructor, and the copy module. These methods allow you to create a new list with the same elements as the original list while maintaining flexibility in handling mutable and immutable objects.

Examples

1. Duplicate a List Using Slicing ([:])

The simplest way to duplicate a list in Python is by using slicing [:], which creates a new list with the same elements.

</>
Copy
# Original list
original_list = [1, 2, 3, 4, 5]

# Duplicating using slicing
duplicate_list = original_list[:]

# Printing both lists
print("Original List:", original_list)
print("Duplicated List:", duplicate_list)

Here, original_list is duplicated using slicing [:]. This creates a new list, duplicate_list, with the same elements as original_list. Since slicing creates a shallow copy, changes to one list do not affect the other.

Output:

Original List: [1, 2, 3, 4, 5]
Duplicated List: [1, 2, 3, 4, 5]

2. Duplicate a List Using the copy() Method

The copy() method creates a shallow copy of a list, meaning it duplicates only the outermost list structure.

</>
Copy
# Original list
original_list = [10, 20, 30, 40]

# Duplicating using copy()
duplicate_list = original_list.copy()

# Printing both lists
print("Original List:", original_list)
print("Duplicated List:", duplicate_list)

Here, copy() is called on original_list, which creates a new list duplicate_list. The elements of the new list are identical to the original, but they exist in separate memory locations.

Output:

Original List: [10, 20, 30, 40]
Duplicated List: [10, 20, 30, 40]

3. Duplicate a List Using the list() Constructor

The list() constructor can be used to create a new list with the same elements as the original list.

</>
Copy
# Original list
original_list = ["a", "b", "c"]

# Duplicating using list() constructor
duplicate_list = list(original_list)

# Printing both lists
print("Original List:", original_list)
print("Duplicated List:", duplicate_list)

In this example, the list() constructor takes original_list as an argument and returns a new list duplicate_list with identical elements.

Output:

Original List: ['a', 'b', 'c']
Duplicated List: ['a', 'b', 'c']

4. Duplicate a List Using the copy Module (Deep Copy)

If a list contains nested lists (a list of lists), a shallow copy won’t duplicate inner lists. To make a complete copy, use the copy.deepcopy() function.

</>
Copy
import copy

# Original nested list
original_list = [[1, 2], [3, 4]]

# Duplicating using deepcopy
duplicate_list = copy.deepcopy(original_list)

# Modifying the original list to check independence
original_list[0][0] = 99

# Printing both lists
print("Original List:", original_list)
print("Duplicated List:", duplicate_list)

Here, the deepcopy() function from the copy module is used to create a fully independent duplicate of original_list. This ensures that changes made to nested lists inside original_list do not affect duplicate_list.

Output:

Original List: [[99, 2], [3, 4]]
Duplicated List: [[1, 2], [3, 4]]

Conclusion

Python provides multiple ways to duplicate a list, depending on whether a shallow or deep copy is needed:

  1. [:] (Slicing): Creates a shallow copy quickly.
  2. copy(): Another way to create a shallow copy.
  3. list() Constructor: Converts an iterable into a new list.
  4. copy.deepcopy(): Creates a deep copy for lists with nested elements.

For simple lists, [:] or copy() are sufficient, but for nested lists, copy.deepcopy() should be used to ensure all elements are duplicated properly.