Cloning Objects for Fun and Profit

Cloning Objects for Fun and Profit
Aassignment statements in Python do not create copies of objects, they only bind names to an object. For immutable objects, that usually doesn’t make a difference.

But for working with mutable objects or collections of mutable objects, you might be looking for a way to create “real copies” or “clones” of these objects.

Essentially, you’ll sometimes want copies that you can modify without

Let’s start by looking at how to copy Python’s built-in collections. Python’s built-in mutable collections like lists, dicts, and sets can be copied by calling their factory functions on an existing collection:

In [1]: new_list = list(original_list)
In [2]: new_dict = dict(original_dict)
In [3]: new_set = set(original_set)

However, this method won’t work for custom objects and, on top of that, it only creates shallow copies. For mutable collections like lists, dicdts, and sets, there’s an important difference between shallow and deep copying:

A shallow copying means constructing a new collection object and then populating it with references to the child objects found in the original, In essence, a shallow copy is only one level deep. The copying process does not recurse and therefore won’t create copies of the child objects themselves.

A deep copy

I know, that was a bit of a mouthful. So let’s look at some examples to drive home this difference between deep and shallow copies.

Making Shallow Copies

In the example below, we’ll create a new nested list and then shallowly

In [2]: xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

In [3]: ys = list(xs)  # Make a shallow copy

This means ys will now be a new and independent object with the same contents as xs. You can verify this by inspecting both objects:

In [5]: xs
Out[5]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
In [4]: ys
Out[4]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

To confirm ys really is independent from the original, let’s devise a little experiment. You could try and add a new sublist to the original (xs) and then check to make sure this modification didn’t affect the copy(ys):

In [6]: xs.append(['new sublist'])
In [7]: xs
Out[7]: [[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]

In [8]: ys
Out[8]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

As you can see, this had the expected effect. Modifying the copied list at a “superficial” level was no problem at all.

However, because we only created a shallow copy

These children were not

Therefore, when you modify one of the child objects in xs, this modification will be reflected in ys as well–that’s because both lists share the same child objects.

In [9]: xs[1][0] = 'X'

In [10]: xs
Out[10]: [[1, 2, 3], ['X', 5, 6], [7, 8, 9], ['new sublist']]

In the above example we(seemingly) only made a change to xs. But it turns out that both sublists at index 1 in xs and ys were modified. Again, this happened because we had only created a shallow

Had we created a deep copy of xs in the first step, both objects would’ve been fully independent. This is the practical difference between shallow and deep copies of objects.

Now you know how to create shallow copies of some of the built-in collection classes, and you know the diffrence between shallow and deep copying. The questions we still want answers for are:

How can you create deep copies of built-in collections?
How can you create copies(shallow and deep) of arbitrary objects, including custom classes?
The answer to these questions lies in the copy module in the Python standard library. This module provides a simple interface for creating shallow and deep copies of arbitrary Python objects.

Making Deep Copies

Let’s repeat the previous list-copying example, but with one important difference. This time we’re going to create a deep

In [13]: import copy
In [14]: xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
In [16]: zs = copy.deepcopy(xs)

When you inspect xs and its clone zs that we created with copy.deepcopy(), you’ll see that they both look identical again - just like in the previous example:

In [17]: xs
Out[17]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

In [18]: zs
Out[18]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

However, if you make a modification to one of the child objects in the original object(xs). You’ll see that this modification won’t affect the deep copy (zs).

Both objects, the original and the copy, are fully independent this time. xs was cloned recursively, including all of its child objects:

In [20]: xs[1][0] = 'X'

In [21]: xs
Out[21]: [[1, 2, 3], ['X', 5, 6], [7, 8, 9]]
In [22]: zs
Out[22]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

You might want to take some time to sit down with Python interpreter and play through these examples right about now. Wrapping your head around copying objects is easier when you get to experience and play with the examples firsthand.

By the way, you can also create shallow copies using a function in the copy module. The copy.copy() function creates shallow copies of objects.

This is useful if you need to clearly communicate that you’re creating a shallow copy somewhere in your code. Using copy.copy() lets you indicate this fact. However, for built-in collections it’s considered more Pythonic to simply use the list, dict, and set factory functions to creat shallow copies.

Copying Arbitrary Objects

The question we still need to answer is how do we create copies( shallow and deep) of arbitrary objects, including custom classes. Let’s take a look at that now.

Again the copy module comes to our rescue. Its copy.copy() and copy.deepcopy() functions can be used to duplicate any object.

Once again, the best way to understand how to use these is with a simple experiment. I’m going to base this on the previous list-copying example. Let’s start by defining a simple 2D point class:

In [23]: class Point:
    ...:     def __init__(self, x, y):
    ...:         self.x = x
    ...:         self.y = y
    ...:     def __repr__(self):
    ...:         return f'Point({self.x!r}, {self.y!r})'

I hope you agree that this was pretty straightforward. I added a repr() implementation so that we can easily inspect objects created from this class in the Python interpreter.

Next up, we’ll create a Point instance and then (shallowly) copy it, using the copy module:

In [25]: a = Point(23, 42)

In [26]: b = copy.copy(a

If we inspect the contents of the original Point object and its (shallow) clone, we see what we’d expect:

In [27]: a
Out[27]: Point(23, 42)

In [28]: b
Out[28]: Point(23, 42)

In [29]: a is b
Out[29]: False

Here’s something else to keep in mind. Because our point object uses immutable types(ints) for its coordinates, there’s no difference between a shallow and a deep copy in this case. But I’ll expand the example in a second.

Let’s move on to a more complex example. I’m going to define another class to represent 2D rectangles. I’ll do it in a way that allows us to create a more complex object hierarchy- my rectangles will use Point objects to represent their coordinates:

In [32]: class Rectangle:
    ...:     def __init__(self, topleft, bottomright):
    ...:         self.topleft = topleft
    ...:         self.bottomright = bottomright
    ...:     def __repr__(self):
    ...:         return (f'Rectangle({self.topleft!r}),'
    ...:                 f'{self.bottomright!r})')

Again, first we’re going to attempt to create a shallow copy of a rectangle instance:

In [33]: rect = Rectangle(Point(0, 1), Point(5, 6))

In [34]: srect = copy.copy(rect)

If you inspect the original rectangle and its copy, you’ll see how nicely the repr() override is working out, and that the shallow copy process worked as expected:

In [35]: rect
Out[35]: Rectangle(Point(0, 1), Point(5, 6))
In [36]: srect
Out[36]: Rectangle(Point(0, 1), Point(5, 6))
In [37]: rect is srect
Out[37]: False

Remember how the previous list example illustrated the difference between deep and shallow copies? I’m going to use the same approach here. I’ll modify an object futher down in the object hierarchy, and then you’ll see this change refelcted in the (shallow) copy as well:

In [39]: rect
Out[39]: Rectangle(Point(999, 1)),Point(5, 6))
In [40]: srect
Out[40]: Rectangle(Point(999, 1)),Point(5, 6))

I hope this behaved how yo expected it to. Next, I’ll create a deep copy of the original rectangle. Then I’ll apply another modification and you’ll see which objects are affected:

In [41]: drect = copy.deepcopy(srect)
In [43]: drect.topleft.x = 222

In [44]: drect
Out[44]: Rectangle(Point(222, 1)),Point(5, 6))

In [45]: rect
Out[45]: Rectangle(Point(999, 1)),Point(5, 6))

In [46]: srect
Out[46]: Rectangle(Point(999, 1)),Point(5, 6))

Voila! This time the deep copy (direct) is fully independent of the original(rect) and the shallow copy(secret).

We’ve covered a lot of ground here, and there are still some finer points to copying objects.

It pays to go deep(ha!) on this topic, so yo may want to study up on the copy module documentation, and possibly even the module’s source code. For example, objects can control how they’re copied by defining the sepcial methods copy() and deepcopy() on them. Have fun!☕️