How do I pass a variable by reference in Python?

Understanding Python’s Parameter Passing: Call-by-Object-Reference

In languages like C++ or Java, you may be familiar with the concept of “passing by reference,” where a function receives a direct reference to a variable, allowing changes to that variable inside the function to be reflected outside it. In Python, however, the situation is a bit different. Python uses a mechanism often referred to as “call-by-object-reference” or “call-by-assignment.”

What Does “Call-by-Object-Reference” Mean?

When you pass an argument to a Python function, what actually gets passed is a reference to the object’s value.
If the passed-in object is mutable (like lists, dictionaries, or custom mutable objects), any in-place modifications to that object inside the function are visible outside the function.
If the object is immutable (like integers, floats, strings, or tuples), you cannot change the object’s value in-place. Any reassignment within the function creates a new local object, leaving the original object untouched.

This behavior can sometimes feel similar to “pass by reference” when dealing with mutable objects, but it is not the same as true reference semantics found in other languages. You can’t force Python to treat immutable types as “by reference” in a way that changes their values outside the function.

Examples with Mutable and Immutable Objects

Immutable Object Example (Integer):

def increment(num):
    num += 1  # Creates a new integer object, does not affect the caller's variable
    print("Inside function:", num)

x = 10
increment(x)
print("Outside function:", x)  # Still 10, unchanged

In this case, num += 1 inside the function creates a new integer object. The original x is not modified.

Mutable Object Example (List):

def append_item(lst):
    lst.append("new_item")
    print("Inside function:", lst)

items = ["original"]
append_item(items)
print("Outside function:", items)  # ["original", "new_item"], modified!

Here, the list items is mutable, so the .append() operation modifies the same list object that items references. These changes are reflected outside the function.

Workarounds for Imitating Pass-by-Reference

If you need to modify an immutable variable in a function and have those changes persist outside, consider these approaches:

Return the New Value:

def increment(num):
    return num + 1

x = 10
x = increment(x)  # Reassign x to the returned value
print(x)  # 11

Returning the altered value and reassigning it outside the function is often the cleanest approach.

Use a Mutable Wrapper: If you really need “reference-like” semantics, you can wrap your immutable values in a mutable container, such as a list or a custom class:
```
def increment_first_element(container):
    container[0] += 1

x = [10]
increment_first_element(x)
print(x[0])  # 11
```
Objects That Behave More Like References: Some advanced patterns involve using classes that store values as attributes. Passing the object around and modifying its attributes mimics pass-by-reference more closely:
```
class Box:
    def __init__(self, value):
        self.value = value

def increment(box):
    box.value += 1

x = Box(10)
increment(x)
print(x.value)  # 11
```

Building a Strong Python Foundation

Understanding Python’s parameter passing model is a fundamental skill. If you’re just starting or want to strengthen your Python basics:

Grokking Python Fundamentals: Perfect for beginners, this course ensures a robust foundation in Python’s core concepts, including object references, data types, and function calls.

As you grow more confident and aim to tackle more complex coding challenges or prepare for interviews:

Grokking the Coding Interview: Patterns for Coding Questions: Learn essential coding patterns that you can apply to various problems, solidifying your problem-solving skills.
Grokking Data Structures & Algorithms for Coding Interviews: Develop a deep understanding of data structures and algorithms to tackle large-scale problems efficiently.

Additionally, explore the DesignGurus.io YouTube channel for tutorials, practical tips, and insights from seasoned engineers, helping you refine your coding techniques and design thinking.

In Summary

Python does not use traditional “pass-by-reference” semantics for variables.
Instead, it passes references to objects, meaning mutable objects can be modified within functions, while immutable objects cannot be directly changed.
To effectively “pass by reference,” use mutable objects or return new values from your functions.

By embracing Python’s approach and using the appropriate strategies, you’ll write cleaner, more maintainable code that leverages the language’s strengths rather than fighting against them.