5 Best Ways to Copy a Nested List in Python

by

💡 Problem Formulation: Python developers often need to duplicate complex structures like nested lists. A nested list is a list containing other lists, and a deep copy is necessary if alterations in the copied list should not affect the original. For instance, given an input [[1, 2], [3, 4]], the goal is to create an independent copy that can be modified without altering the original list.

Method 1: Use the copy Module’s deepcopy() Function

The copy module’s deepcopy() function is specifically designed to copy complex data structures in Python, including nested lists. It creates a new container and recursively adds copies of the objects found in the original.

Here’s an example:

import copy

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

Output:

Original List: [[1, 2], [3, 4]]
Copied List: [['X', 2], [3, 4]]

This code snippet first imports the copy module. It then makes a deep copy of the original list, resulting in a new list that is identical but independent of the original. Changes to the copied list do not affect the original list.

Method 2: Use List Comprehension with [:] Notation

List comprehension combined with slice notation [:] can be used to create a shallow copy of each nested list within an outer list comprehension. This works for nested lists with only one level of nesting.

Here’s an example:

original_list = [[1, 2], [3, 4]]
copied_list = [sublist[:] for sublist in original_list]
copied_list[0][0] = 'X'

Output:

Original List: [[1, 2], [3, 4]]
Copied List: [['X', 2], [3, 4]]

The code uses list comprehension to iterate over the original list and slice each nested list to make a shallow copy of it. However, this method does not work for deeper levels of nesting as it doesn’t make a deep copy.

Method 3: Use the json Module to Serialize and Deserialize

Serializing the list to a JSON formatted string and then deserializing it back into a list creates a deep copy. This method works well for nested lists that contain only JSON serializable data types.

Here’s an example:

import json

original_list = [[1, 2], [3, 4]]
copied_list = json.loads(json.dumps(original_list))
copied_list[0][0] = 'X'

Output:

Original List: [[1, 2], [3, 4]]
Copied List: [['X', 2], [3, 4]]

The code serializes the original list into JSON format using json.dumps(), and then parses that JSON string back into a new list with json.loads(). It is a workaround for deep copying objects that are JSON serializable.

Method 4: Use a Custom Recursive Function

A custom recursive function can be written that iterates through each item in the original list and, if the item is a list itself, calls itself recursively to copy each nested list.

Here’s an example:

def deepcopy_nested_list(lst):
    new_list = []
    for item in lst:
        if isinstance(item, list):
            new_list.append(deepcopy_nested_list(item))
        else:
            new_list.append(item)
    return new_list

original_list = [[1, 2], [3, 4]]
copied_list = deepcopy_nested_list(original_list)
copied_list[0][0] = 'X'

Output:

Original List: [[1, 2], [3, 4]]
Copied List: [['X', 2], [3, 4]]

This code defines a function deepcopy_nested_list() that checks each element, and if it’s a list, it recurses, otherwise, it copies the element. This ensures a deep copy for any level of nested lists.

Bonus One-Liner Method 5: Use a List Comprehension with copy() Method

For nested lists with a single level of nesting, the copy() method on each sublist inside a list comprehension creates a shallow copy of each nested list.

Here’s an example:

original_list = [[1, 2], [3, 4]]
copied_list = [sublist.copy() for sublist in original_list]
copied_list[0][0] = 'X'

Output:

Original List: [[1, 2], [3, 4]]
Copied List: [['X', 2], [3, 4]]

The code here uses a list comprehension to loop through each sublist in the original list and calls sublist.copy() to make a shallow copy of each sublist. Note that this only works for single-level nested lists.

Summary/Discussion

  • Method 1: deepcopy() from the copy module. Most reliable for any depth of nesting. May not work with objects that copy module can’t handle.
  • Method 2: List comprehension with slice notation. Simple and Pythonic. Only works for one level of list nesting and creates shallow copies.
  • Method 3: json serialization. Useful for lists with serializable data types. Not suitable for objects not supported by JSON.
  • Method 4: Custom recursive function. Offers control and can handle various types and structures. More complex and may be slower for large lists.
  • Bonus Method 5: List comprehension with copy(). Quick one-liner for single-level nested lists. Does not work for deeper nesting.