python - List changes unexpectedly after assignment. Why is this and how can I prevent it?

ID : 198

viewed : 176

Tags : pythonlistreferencecopyclonepython

Top 5 Answer for python - List changes unexpectedly after assignment. Why is this and how can I prevent it?

vote vote


With new_list = my_list, you don't actually have two lists. The assignment just copies the reference to the list, not the actual list, so both new_list and my_list refer to the same list after the assignment.

To actually copy the list, you have various possibilities:

  • You can use the builtin list.copy() method (available since Python 3.3):

    new_list = old_list.copy() 
  • You can slice it:

    new_list = old_list[:] 

    Alex Martelli's opinion (at least back in 2007) about this is, that it is a weird syntax and it does not make sense to use it ever. ;) (In his opinion, the next one is more readable).

  • You can use the built in list() function:

    new_list = list(old_list) 
  • You can use generic copy.copy():

    import copy new_list = copy.copy(old_list) 

    This is a little slower than list() because it has to find out the datatype of old_list first.

  • If the list contains objects and you want to copy them as well, use generic copy.deepcopy():

    import copy new_list = copy.deepcopy(old_list) 

    Obviously the slowest and most memory-needing method, but sometimes unavoidable.


import copy  class Foo(object):     def __init__(self, val):          self.val = val      def __repr__(self):         return 'Foo({!r})'.format(self.val)  foo = Foo(1)  a = ['foo', foo] b = a.copy() c = a[:] d = list(a) e = copy.copy(a) f = copy.deepcopy(a)  # edit orignal list and instance  a.append('baz') foo.val = 5  print('original: %r\nlist.copy(): %r\nslice: %r\nlist(): %r\ncopy: %r\ndeepcopy: %r'       % (a, b, c, d, e, f)) 


original: ['foo', Foo(5), 'baz'] list.copy(): ['foo', Foo(5)] slice: ['foo', Foo(5)] list(): ['foo', Foo(5)] copy: ['foo', Foo(5)] deepcopy: ['foo', Foo(1)] 
vote vote


Felix already provided an excellent answer, but I thought I'd do a speed comparison of the various methods:

  1. 10.59 sec (105.9 µs/itn) - copy.deepcopy(old_list)
  2. 10.16 sec (101.6 µs/itn) - pure Python Copy() method copying classes with deepcopy
  3. 1.488 sec (14.88 µs/itn) - pure Python Copy() method not copying classes (only dicts/lists/tuples)
  4. 0.325 sec (3.25 µs/itn) - for item in old_list: new_list.append(item)
  5. 0.217 sec (2.17 µs/itn) - [i for i in old_list] (a list comprehension)
  6. 0.186 sec (1.86 µs/itn) - copy.copy(old_list)
  7. 0.075 sec (0.75 µs/itn) - list(old_list)
  8. 0.053 sec (0.53 µs/itn) - new_list = []; new_list.extend(old_list)
  9. 0.039 sec (0.39 µs/itn) - old_list[:] (list slicing)

So the fastest is list slicing. But be aware that copy.copy(), list[:] and list(list), unlike copy.deepcopy() and the python version don't copy any lists, dictionaries and class instances in the list, so if the originals change, they will change in the copied list too and vice versa.

(Here's the script if anyone's interested or wants to raise any issues:)

from copy import deepcopy  class old_class:     def __init__(self):         self.blah = 'blah'  class new_class(object):     def __init__(self):         self.blah = 'blah'  dignore = {str: None, unicode: None, int: None, type(None): None}  def Copy(obj, use_deepcopy=True):     t = type(obj)      if t in (list, tuple):         if t == tuple:             # Convert to a list if a tuple to             # allow assigning to when copying             is_tuple = True             obj = list(obj)         else:             # Otherwise just do a quick slice copy             obj = obj[:]             is_tuple = False          # Copy each item recursively         for x in xrange(len(obj)):             if type(obj[x]) in dignore:                 continue             obj[x] = Copy(obj[x], use_deepcopy)          if is_tuple:             # Convert back into a tuple again             obj = tuple(obj)      elif t == dict:         # Use the fast shallow dict copy() method and copy any         # values which aren't immutable (like lists, dicts etc)         obj = obj.copy()         for k in obj:             if type(obj[k]) in dignore:                 continue             obj[k] = Copy(obj[k], use_deepcopy)      elif t in dignore:         # Numeric or string/unicode?         # It's immutable, so ignore it!         pass      elif use_deepcopy:         obj = deepcopy(obj)     return obj  if __name__ == '__main__':     import copy     from time import time      num_times = 100000     L = [None, 'blah', 1, 543.4532,          ['foo'], ('bar',), {'blah': 'blah'},          old_class(), new_class()]      t = time()     for i in xrange(num_times):         Copy(L)     print 'Custom Copy:', time()-t      t = time()     for i in xrange(num_times):         Copy(L, use_deepcopy=False)     print 'Custom Copy Only Copying Lists/Tuples/Dicts (no classes):', time()-t      t = time()     for i in xrange(num_times):         copy.copy(L)     print 'copy.copy:', time()-t      t = time()     for i in xrange(num_times):         copy.deepcopy(L)     print 'copy.deepcopy:', time()-t      t = time()     for i in xrange(num_times):         L[:]     print 'list slicing [:]:', time()-t      t = time()     for i in xrange(num_times):         list(L)     print 'list(L):', time()-t      t = time()     for i in xrange(num_times):         [i for i in L]     print 'list expression(L):', time()-t      t = time()     for i in xrange(num_times):         a = []         a.extend(L)     print 'list extend:', time()-t      t = time()     for i in xrange(num_times):         a = []         for y in L:             a.append(y)     print 'list append:', time()-t      t = time()     for i in xrange(num_times):         a = []         a.extend(i for i in L)     print 'generator expression extend:', time()-t 
vote vote


I've been told that Python 3.3+ adds the list.copy() method, which should be as fast as slicing:

newlist = old_list.copy() 
vote vote


What are the options to clone or copy a list in Python?

In Python 3, a shallow copy can be made with:

a_copy = a_list.copy() 

In Python 2 and 3, you can get a shallow copy with a full slice of the original:

a_copy = a_list[:] 


There are two semantic ways to copy a list. A shallow copy creates a new list of the same objects, a deep copy creates a new list containing new equivalent objects.

Shallow list copy

A shallow copy only copies the list itself, which is a container of references to the objects in the list. If the objects contained themselves are mutable and one is changed, the change will be reflected in both lists.

There are different ways to do this in Python 2 and 3. The Python 2 ways will also work in Python 3.

Python 2

In Python 2, the idiomatic way of making a shallow copy of a list is with a complete slice of the original:

a_copy = a_list[:] 

You can also accomplish the same thing by passing the list through the list constructor,

a_copy = list(a_list) 

but using the constructor is less efficient:

>>> timeit >>> l = range(20) >>> min(timeit.repeat(lambda: l[:])) 0.30504298210144043 >>> min(timeit.repeat(lambda: list(l))) 0.40698814392089844 

Python 3

In Python 3, lists get the list.copy method:

a_copy = a_list.copy() 

In Python 3.5:

>>> import timeit >>> l = list(range(20)) >>> min(timeit.repeat(lambda: l[:])) 0.38448613602668047 >>> min(timeit.repeat(lambda: list(l))) 0.6309100328944623 >>> min(timeit.repeat(lambda: l.copy())) 0.38122922903858125 

Making another pointer does not make a copy

Using new_list = my_list then modifies new_list every time my_list changes. Why is this?

my_list is just a name that points to the actual list in memory. When you say new_list = my_list you're not making a copy, you're just adding another name that points at that original list in memory. We can have similar issues when we make copies of lists.

>>> l = [[], [], []] >>> l_copy = l[:] >>> l_copy [[], [], []] >>> l_copy[0].append('foo') >>> l_copy [['foo'], [], []] >>> l [['foo'], [], []] 

The list is just an array of pointers to the contents, so a shallow copy just copies the pointers, and so you have two different lists, but they have the same contents. To make copies of the contents, you need a deep copy.

Deep copies

To make a deep copy of a list, in Python 2 or 3, use deepcopy in the copy module:

import copy a_deep_copy = copy.deepcopy(a_list) 

To demonstrate how this allows us to make new sub-lists:

>>> import copy >>> l [['foo'], [], []] >>> l_deep_copy = copy.deepcopy(l) >>> l_deep_copy[0].pop() 'foo' >>> l_deep_copy [[], [], []] >>> l [['foo'], [], []] 

And so we see that the deep copied list is an entirely different list from the original. You could roll your own function - but don't. You're likely to create bugs you otherwise wouldn't have by using the standard library's deepcopy function.

Don't use eval

You may see this used as a way to deepcopy, but don't do it:

problematic_deep_copy = eval(repr(a_list)) 
  1. It's dangerous, particularly if you're evaluating something from a source you don't trust.
  2. It's not reliable, if a subelement you're copying doesn't have a representation that can be eval'd to reproduce an equivalent element.
  3. It's also less performant.

In 64 bit Python 2.7:

>>> import timeit >>> import copy >>> l = range(10) >>> min(timeit.repeat(lambda: copy.deepcopy(l))) 27.55826997756958 >>> min(timeit.repeat(lambda: eval(repr(l)))) 29.04534101486206 

on 64 bit Python 3.5:

>>> import timeit >>> import copy >>> l = list(range(10)) >>> min(timeit.repeat(lambda: copy.deepcopy(l))) 16.84255409205798 >>> min(timeit.repeat(lambda: eval(repr(l)))) 34.813894678023644 
vote vote


There are many answers already that tell you how to make a proper copy, but none of them say why your original 'copy' failed.

Python doesn't store values in variables; it binds names to objects. Your original assignment took the object referred to by my_list and bound it to new_list as well. No matter which name you use there is still only one list, so changes made when referring to it as my_list will persist when referring to it as new_list. Each of the other answers to this question give you different ways of creating a new object to bind to new_list.

Each element of a list acts like a name, in that each element binds non-exclusively to an object. A shallow copy creates a new list whose elements bind to the same objects as before.

new_list = list(my_list)  # or my_list[:], but I prefer this syntax # is simply a shorter way of: new_list = [element for element in my_list] 

To take your list copy one step further, copy each object that your list refers to, and bind those element copies to a new list.

import copy   # each element must have __copy__ defined for this... new_list = [copy.copy(element) for element in my_list] 

This is not yet a deep copy, because each element of a list may refer to other objects, just like the list is bound to its elements. To recursively copy every element in the list, and then each other object referred to by each element, and so on: perform a deep copy.

import copy # each element must have __deepcopy__ defined for this... new_list = copy.deepcopy(my_list) 

See the documentation for more information about corner cases in copying.

Top 3 video Explaining python - List changes unexpectedly after assignment. Why is this and how can I prevent it?