Does assigning another variable to a string make a copy or increase the reference count

Question

On p.35 of "Python Essential Reference" by David Beazley, he first states:

For immutable data such as strings, the interpreter aggressively shares objects between different parts of the program.

However, later on the same page, he states

For immutable objects such as numbers and strings, this assignment effectively creates a copy.

But isn't this a contradiction? On one hand he is saying that they are shared, but then he says they are copied.

Answer 1

An assignment in python never ever creates a copy (it is technically possible only if the assignment for a class member is redefined for example by using __setattr__, properties or descriptors).

So after

a = foo()
b = a

whatever was returned from foo has not been copied, and instead you have two variables a and b pointing to the same object. No matter if the object is immutable or not.

With immutable objects however it's hard to tell if this is the case (because you cannot mutate the object using one variable and check if the change is visible using the other) so you are free to think that indeed a and b cannot influence each other.

For some immutable objects also Python is free to reuse old objects instead of creating new ones and after

a = x + y
b = x + y

where both x and y are numbers (so the sum is a number and is immutable) may be that both a and b will be pointing to the same object. Note that there is no such a guarantee... it may also be that instead they will be pointing to different objects with the same value.

The important thing to remember is that Python never ever makes a copy unless specifically instructed to using e.g. copy or deepcopy. This is very important with mutable objects to avoid surprises.

One common idiom you can see is for example:

class Polygon:
    def __init__(self, pts):
        self.pts = pts[:]
    ...

In this case self.pts = pts[:] is used instead of self.pts = pts to make a copy of the whole array of points to be sure that the point list will not change unexpectedly if after creating the object changes are applied to the list that was passed to the constructor.