9. References

In programming, particularly in languages like Python, lists are mutable objects. This means that when you pass a list to a function (as a parameter), you’re passing a reference to the original list, not a copy of it. This has significant implications, particularly in terms of side effects. Understanding these effects is crucial for writing reliable and maintainable code.

9.1. Variable and immutable values

In Python, variables do not directly contain values as they might in some other programming languages. Instead, a variable holds a reference to a value that is stored somewhere in memory. To better understand this concept, imagine that the Python interpreter manages two distinct spaces:

The Namespace (Left Space): This is the space that is directly accessible to the user. It contains the variables that have been defined in your program. You can think of it as a map where variable names are the keys, and these keys point to objects in the memory.

The Memory Space (Right Space): This is where the actual values are stored. This space is not directly accessible to the user but is managed internally by the interpreter. When you assign a value to a variable, the variable in the namespace becomes a reference or pointer to an object in this memory space.

Consider the following assignment:

x = 5

Here’s what happens behind the scenes:

• The interpreter creates an integer object with the value 5 in the memory space.

• A variable x is created in the namespace and is assigned a reference to the memory location where the value 5 is stored.

Let’s continue with y = 10.

What happens when we execute the following instruction y = x? The right-hand side of the equation is evaluated first. We retrieve the value associated with the variable x. Then, the variable y will be assigned this same value. Both variables will point to the same data. The value 10 is no longer referenced and will eventually be removed from memory by a mechanism known as the garbage collector (see Garbage Collector).

Let’s now assume we define a function inc. It takes a parameter and returns the value of this parameter incremented by 1.

def inc(x):
    x = x+1
    return x

What is the effect of this definition on memory? As we have seen, functions can be manipulated like variables, and everything works in a similar way. A variable inc is created in the namespace, and a function object is added to the memory space.

When we call the inc function, the interpreter retrieves the object associated with the inc variable. This object contains the instructions that will be executed. Let’s try to observe with our diagram what happens when the instruction x = inc(x) is called…

First, a local name space is created when the function is called. The parameter x is created and assigned the value 5. This parameter is a local variable that masks the x variable in the global name space.

After executing the first line of the function x = x+1, we obtain the following diagram.

Let’s recall that we are observing the execution of the following instruction.

x = 5
y = x

def inc(x):
    x = x+1
    return x

x = inc(x)

At the moment the return statement is executed, the value associated with the local variable x is used to replace the function call inc(x). The global variable x is then assigned the value referenced by the local variable x, which is 6. Finally, the local memory namespace of the function call is destroyed.

So far, everything is relatively clear, and there are no issues because values like 5, 6, or 10 are immutable…

9.2. Variable and Mutable Values

If everything we’ve seen is clear, then the following should be as well, but you should understand why we need to be cautious with mutable values and function calls.

Let’s imagine we have the following code and use the same diagram to observe memory behavior.

l = [0, 1, 2, 3]
h = l

def inc(k):
    k[0] += 1
    
inc(l)

After executing the first three instructions, we have the following state.

When the function inc(l) is called, a local variable is created, and it is clear that the only existing list is modified. The value of the first element changes from 0 to 1.

If we want different behavior, we need to start the inc function by duplicating the list (using a slice) and, importantly, return the new list. We obtain the following code.

l = [0, 1, 2, 3]
h = l

def inc(k):
    k = k[:]
    k[0] += 1
    return k
    
l = inc(l)

After executing this code, l = [1, 1, 2, 3] and h = [0, 1, 2, 3].

9.3. Fonction id

A good way to observe whether lists are duplicated or not is to use the id function. This function allows you to find out the identifier of an object (see Object ID). Without going into details, the identifier of an object is unique and can be considered to correspond to its memory address.

>>> l = [0, 1, 2, 3] # l associated with a new list
>>> id(l)            # the id of the list 
4332163136
>>> h = l            # h is associated to the same list
>>> id(h)            # the id is obviouly the same...
4332163136
>>> l[0] = 1         # object is mutable
>>> id(l)            # id is not changed
4332163136
>>> h                # the two variables refer to the same list
[1, 1, 2, 3]
>>> l = l[:]         # duplication
>>> id(l)
4333099776           # the id is not the same, it is an other list, even if the value are the same
>>> l[0] = 100       # only one list is modified
>>> l, h
([100, 1, 2, 3], [1, 1, 2, 3])