How to modify a function in Python

Have you ever faced a bug in your code when writing Python where you thought you were modifying a local variable but actually modified the variable outside of the function too?

For example, if you have a function like this:

def add_one(x: int, y: list) -> None:
    x += 1
    y += [1]

And when you then call it

a = 0
b = []
add_one(a, b)

You find that a = 0, but b = [1].

In this article we’ll explore what causes this behaviour so that you can avoid running into odd bugs in your code.

The first step in understanding this behaviour is to learn about the difference in how mutable and immutable types behave during assignment.

In Python we have both mutable and immutable data types, which means that you can modify the values of some data types, whilst you cannot modify the values of others.

Examples of mutable types are

• dictionaries
• lists
• sets
• classes

And examples of immutable types are

• strings
• integers
• floats
• booleans
• tuples

Having mutable data types means that we can modify them and still have the same object, whilst if we try to modify an immutable type we create a new object, To be able to demonstrate this behind the scenes we’ll use the built in id() method, which gives us the unique identifier of the object. If two objects have the same identifier, then they are referencing the same object, whilst if the identifiers are different, then they are referencing different objects.

We can see this in action by comparing a mutable data type (list), to an immutable one (int):

x = 0
y = []id(x)  # 4353643616
id(y)  # 4356958960x += 1
y += [1]id(x) # 4353643648
id(y)   # 4356958960

What we can see here is that after adding 1 to x, which currently referenced the value 0, it is now referencing a new object, namely the integer 1. Conversely, our

a = 0
b = []
add_one(a, b)

And so we can see that if we try to modify an immutable data type, we actually reference a new object, whereas for a mutable one we keep the reference to the same object and instead directly modify the contents of the object.

Now that we’ve seen the difference in how mutable and immutable objects work when you apply operations on them, let’s understand the other part of the puzzle that determines why we can modify mutable objects within a function like we saw previously.

This behaviour is due to how Python handles passing arguments to functions, which is done through a principle called “passing by assignment”. Passing by assignment means that we pass in variables in the same way that we would handle variable assignment, for example:

a = 1
b = ab is a  # Truea += 1
b is a  # False

What’s happened here is that we’ve assigned a to reference to integer object 1, and then we’ve assigned b to be equal to

a = 0
b = []
add_one(a, b)

a = 0
b = []
add_one(a, b)

a = 0
b = []
add_one(a, b)

a = 0
b = []
add_one(a, b)

If we then modify

a = 0
b = []
add_one(a, b)

a = 0
b = []
add_one(a, b)

Knowing now how assignment works, if we look back at our list example:

x = []
y = x
x is y  # Truex += [1]
x is y  # Trueprint(x)  # [1]
print(y)  # [1]

We have the sample principle here, with x and

a = 0
b = []
add_one(a, b)

Now that we understand how mutable and immutable objects differ, and also how assignment works in Python, let’s understand what’s actually happening when we call our add_one function from above.

To avoid having to scroll a lot, let’s copy our toy example here again once more

def add_one(x: int, y: list) -> None:
    x += 1
    y += [1]a = 0
b = []add_one(a, b)
print(a) # 0
print(b) # [1]

After creating the function, the first thing we do is assign a to reference the integer object 0, and b an empty list object.

Next we call the function with

a = 0
b = []
add_one(a, b)

a = 0
b = []
add_one(a, b)

a = 0
b = []
add_one(a, b)

a = 0
b = []
add_one(a, b)

a = 0
b = []
add_one(a, b)

a = 0
b = []
add_one(a, b)

a = 0
b = []
add_one(a, b)

a = 0
b = []
add_one(a, b)

Now inside the function we modify x by adding 1 to it. Because our integer is immutable, x gets assigned to reference the new integer object.

Next we add the element 1 to the end of our list. In this case, since our list is mutable, we don’t create a new object but instead update the existing one.

Now that we’ve reached the end of the function and we leave its scope, x and

a = 0
b = []
add_one(a, b)

a = 1
b = ab is a  # Truea += 1
b is a  # False

a = 0
b = []
add_one(a, b)

Python’s internals are very powerful and allow for very flexible code. however, sometimes we can be caught off-guard by their behaviour if we don’t fully understand what’s happening behind the scenes. This can lead to weird bugs in your program that can feel very hard to track down.

Understanding how Python’s assignment operation works, and how mutable and immutable data types behave differently under modification means you don’t just avoid mistakenly having these sorts of “bugs” in your programs, but you can actually use these behaviours to your advantage to writer cleaner, more concise, Python code

Can you change a function in Python?

How do you redefine a function in Python?

What is a modifying function?

Can you modify parameters in Python?