Python: Copying Arrays Tutorial with Examples

In Python, copying arrays (or lists, as Python does not have a built-in array type like other languages) is a common operation when you want to duplicate a list for further modifications without altering the original.

Python provides several ways to copy arrays, each with its own advantages and considerations, especially when dealing with shallow vs. deep copies.

In this tutorial, we will cover:

What is an Array (List) in Python?
Shallow vs. Deep Copy
Copying Arrays Using Assignment
Copying Arrays Using copy() Method
Copying Arrays Using List Slicing
Copying Arrays Using the list() Function
Copying Arrays Using copy Module (Deep Copy)
Examples and Common Use Cases

Let’s explore each method of copying arrays with examples and explanations.

1. What is an Array (List) in Python?

In Python, the most common way to store a collection of elements is by using a list. Lists are mutable sequences, meaning their elements can be changed.

Python does not have a built-in array data structure, but lists can be used in a similar way to arrays in other programming languages.

Example of a List (Array):

my_list = [1, 2, 3, 4, 5]
print(my_list)  # Output: [1, 2, 3, 4, 5]

You can store any type of elements in a list, including numbers, strings, and even other lists.

2. Shallow vs. Deep Copy

Before diving into the methods of copying arrays, it's important to understand the difference between shallow copies and deep copies.

Shallow Copy: A shallow copy creates a new list, but it does not create new copies of the objects contained within the original list. For simple lists (e.g., lists of numbers or strings), a shallow copy behaves as expected. However, if the list contains mutable objects (like other lists), changes made to those mutable objects will be reflected in both the original and the copied list.
Deep Copy: A deep copy creates a completely independent copy of the original list and any objects contained within it. Changes made to the copied list do not affect the original, and vice versa.

3. Copying Arrays Using Assignment

The simplest way to “copy” a list is by using assignment. However, this does not create a new list; it only creates a new reference to the same list. Changes made to one list will affect the other.

Example: Copying a List Using Assignment

original_list = [1, 2, 3]
copied_list = original_list  # This is not a true copy

copied_list[0] = 99
print("Original list:", original_list)  # Output: [99, 2, 3]
print("Copied list:", copied_list)      # Output: [99, 2, 3]

In this example, modifying copied_list also modifies original_list because they refer to the same list.

4. Copying Arrays Using copy() Method

The copy() method creates a shallow copy of a list. It is the most straightforward way to duplicate a list in Python.

Example: Copying a List Using copy()

original_list = [1, 2, 3]
copied_list = original_list.copy()

copied_list[0] = 99
print("Original list:", original_list)  # Output: [1, 2, 3]
print("Copied list:", copied_list)      # Output: [99, 2, 3]

In this example, changes to copied_list do not affect original_list because they are separate lists.

5. Copying Arrays Using List Slicing

List slicing is another way to create a shallow copy of a list. The syntax list[:] creates a copy of the entire list.

Example: Copying a List Using Slicing

original_list = [1, 2, 3]
copied_list = original_list[:]

copied_list[0] = 99
print("Original list:", original_list)  # Output: [1, 2, 3]
print("Copied list:", copied_list)      # Output: [99, 2, 3]

In this example, slicing creates a new list, so changes made to copied_list do not affect original_list.

6. Copying Arrays Using the list() Function

The list() function can be used to create a new list from an existing iterable, such as a list. This also creates a shallow copy of the list.

Example: Copying a List Using list()

original_list = [1, 2, 3]
copied_list = list(original_list)

copied_list[0] = 99
print("Original list:", original_list)  # Output: [1, 2, 3]
print("Copied list:", copied_list)      # Output: [99, 2, 3]

In this example, using list() creates a new list, and changes to copied_list do not affect original_list.

7. Copying Arrays Using copy Module (Deep Copy)

When working with nested lists or lists containing other mutable objects, you may want to create a deep copy. The copy module provides a deepcopy() function that creates an independent copy of the original list and all objects contained within it.

Example: Deep Copying a Nested List Using deepcopy()

import copy

original_list = [[1, 2], [3, 4]]
copied_list = copy.deepcopy(original_list)

copied_list[0][0] = 99
print("Original list:", original_list)  # Output: [[1, 2], [3, 4]]
print("Copied list:", copied_list)      # Output: [[99, 2], [3, 4]]

In this example, deepcopy() creates a completely independent copy of original_list. Changes to copied_list do not affect original_list, even for nested lists.

8. Examples and Common Use Cases

Example 1: Copying a Simple List

original_list = [10, 20, 30]

# Copy using different methods
copied_list1 = original_list.copy()
copied_list2 = original_list[:]
copied_list3 = list(original_list)

# Modify the copied list
copied_list1[0] = 100

# Output the results
print("Original list:", original_list)  # Output: [10, 20, 30]
print("Copied list 1:", copied_list1)   # Output: [100, 20, 30]

In this example, different methods are used to copy the list. All create a shallow copy.

Example 2: Copying a Nested List (Shallow vs. Deep Copy)

import copy

# Nested list
original_list = [[1, 2], [3, 4]]

# Shallow copy
shallow_copy = original_list.copy()

# Deep copy
deep_copy = copy.deepcopy(original_list)

# Modify the shallow copy
shallow_copy[0][0] = 99

# Modify the deep copy
deep_copy[1][1] = 88

# Output the results
print("Original list:", original_list)  # Output: [[99, 2], [3, 4]]
print("Shallow copy:", shallow_copy)    # Output: [[99, 2], [3, 4]]
print("Deep copy:", deep_copy)          # Output: [[1, 2], [3, 88]]

In this example, the shallow copy affects the original nested list, while the deep copy does not.

Example 3: Copying a List of Strings (Shallow Copy)

fruits = ["apple", "banana", "cherry"]

# Create a shallow copy
fruits_copy = fruits[:]

# Modify the copied list
fruits_copy[1] = "orange"

# Output the results
print("Original list:", fruits)    # Output: ['apple', 'banana', 'cherry']
print("Copied list:", fruits_copy) # Output: ['apple', 'orange', 'cherry']

In this example, modifying fruits_copy does not affect the original fruits list because the strings are immutable, and the copy is shallow.

Summary of Python Copy Methods for Arrays (Lists):

Method	Description	Shallow/Deep	Example
Assignment (=)	Creates a reference to the original list.	None (same object)	copied_list = original_list
copy() Method	Creates a shallow copy of the list.	Shallow	copied_list = original_list.copy()
Slicing ([:])	Creates a shallow copy of the list.	Shallow	copied_list = original_list[:]
list() Function	Creates a shallow copy of the list.	Shallow	copied_list = list(original_list)
deepcopy() from copy	Creates a deep copy of the list.	Deep	copied_list = copy.deepcopy(original_list)

Conclusion

In Python, copying arrays (or lists) is a common task, especially when you want to modify a copy of a list without affecting the original.

In this tutorial, we covered:

Different methods of copying lists, including assignment, copy() method, slicing, list() function, and deepcopy.
The difference between shallow copies and deep copies, and when to use each.
Practical examples of copying simple lists and nested lists.

Copying Arrays