Shallow vs Deep Copying in Python - Advanced Python 20 - Programming Tutorial

Key Takeaways

hi everybody welcome to a new Python tutorial in this tutorial we will talk about copying so we will learn how we can copy mutable elements with a built-in copy module and the difference between shallow and deep copies and we will also have a look at how to make actual copies of custom objects so let's start and first of all let's have a look at the assignment operator so let's say we have a variable call it orc and this is now a number and now if you want to make a copy with an assignment so we say copy equals original then this will not make a real copy it will only create a new variable with the same reference so now both variables point to the same number and now for immutable types like this integer this is not a problem so let's say if we change the copy then say copy equals 6 then this assignment will again create a new variable so days they are now both independent so if we print the copy and if we print the original they are different but when we deal with mutable types so for example a list then we have to be careful so let's say we have a list here with some elements so let's say 0 1 2 3 4 and now we make a copy with this assignment operator and then if we change elements of our copy so let's say we want to change the first item and say this is now minus 10 and now if you print both the copy and the original we see that also the original has the value minus 10 here and this is because this assignment operator doesn't make an actual copy so to make an actual copy we can use the built-in copy module so we can say import copy and then we have to make a difference between shallow and deep being so a shallow copy is only one level deep so at the first level it makes an actual copy but then it only copies references of the nested child objects and then there's the deep copy so this will be in a full independent copy so let's start with an with a shallow copy so to make a shallow copy we can say copy equals copy dot copy and then the original and now if we print both we see that the original didn't get affected so only the copy here has minus ten and for example with a list there are several different options to make shallow copies so we can also say copy equals original dot copy so this will also work or we can use the list function and give it the original as an argument this is also possible or we can use list slicing so we can say org and then the slicing operator so this will simply be from start to end so this will copy all elements and this will also make an actual copy or a shallow copy so this works fine if our element is only one level deep and now let's say we have a nest or nested list so let's say we have a first list here a list inside a list and then a second list here so that's some more elements three so this is our original list and now we make a shallow copy and now we change an object or an item that is at the second level so we say copy at index zero so in this list and then again and index 0 so this element or for another example let's make index 1 here so this is this element and now this we want to set to minus 10 and now let's see what happens so if we run this we see that both the copy and the original now have minus 10 here and this is because a shallow copy is only one level deep so to make an actual copy in all the levels we have to make a deep copy so we can say copy dot deep copy and now if we run this we see that the original didn't get affected so this is the difference between shallow and deep copying and for the built-in types like lists dictionaries or tuples we can use these methods but we can also use it for custom objects so let's say we have a custom class and call it person and now in the in it it gets self of course and then it gets a name and an age and then we say self dot name equals name and self dot H equals H and now let's create two persons person 1 equals person and now it's a name it gets Alex and as an age let's say 27 and now let's make a copy simply by assigning it so let's say person 2 equals person 1 and now if we change person 2 dot H equals 28 and now if you print person 2 dot H and we also print person 1.8 then we see again and both got affected because this is not an actual copy so here we can use copy dot copy and now if we run this we see we have a shallow copy here so the original person didn't get affected but again now if we have a deeper structure so let's say or let's first create or person class and let's say we also have a class company this gets this has an init method so in it self and now this gets two persons it gets a boss and an employee so self top boss equals boss and self dot employee equals employee and now we create two persons so one boss so the boss might be holder and now a second person Joe with a little bit younger and now let's say we want to have a company so we say company equals company with our person one and our person too and now if we want to make a clone of this so if we say company clone equals company well let's right away make a shallow copy so we can say copy dot copy and now if we change some variable here so let's say one boss turns a year older so let's say company clone top boss dot H equals 56 now and now let's print this print company clone dot boss dot age and also print the age of the boss of the original company so let's say company boss age then again we see it got affected because this is only a shallow copy and the H is at the level 2 so this will again only be a copy of the reference here and in order to make this independent we have to say copy dots deep copy and now if you run this we see that the original boss is still 55 so this is the difference between shallow and deep copying I hope you enjoyed this tutorial and see you in the next tutorial where we will learn about context managers in Python