How do I clone a list so it doesn't change unexpectedly after assignment?

python

deepcopy

list-cloning

python-objects

byAnton Shumikhin·Oct 26, 2024

To "clone" or create a duplicate of a list in Python, you can use shallow copy for singular level lists, by slicing [:] or with list.copy(). For multilevel lists or lists with mutable elements, ensure an independent copy with deep copy via copy.deepcopy().

# Nothing can get between us when it's just a shallow copy!
cloned_list = original_list[:]

# Things get deep when you want to also clone the heart, not just the body.
import copy
cloned_list = copy.deepcopy(original_list)

Note: Shallow copies clone the list structure, not the elements. Deep copies create new instances of everything inside. Use the right one to avoid disturbing the peace of your code.

Analyze: How deep is your list?

First, analyze your list structure:

Flat lists: For lists with immutable elements (e.g., numbers, strings), my_list.copy() or my_list[:] can efficiently clone. Life's simple for them, isn't it?
Nested lists or mutable elements: If your list has sublists or other mutable objects, those shallow copies above won’t do them justice. Here, copy.deepcopy(my_list) works to retain individuality.

Creating your clone, selectively

Sometimes, you might wish to deep copy only specific fragments of a list. Craft your own custom copy function to embrace this uniqueness:

# Yes, you can pick who gets to be cloned!
def selective_deepcopy(lst, condition=lambda x: True):
    new_lst = []
    for item in lst:
        new_lst.append(copy.deepcopy(item) if condition(item) else item)
    return new_lst

Quick and efficient copies

When performance is crucial (isn't it always?), benchmark your copying techniques with timeit:

import timeit

# 'Seconds' lost can never be regained! Time how long shallow copying takes.
timeit.timeit('new_list = my_list.copy()', setup='my_list = [1, 2, 3]')
timeit.timeit('new_list = my_list[:]', setup='my_list = [1, 2, 3]')

# And now the deep stuff. How long does deep copying take, huh? 
timeit.timeit('new_list = copy.deepcopy(my_list)', setup='import copy; my_list = [[1], [2], [3]]')

Choose the method that strikes a perfect balance between speed and accuracy.

Keep the immutables free

Immutable elements like tuples or strings in lists can simplify your life. They don't like changes. Thus, deep cloning is less critical.

Verify your copies

Double-check the uniqueness of your fresh copy using id():

# They say everyone has an id. Let's see if it's true for our clones too.
print(id(original_list)) # Prints: id of original_list
print(id(cloned_list)) # Prints: id of cloned_list

Different ids prove they are distinct entities. Phew!

Caveats to heed

List mutability can throw a wrench in the works. Beware of:

Nested mutable elements: Shallow copies don't play well with nested lists or dictionaries. Changes in these will echo in both copies! Talk about being connected.
Assignment misleads: new_list = my_list just adds a new nickname to the list, not a new entity. Be wise.

Level up with custom behavior

Explore Python's __copy__ and __deepcopy__ magic for defining custom copy behavior for your objects. Because why not!

Choosing the clone tool

The cloning method you need depends on how complex your list is:

Flat and immutable: list.copy() or slicing [ : ] - because they like living on the surface.
Flat but mutable: copy.copy() - to clone the element-level life forms.
Nested and complex: copy.deepcopy() - to clone the entire universe.