copy — Shallow and deep copy operations¶
Assignment statements in Python do not copy objects, they create bindings between a target and an object. For collections that are mutable or contain mutable items, a copy is sometimes needed so one can change one copy without changing the other. This module provides generic shallow and deep copy operations (explained below).
Return a shallow copy of x.
Return a deep copy of x.
exception copy. Error ¶
Raised for module specific errors.
The difference between shallow and deep copying is only relevant for compound objects (objects that contain other objects, like lists or class instances):
A shallow copy constructs a new compound object and then (to the extent possible) inserts references into it to the objects found in the original.
A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original.
Two problems often exist with deep copy operations that don’t exist with shallow copy operations:
Recursive objects (compound objects that, directly or indirectly, contain a reference to themselves) may cause a recursive loop.
Because deep copy copies everything it may copy too much, such as data which is intended to be shared between copies.
The deepcopy() function avoids these problems by:
keeping a memo dictionary of objects already copied during the current copying pass; and
letting user-defined classes override the copying operation or the set of components copied.
This module does not copy types like module, method, stack trace, stack frame, file, socket, window, or any similar types. It does “copy” functions and classes (shallow and deeply), by returning the original object unchanged; this is compatible with the way these are treated by the pickle module.
Shallow copies of dictionaries can be made using dict.copy() , and of lists by assigning a slice of the entire list, for example, copied_list = original_list[:] .
Classes can use the same interfaces to control copying that they use to control pickling. See the description of module pickle for information on these methods. In fact, the copy module uses the registered pickle functions from the copyreg module.
In order for a class to define its own copy implementation, it can define special methods __copy__() and __deepcopy__() . The former is called to implement the shallow copy operation; no additional arguments are passed. The latter is called to implement the deep copy operation; it is passed one argument, the memo dictionary. If the __deepcopy__() implementation needs to make a deep copy of a component, it should call the deepcopy() function with the component as first argument and the memo dictionary as second argument. The memo dictionary should be treated as an opaque object.
Discussion of the special methods used to support object state retrieval and restoration.
Six ways to Copy List items in Python
I like to learn cool stuff about python, I have started my Python journey one year ago. Now I am going through the basics of the python to learn more.
I have come across Six ways to copy list items from one list to another in python.
Let's have look at it.
Suppose we want to copy the content of old_list to new_list,
1.Using the Copy() Method: the Copy method of the list object is used to copy only the content inside the list. So the new list will not have the same reference id or memory location. so if we make any changes in the new_list it will not get reflected in the old_ist.
2. Using list() function: List() is built-in function in python. it is also used to create a new list in python. If we pass old_list as an argument inside this function. It copies the content of the old_list and generates a new_list.
The new list will not have same reference id because only content gets copied in this case
Note: Here I have intentionally used copy() as Method and list() as a function to point out the difference. Methods are always called on an object using ‘.’ operator, while function may not. All method is Function but the reverse may not be true.
3. Using List Slicing: List slicing is a way to extract data from a list. So using list slicing if we extract all the content from one list, the new list will have all the content from the old list.
Again this method will only copy content not reference id.
4. Shallow Copy: We can use the copy function of the copy module to get content from one list to another. Again it only copies the content, so the new list will have new Reference id.
5. Deep Copy: We can also use the Deep Copy function of the copy module in the same way as Shallow Copy. Both function works the same for a Normal List having simple content like shown in the example.
There is a difference in the behavior of both the function of the copy module in the case of the Nested List(List inside List).
If you want to know more about the difference between Shallow Copy and Deep Copy feel free to check this link
Suppose we want to copy the content as well as the reference of old_list to new_list,
6. Direct Assigning: If we Assign old_list to the new_list it copies content as well as Reference so changes will be reflected in old_list if it is done in the new_list.
Копирование массива в Python. Метод copy для копирования массива. Представление массива
В этой статье мы поговорим, как скопировать массив в Python и чем копирование массива отличается от представления массива. Также рассмотрим поверхностное и глубокое копирование объектов в Python.
Работая с массивами в Python, вы наверняка сталкивались с ситуацией, когда при использовании некоторых функций, возвращающих какой-нибудь результат, с исходным массивом не происходит ничего. Как в примере ниже:
Всё дело в том, что в библиотеке NumPy есть два понятия касаемо массива: копия и представление. И это разные вещи. Посмотрите на код ниже:
На самом деле, всё просто. Когда мы выполняем присваивание b = a, никакого копирования данных на деле не происходит. В памяти компьютера всё так же один массив, а переменные a и b — это даже не переменные, а указатели, указывающие на одни и те же данные. Таким образом, мы обращаемся по разным указателям к одним и тем же данным в памяти и видим в результате одно и то же.
Хорошо, a и b являются указателями, но что тогда с переменной с? На деле, это тоже указатель, ссылающийся на ту же область памяти с данными, правда, представлены эти данные в иной форме. Вот мы и подошли к понятию представления массива, которое существует в NumPy. Действительно, те же данные можно представить в разной форме:
На деле, можно говорить о копировании, если данные в памяти компьютера физически копируются в другое место. Но, как мы уже убедились, операция присваивания копирование не выполняет. Также мы поняли, что те же самые данные могут иметь различные представления.
Присваивание не копирует массивы в Python
Итак, простое присваивание никаких копий массива не выполняет, и это первое, что стоит уяснить. Может показаться, что это всего лишь прихоть создателей Python и NumPy, но всё не так просто. Если бы ситуация обстояла иначе, мы бы работали с памятью напрямую, а отсутствие автоматического копирования во время присваивания — совсем небольшая плата за лёгкость и простоту языка программирования Python.
Давайте приведём ещё парочку примеров на эту тему:
Обратите внимание, что массивы a и b в действительности являются одним и тем же массивом с такими же данными и типом данных.
Таким образом, у нас есть массив b и массив a, но нельзя забывать о том, что это, по сути, один и тот же массив.
Так как же копировать массивы в Python?
Чтобы сделать полную копию массива в Python, используют метод copy. Он выполняет копирование не только данных массива, но и всех его свойств.
После применения метода copy мы можем говорить о массивах a и b, как о разных массивах и копиях друг друга. Да, эти массивы имеют одинаковые данные, но эти данные не являются одними и теми же. Теперь действительно массив b является копией массива a, и именно это называется копированием массива в терминологии NumPy.
Представление массива
Итак, теперь мы знаем, как сделать копию массива посредством метода copy. Но бывают ситуации, когда нам не нужна копия массива, а нужен тот же массив но с иными размерами. Речь идёт, как вы уже догадались, о другом представлении исходного массива.
Для этих целей в NumPy есть метод ndarray.view() . Он создаёт новый объект массива, просматривающий данные исходного, однако изменение размеров одного массива не приводит к изменению размеров другого.
Обычно, функции которые меняют форму и порядок элементов в Пайтон-массивах возвращают не копию массива, а именно его представление:
Также представлениями массивов в Python являются срезы массивов:
Обратите внимание, что когда мы говорим о том, что массив b является представлением массива a, мы подразумеваем, что вне зависимости от вида и формы массива b он включает в себя те же данные в памяти, что и наш массив a. Таким образом, изменение элементов в одном из массивов приведёт, соответственно, к изменениям в другом.
Глубокое и поверхностное копирование объектов с помощью copy
Как мы уже хорошо уяснили, операция присваивания не приводит к копированию объекта, а лишь создаёт ссылку на этот объект. Но если мы работаем с изменяемыми коллекциями или коллекциями, которые содержат изменяемые элементы, нам может понадобиться такая копия, которую мы сможем изменить, не меняя оригинал. Здесь нам тоже поможет copy, выполняющий как поверхностное, так и глубокое копирование: • copy.copy(a) — возвращает поверхностную копию a; • copy.deepcopy(a) — возвращает полную копию a.
Если же объект скопировать невозможно, возникает исключение copy.error. В принципе, разница между глубоким и поверхностным копированием существенна лишь для составных объектов, которые содержат изменяемые объекты (допустим, список списков). При этом: 1) поверхностная копия позволяет создать новый составной объект, а потом (если это возможно) вставляет в него ссылки на объекты, которые находятся в оригинале; 2) глубокая копия позволяет создать новый составной объект, а потом рекурсивно вставляет в него копии объектов, которые находятся в оригинале.
При выполнении глубокого копирования возможны проблемы (их нет у поверхностного копирования): — рекурсивные объекты могут привести к рекурсивному циклу; — т. к. глубокая копия копирует всё, она способна скопировать слишком много, к примеру, административные структуры данных.
Однако в случае возникновения проблем нам поможет функция deepcopy, которая устраняет эти сложности: — посредством хранения «memo» словаря объектов; — позволяя классам, которые определяет пользователь, переопределять операцию копирования либо набор копируемых компонентов.
В результате, не копируются типы вроде классов, функций, модулей, методов, стековых кадров, окон, сокетов и т. п.
Что же, теперь, надеемся, вы получили представление о копировании массивов и объектов в Python. Если хотите знать больше, к вашим услугам специализированный курс для продвинутых разработчиков:
5 Ways to Copy a List in Python: Let’s Discover Them
It’s very common to copy a list in your Python programs. But, what should you absolutely know about copying lists?
How to copy a Python list?
Python provides multiple ways to copy a list depending on what your program needs to do with the existing list. You can use the assignment operator, the list copy method, the slice notation and shallow or deep copy.
This tutorial is designed to show you everything you need to know about copying lists in Python.
Let’s get started!
How to Make a Copy of a List in Python
I will start with a simple example to understand together how copying list works in Python.
After defining a list called numbers I use the assignment operator ( = ) to copy this list to a new list called new_numbers.
Let’s see what happens…
Now I add a new element to the new_numbers list using the append method and verify the elements in both lists using the print function:
For some reason even if we have added the new number to the new_numbers list only, both of our lists contain the new number.
We will use the built-in id function to print the memory address of our two lists and to make it more readable we will also use the hex function that provides an hexadecimal representation of an integer.
Can you see the problem?
Both variables point to the same memory address, so numbers and new_numbers points to the same list object. That’s why we see the new element in both of them.
So, how can we copy our list to a completely new object?
How to Create An Actual Copy of the Original List
Python provides the list copy method that allows to create a new list object from the one we copy.
Let’s use the copy method on our original list to create the list new_numbers:
Now we will append a number to the new list we have created and we will verify that the number is not present in the original list:
This time the original list has not been changed by the append method applied to the new list.
And as confirmation we will also verify the memory location of both list objects:
Different memory addresses for the two objects. That’s good!
Copying Using the Python Slice Notation
Another way to copy a Python list is with the slice notation.
The slice notation can be used to copy parts of a list into a new list or even the entire list by simply using the following expression:
Let’s apply it to our numbers list:
After adding another number to the new list you can see that the original list, once again, is unchanged:
And that with the slice notation we have created a new list object:
And also this one is done! ��
Shallow Copy Vs Deep Copy
The difference between a shallow copy and a deep copy only applies to compound objects, in other words to objects that contain other objects.
Examples of compound objects are class instances and lists.
The Python copy module allows to create shallow copies and deep copies of objects. Below you can see the syntax for both types of copy:
With a shallow copy a new compound object is created (e.g. a list of lists) and references to the objects found in the original object are added to the new compound object.
In the next section we will see exactly how a shallow copy works.
In the meantime I want to make clear the difference between a shallow copy and a deep copy.
A deep copy creates a new compound object (e.g. a list of lists) then it also creates copies of the objects found in the original object and inserts them in the new compound object.
The definitions of shallow copy and deep copy will be a lot clearer in the next sections where we will see how they work in practice.
How to Make a Shallow Copy in Python
Let’s see how a shallow copy works with a list…
…try these commands in your Python shell to make sure the behaviour of shallow and deep copying is clear to you:
If I add an element to the new_numbers list the original list doesn’t change:
This confirms that in the shallow copy a new compound object has been created. In other words the new compound object is not a reference to the original object.
But now, let’s try to update one element common between the original and the new list:
I have updated the first element of the first list object in the original list.
As you can see the element has been updated in both lists, the original and the new one.
That’s because we have used a shallow copy and hence the first element of the new_numbers list is just a reference to the first element of the numbers list ([1,2,3]).