Is Python Pass by Value or Pass by Reference? Example

Python is a popular programming language known for its simplicity and ease of use. When working with Python, it's important to understand how values are passed between functions and methods. Specifically, many developers wonder whether Python is pass by value or pass by reference. In this blog post, we'll explore this topic in depth and provide some examples to help illustrate the concepts.

Pass by Value vs. Pass by Reference

First, let's define what we mean by pass by value and pass by reference. In a pass by value language, when a function or method is called, a copy of the value is created and passed to the function. This means that any changes made to the value within the function are only made to the copy, and not the original value. In contrast, in a pass by reference language, a reference to the original value is passed to the function, so any changes made to the value within the function are made to the original value.

Python's Approach

So which approach does Python use? The answer is... neither! Python actually uses a third approach, which is sometimes called "pass by assignment" or "pass by object reference". In this approach, a reference to the value is passed to the function, but the reference itself is passed by value. This means that any changes made to the value within the function are made to the original value, but if the function reassigns the reference to a new value, that change is not reflected outside the function.

Let's look at some examples to illustrate this concept.

Example 1: Immutable Types

In Python, some types of variables are immutable, meaning they cannot be changed after they are created. Examples of immutable types include integers, floats, strings, and tuples. When we pass an immutable type to a function, any changes made to the value within the function are not reflected outside the function. For example:

def change_number(x):

    x += 1



num = 5

change_number(num)

print(num) # Output: 5

we define a function that takes an integer as an argument and adds 1 to it. We then create a variable num with the value 5, and pass it to the function. However, when we print the value of num after calling the function, we see that it has not changed. This is because integers are immutable in Python, so when we pass num to the function, a copy of the value is created and passed, rather than a reference to the original value.

Example 2: Mutable Types

In contrast to immutable types, mutable types in Python can be changed after they are created. Examples of mutable types include lists, dictionaries, and sets. When we pass a mutable type to a function, any changes made to the value within the function are reflected outside the function. For example:

def add_to_list(lst, val):
    lst.append(val)

my_list = [1, 2, 3]
add_to_list(my_list, 4)
print(my_list) # Output: [1, 2, 3, 4]

In Above example, we define a function that takes a list and a value as arguments, and appends the value to the list. We then create a variable my_list with the values 1, 2, and 3, and pass it to the function along with the value 4. When we print the value of my_list after calling the function, we see that it has been modified to include the value 4. This is because lists are mutable in Python, so when we pass my_list to the function, a reference to the original list is passed.

Python's approach to passing values to functions is neither strictly pass by value nor pass by reference, but rather a combination of the two known as "pass by assignment" or "pass by object reference". Understanding this concept is important when working with Python, as it affects how values are modified within functions and whether those modifications are reflected outside of the function.

Some common use cases for generators in Python include generating large amounts of data on the fly, iterating over a sequence of values without storing them in memory, and implementing lazy evaluation. By using generators, you can write more efficient and memory-friendly code, which can be especially important in situations where you are working with large datasets.

while Python is not strictly pass by value or pass by reference, its approach of "pass by assignment" or "pass by object reference" provides a useful combination of the two. Generators are a powerful feature of Python that can help you write more efficient and memory-friendly code in a variety of use cases.