С new_list = my_list вас фактически нет двух списков. Назначение просто копирует ссылку на список, а не фактический список, поэтому как new_list , так и my_list относятся к тому же списку после назначения.

Чтобы на самом деле скопировать список, у вас есть различные возможности:

• Вы можете отрезать его:

   new_list = old_list[:] 

  По мнению Алекса Мартелли (по крайней мере, в 2007 году ), это странный синтаксис, и использовать его никогда не имеет смысла . 😉 (По его мнению, следующий – более читаемый).

• Вы можете использовать встроенную функцию list() :

   new_list = list(old_list) 

• Вы можете использовать generic copy.copy() :

   import copy new_list = copy.copy(old_list) 

  Это немного медленнее, чем list() потому что сначала нужно выяснить тип данных old_list .

• Если список содержит объекты и вы хотите их скопировать, используйте общий copy.deepcopy() :

   import copy new_list = copy.deepcopy(old_list) 

  Очевидно, самый медленный и самый необходимый для памяти способ, но иногда неизбежный.

Пример:

 import copy class Foo(object): def __init__(self, val): self.val = val def __repr__(self): return str(self.val) foo = Foo(1) a = ['foo', foo] b = a[:] c = list(a) d = copy.copy(a) e = copy.deepcopy(a) # edit orignal list and instance a.append('baz') foo.val = 5 print('original: %r\n slice: %r\n list(): %r\n copy: %r\n deepcopy: %r' % (a, b, c, d, e)) 

Результат:

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

Феликс уже дал отличный ответ, но я думал, что сделаю сравнение скорости различных методов:

1. 10.59 сек (105.9us / itn) – copy.deepcopy(old_list)
2. 10.16 сек (101.6us / itn) – метод pure python Copy() копирующий классы с помощью deepcopy
3. 1.488 с (14.88us / itn) – метод pure python Copy() не копирует классы (только dicts / lists / tuples)
4. 0.325 с (3.25us / itn) – for item in old_list: new_list.append(item)
5. 0.217 с (2.17us / itn) – [i for i in old_list] ( понимание списка )
6. 0.186 с (1.86us / itn) – copy.copy(old_list)
7. 0,075 сек (0.75us / itn) – list(old_list)
8. 0,053 сек (0,53us / itn) – new_list = []; new_list.extend(old_list) new_list = []; new_list.extend(old_list)
9. 0.039 сек (0.39us / itn) – old_list[:] ( old_list[:] списка )

Таким образом, самая быстрая нарезка списка. Но имейте в copy.copy() что copy.copy() , list[:] и list(list) , в отличие от copy.deepcopy() и версия python не копируют в список списки, словари и экземпляры классов, поэтому, если оригиналы меняются , они также будут изменены в скопированном списке и наоборот.

(Вот сценарий, если кто-то заинтересован или хочет поднять какие-либо вопросы 🙂

 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 , 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 , 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 , 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 

EDIT : добавлены классы стиля старого стиля, а также диктофоны к эталонам и сделали версию python намного быстрее и добавили еще несколько методов, включая выражения списков и extend() .

Мне сказали, что Python 3.3+ добавляет list.copy() , который должен быть таким же быстрым, как нарезка:

newlist = old_list.copy()

Каковы варианты клонирования или копирования списка в Python?

Существует два семантических способа копирования списка. Неглубокая копия создает новый список тех же объектов, в глубокой копии создается новый список, содержащий эквивалентные объекты.

Неверная копия списка

Неглубокая копия копирует только сам список, который является контейнером ссылок на объекты в списке. Если объекты, содержащиеся в них, являются изменяемыми и один из них изменен, это изменение будет отражено в обоих списках.

В Python 2 и 3. есть разные способы сделать это. Пути Python 2 также будут работать в Python 3.

Python 2

В Python 2 идиоматический способ создания мелкой копии списка состоит из полного фрагмента оригинала:

 a_copy = a_list[:] 

Вы также можете выполнить одно и то же, передав список через конструктор списка,

 a_copy = list(a_list) 

но использование конструктора менее эффективно:

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

Python 3

В Python 3 списки получают метод list.copy :

 a_copy = a_list.copy() 

В 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 

Создание другого указателя не делает копию

Использование new_list = my_list затем изменяет new_list каждый раз, когда изменяется my_list. Почему это?

my_list – указатель на фактический список в памяти. Когда вы скажете new_list = my_list что вы не делаете копию, вы просто добавляете другое имя, указывающее на этот исходный список в памяти. У нас могут быть подобные проблемы, когда мы делаем копии списков.

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

Список – это всего лишь массив указателей на содержимое, поэтому мелкая копия просто копирует указатели, поэтому у вас есть два разных списка, но они имеют одинаковое содержимое. Чтобы сделать копии содержимого, вам нужна глубокая копия.

Глубокие копии

Чтобы сделать глубокую копию списка, в Python 2 или 3, используйте deepcopy в модуле copy :

 import copy a_deep_copy = copy.deepcopy(a_list) 

Чтобы продемонстрировать, как это позволяет нам создавать новые под-списки:

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

И поэтому мы видим, что глубокий скопированный список – это совсем другой список из оригинала. Вы можете перевернуть свою собственную функцию, но не надо. Вероятно, вы создадите ошибки, которых иначе не было бы, используя функцию глубокой копии стандартной библиотеки.

Не используйте eval

Вы можете видеть, что это используется как способ для глубокой печати, но не делайте этого:

 problematic_deep_copy = eval(repr(a_list)) 

1. Это опасно, особенно если вы оцениваете что-то из источника, которому вы не доверяете.
2. Это ненадежно, если подэлемент, который вы копируете, не имеет представления, которое может быть доказано для воспроизведения эквивалентного элемента.
3. Он также менее эффективен.

В 64-битном 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 

на 64-битном 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 

Этот ответ предназначен только для Python 2. Я еще не обновился до Python 3.

Уже есть много ответов, которые расскажут вам, как сделать правильную копию, но никто из них не говорит, почему ваша оригинальная «копия» не удалась.

Python не сохраняет значения в переменных; он связывает имена с объектами. Ваше исходное задание заняло объект, на который ссылается my_list и связал его с new_list . Независимо от того, какое имя вы используете, остается только один список, поэтому изменения, сделанные при обращении к нему как my_list будут сохраняться при обращении к нему как new_list . Каждый из других ответов на этот вопрос дает вам различные способы создания нового объекта для привязки к new_list .

Каждый элемент списка действует как имя, поскольку каждый элемент связывается не исключительно с объектом. Неглубокая копия создает новый список, элементы которого привязываются к тем же объектам, что и раньше.

 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] 

Чтобы сделать копию списка еще одним шагом, скопируйте каждый объект, к которому относится ваш список, и привяжите эти копии элементов к новому списку.

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

Это еще не глубокая копия, потому что каждый элемент списка может ссылаться на другие объекты, точно так же, как список привязан к его элементам. Чтобы рекурсивно скопировать каждый элемент в списке, а затем каждый другой объект, на который ссылаются каждый элемент, и т. Д .: выполните глубокую копию.

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

Дополнительную информацию об угловых случаях при копировании см. В документации .

new_list = list(old_list)

Идиома Python для этого – newList = oldList[:]

Использовать thing[:]

 >>> a = [1,2] >>> b = a[:] >>> a += [3] >>> a [1, 2, 3] >>> b [1, 2] >>> 

Все остальные участники дали отличные ответы, которые работают, когда у вас есть один размерный (выровненный) список, однако из тех методов, которые были упомянуты до сих пор, только copy.deepcopy() работает, чтобы клонировать / копировать список и не указывать на него вложенные объекты list когда вы работаете с многомерными вложенными списками (список списков). В то время как Феликс Клинг ссылается на это в своем ответе, это немного больше относится к проблеме и, возможно, обходное решение с использованием встроенных модулей, которые могут оказаться более быстрой альтернативой deepcopy .

Хотя new_list = old_list[:] , copy.copy(old_list)' и для Py3k old_list.copy() работают для old_list.copy() списков, они возвращаются к указанию на объекты list вложенные в old_list и new_list , и изменяются на один объектов list сохраняются в другом.

Изменить: появилась новая информация

Как было отмечено как Aaron Hall, так и PM 2Ring с использованием eval() это не только плохая идея, но и намного медленнее, чем copy.deepcopy() .

Это означает, что для многомерных списков единственным вариантом является copy.deepcopy() . С учетом сказанного это действительно не вариант, так как производительность идет на юг, когда вы пытаетесь использовать его в многомерном массиве умеренного размера. Я попытался использовать тайм- timeit с использованием массива 42×42, не неслыханного или даже такого большого для приложений для биоинформатики, и я отказался ждать ответа и просто начал вводить свое редактирование на этот пост.

Казалось бы, единственным реальным вариантом является инициализация нескольких списков и работа над ними независимо. Если у кого-то есть другие предложения, как обращаться с многомерным копированием списков, то это будет оценено.

Как утверждали другие, могут быть значительные проблемы с производительностью с использованием модуля copy и copy.deepcopy для многомерных списков . Попытка разработать другой способ копирования многомерного списка без использования deepcopy (я работал над проблемой для курса, который позволяет всего 5 секунд для запуска всего алгоритма для получения кредита), я придумал способ использовать встроенные функции для создания копии вложенного списка, не указывая друг на друга или на объекты list вложенные в них. Я использовал eval() и repr() в присваивании, чтобы сделать копию старого списка в новый список без создания ссылки на старый список. Он принимает форму:

 new_list = eval(repr(old_list)) 

В основном это делает представление old_list как строки, а затем оценивает строку, как если бы это был объект, который представляет строка. Таким образом, не создается ссылка на исходный объект list . Создается новый объект list и каждая переменная указывает на свой собственный независимый объект. Вот пример использования 2-мерного вложенного списка.

 old_list = [[0 for j in range(y)] for i in range(x)] # initialize (x,y) nested list # assign a copy of old_list to new list without them pointing to the same list object new_list = eval(repr(old_list)) # make a change to new_list for j in range(y): for i in range(x): new_list[i][j] += 1 

Если вы затем проверите содержимое каждого списка, например, список 4 на 3, Python вернется

 >>> new_list [[1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1]] >>> old_list [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] 

Хотя это, вероятно, не канонический или синтаксически правильный способ сделать это, похоже, что он работает хорошо. Я не тестировал производительность, но я собираюсь догадаться, что eval() и rep() будут иметь меньше накладных расходов для запуска, чем deepcopy .

В отличие от других языков переменная и ценность , у python есть имя и объект .

 a=[1,2,3] 

означает, что в списке (объекте) указано имя «a»,

 b=a 

просто дает тому же объекту новое имя «b», поэтому всякий раз, когда вы что-то делаете с a, объект изменяется и, следовательно, b изменяется.

Он сказал, что единственный способ сделать копию на самом деле – создать новый объект, как и другие ответы.

Вы можете узнать об этом подробнее

Python 3.6.0 Сроки

Ниже приведены результаты синхронизации с использованием Python 3.6.0. Имейте в виду, что эти времена относительно друг друга, а не абсолютны.

Я придерживался только мелких копий, а также добавил некоторые новые методы, которые не были возможны в Python2, например list.copy() (эквивалент среза Python3) и список распаковки ( *new_list, = list ):

 METHOD TIME TAKEN b = a[:] 6.468942025996512 #Python2 winner b = a.copy() 6.986593422974693 #Python3 "slice equivalent" b = []; b.extend(a) 7.309216841997113 b = a[0:len(a)] 10.916740721993847 *b, = a 11.046738261007704 b = list(a) 11.761539687984623 b = [i for i in a] 24.66165203397395 b = copy.copy(a) 30.853400873980718 b = [] for item in a: b.append(item) 48.19176080400939 

Мы можем видеть, что старый победитель все еще выходит сверху, но не на самом деле огромным количеством, учитывая повышенную читаемость подхода list.copy() .

Обратите внимание, что эти методы не дают эквивалентных результатов для любого ввода, кроме списков. Все они работают для разрезаемых объектов, некоторые работы для любого итерабельного, но только copy.copy() работает для любого объекта Python.

Вот код тестирования для заинтересованных сторон ( Шаблон отсюда ):

 import timeit COUNT = 50000000 print("Array duplicating. Tests run", COUNT, "times") setup = 'a = [0,1,2,3,4,5,6,7,8,9]; import copy' print("b = list(a)\t\t", timeit.timeit(stmt='b = list(a)', setup=setup, number=COUNT)) print("b = copy.copy(a)\t\t", timeit.timeit(stmt='b = copy.copy(a)', setup=setup, number=COUNT)) print("b = a.copy()\t\t", timeit.timeit(stmt='b = a.copy()', setup=setup, number=COUNT)) print("b = a[:]\t\t", timeit.timeit(stmt='b = a[:]', setup=setup, number=COUNT)) print("b = a[0:len(a)]\t", timeit.timeit(stmt='b = a[0:len(a)]', setup=setup, number=COUNT)) print("*b, = a\t", timeit.timeit(stmt='*b, = a', setup=setup, number=COUNT)) print("b = []; b.extend(a)\t", timeit.timeit(stmt='b = []; b.extend(a)', setup=setup, number=COUNT)) print("b = []\nfor item in a: b.append(item)\t", timeit.timeit(stmt='b = []\nfor item in a: b.append(item)', setup=setup, number=COUNT)) print("b = [i for i in a]\t", timeit.timeit(stmt='b = [i for i in a]', setup=setup, number=COUNT)) 

 new_list = my_list[:] 

new_list = my_list Попытайтесь это понять. Предположим, что my_list находится в памяти кучи в местоположении X, т. Е. My_list указывает на X. Теперь, назначив new_list = my_list вы указываете new_list, указывающий на X. Это называется мелкой копией.

Теперь, если вы назначили new_list = my_list[:] вы просто копируете каждый объект my_list в new_list. Это называется Deep copy.

Другой способ, которым вы можете это сделать:

• new_list = list(old_list)
• import copy new_list = copy.deepcopy(old_list)

Не уверен, что это все еще актуально, но то же самое относится и к словарям. Посмотрите на этот пример.

 a = {'par' : [1,21,3], 'sar' : [5,6,8]} b = a c = a.copy() a['har'] = [1,2,3] a Out[14]: {'har': [1, 2, 3], 'par': [1, 21, 3], 'sar': [5, 6, 8]} b Out[15]: {'har': [1, 2, 3], 'par': [1, 21, 3], 'sar': [5, 6, 8]} c Out[16]: {'par': [1, 21, 3], 'sar': [5, 6, 8]} 

Другой метод (который я считаю довольно читаемым) заключается в том, чтобы превратить его в строку, а затем переключить обратно в список.

 new_list = list(''.join(my_list))