[Tutor] about copy.copy

[linda.s]

On 7/18/06, Danny Yoo <dyoo at hkn.eecs.berkeley.edu> wrote:
>
>
> On Tue, 18 Jul 2006, linda.s wrote:
>
> > But in the following example, a/b/c change and it looks like there is
> > no difference.
> >>>> a=[[1,2,3], [4,5,6]]
> >>>> b=a
> >>>> c=copy.copy(a)
>
>
> Hi Linda,
>
> I find it easiest to explain this by going to box-and-pointer diagrams.
> Let me see if this will help you too.
>
> First, some background: we'll say that a "name" is something that's
> directed at a "value" such as a number or a list.  We'll diagram this by
> drawing an arrow from a name to a value.  For example:
>
>      a = 42
>
> will have a diagram of:
>
>      a -------------> 42
>
>
>
> We'll treat a list as a value that itself can point at a lot of values.
> For example:
>
>      a = [1, 2, 3]
>
>
> is going to look like:
>
>      a ------------> [ . , . , . ]
>                        |   |   |
>                        V   V   V
>                        1   2   3
>
> So there's going to be two levels of arrows here.  I'm using periods here
> just as placeholders so you can see where the arrows are starting from.
>
>
>
> Ok, with that background, we'll take a look at the diagram for:
>
>      a = [1, 2, 3]
>      b = a
>      c = copy.copy(a)
>
>                      b
>                      |
>                      |
>                      V
>      a ------------> [ . , . , . ]
>                        |   |   |
>                        V   V   V
>                        1   2   3
>                        ^   ^   ^
>                        |   |   |
>      c ------------> [ . , . , . ]
>
>
> What's going on is that 'a' and 'b' are directed at the same list value.
> 'c' is directed at a different list value, but the elements of that new
> list point to the same elements as 'a'.  We call this a "shallow copy"
> because the copying is only a single level deep.
>
>
> This diagram tries to model what happens when we start mutating the list
> value that 'a' points to.  But let's say that we do a change to one of
> those lists:
>
>      a[0] = 42
>
> This mutates the first cell of the list to point to a value 42.  What does
> this look like?  Try it out, and then look below to compare:
>
> *** spoiler space ***
>
>
>
>
>
>
>
>
> *** spoiler space ***
>
> Ok, here's the diagram I have:
>
>                      b
>                      |
>                      |
>                      V
>      a ------------> [ . , . , . ]
>                        |   |   |
>                        V   |   |
>                       42   |   |
>                            |   |
>                            V   V
>                        1   2   3
>                        ^   ^   ^
>                        |   |   |
>      c ------------> [ . , . , . ]
>
> It shows that 'c' is not going to "change" in the sense that we're not
> going to observe any differences.  It will have appeared, though, that
> mutating the list that 'a' points to will affect 'b'.
>
>
> Do you have any questions so far about this?  Some kind of model like this
> is necessary to understand the situation you're seeing now, so please feel
> free to ask if any part of this is confusing.
>
But in the following example, a change in a spread to both b and c:
>>> a=[[1,2,3], [4,5,6]]
>>> b=a
>>> c=copy.copy(a)
>>> a[0][0]='a'
>>> a
[['a', 2, 3], [4, 5, 6]]
>>> b
[['a', 2, 3], [4, 5, 6]]
>>> c
[['a', 2, 3], [4, 5, 6]]