python assignment by value or reference

Free Python 3 Tutorial
Control Flow
Exception Handling
Python Programs
Python Projects
Python Interview Questions
Python Database
Data Science With Python
Machine Learning with Python
How to perform modulo with negative values in Python?
Python - Iterate through list without using the increment variable
How to install Python Pycharm on Windows?
Working with Binary Data in Python
Primary and secondary prompt in Python
Python Docstrings
Understanding the Execution of Python Program
is keyword in Python
Difference between continue and pass statements in Python
break, continue and pass in Python
Indentation in Python
Use of nonlocal vs use of global keyword in Python
Python assert keyword
Difference between Yield and Return in Python
Variables under the hood in Python
Context Variables in Python
Python Scope of Variables
Internal working of Python
Python2 vs Python3 | Syntax and performance Comparison

Is Python call by reference or call by value

Python utilizes a system, which is known as “Call by Object Reference” or “Call by assignment”. If you pass arguments like whole numbers, strings , or tuples to a function, the passing is like a call-by-value because you can not change the value of the immutable objects being passed to the function. Passing mutable objects can be considered as call by reference or Python pass by assignment because when their values are changed inside the function, then it will also be reflected outside the function.

What is Call By Reference in Python?

In Python , “call by reference” is a way of handing arguments to functions where the reference to the real object gets passed instead of the object’s actual value. This means that if you make changes to the object within the function, those changes directly affect the original object outside the function. It’s important to highlight that this approach in Python is not the same as the traditional “call-by-reference” used in some other programming languages. Python follows its own model, often called “pass-by-object-reference,” emphasizing the passing of references to objects while maintaining its unique characteristics.

What is Call By Value in Python?

In Python, the common way of passing function arguments is through “call by value.” This means that when you pass a variable to a function, you’re essentially handing over the actual value of the variable itself, not the reference to the object it’s pointing to. Consequently, any changes made to the variable within the function don’t directly affect the original variable outside the function. This approach is consistent with the principles of “call by value” and sets it apart from the “call by reference” mechanisms seen in some other programming languages. In simpler terms, the function deals with a copy of the variable’s value, ensuring that the original variable remains unchanged in the broader context of the program.

Python Call By Reference or Call By Value

Below are some examples by which we can understand better about this:

Example 1: Call by Value in Python

In this example, the Python code demonstrates call by value behavior. Despite passing the string variable “Geeks” to the function, the local modification inside the function does not alter the original variable outside its scope, emphasizing the immutability of strings in Python.

Example 2: Call by Reference in Python

In this example, the Python code illustrates call by reference behavior. The function add_more() modifies the original list mylist by appending an element, showcasing how changes made inside the function persist outside its scope, emphasizing the mutable nature of lists in Python.

Binding Names to Objects

Example 1: variable identity and object equality in python.

In Python, each variable to which we assign a value/container is treated as an object. When we are assigning a value to a variable, we are actually binding a name to an object .

Example 2: List Identity and Object Equality in Python

In this example, the Python code compares the memory addresses (locations) of two list variables, a and b , using the id() function. Despite having identical values, the is keyword evaluates to False , indicating that these lists are distinct objects in memory, highlighting the importance of memory address comparison for object identity in Python.

Example 3: Immutable Objects and Function Parameter Behavior in Python

In this example, the Python code demonstrates the immutability of strings by passing the variable string to the function foo() . Despite attempting to assign a new value inside the function, the original string remains unchanged outside its scope, illustrating that string variables are immutable in Python.

Example 4: Mutable Objects and In-Place Modification in Python Functions

When we pass a mutable variable into the function foo and modify it to some other name the function foo still points to that object and continue to point to that object during its execution.

Please Login to comment...

python-basics
How to Delete Whatsapp Business Account?
Discord vs Zoom: Select The Efficienct One for Virtual Meetings?
Otter AI vs Dragon Speech Recognition: Which is the best AI Transcription Tool?
Google Messages To Let You Send Multiple Photos
30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

How to Call By Value and Call By Reference in Python

In this Python tutorial, I will show you how to call by value and call by reference in Python .

Both the concepts of call by value and call by reference are very helpful in memory management, data manipulation, and even API development.

In this tutorial, I have explained the meaning of call by value and reference and, with examples, shown how to implement these concepts and how they differ.

Let’s begin,

Table of Contents

What does Call By Value and Call By Reference in Python Mean?

In several programming languages, you can pass the data to the function argument in two ways: by value and reference (address).

Calling by value means passing the value to the function’s argument; if any changes are made to that value within the function, then the original value outside the function remains the same.
Whereas Calling by reference means passing the address of a value to the function’s argument, if any changes are made to that value within the function, they also change the value outside the function.

Understanding these two concepts is very helpful because it allows you to manage your data in a better way.

But I want to tell you one thing: Python does not have the concept ‘call by value’ like languages like C , C++ , Java , etc. Instead, it passes the object reference by value.

This means you pass the immutable objects, such as integers and tuples, to the function argument; it acts like a call by value because the nature of immutable objects prevents any changes within the function from affecting the original objects.

If we talk about the call by reference in Python, mutable objects, such as lists, dictionaries, etc, are passed to the function arguments. Since the function gets the reference to the original object, whatever modification is made to objects changes the original object.

Your concept of call by value and reference must have been clear until now; if not, don’t worry. You will understand it through examples.

Pass By Value and Pass by Reference in Python

Before beginning, remember one thing: the original value doesn’t change in the call by value, but it does change in the call by reference. Also, I will use the words pass or call interchangeably, depending upon the context.

Pass By Reference in Python

As I said, when mutable objects such as lists and dictionaries are passed to the function arguments. Any changes made to these objects within a function by an operation also change the original objects outside the function.

Let’s see, first, create a dictionary named ‘user_profile’ as shown below.

In the above code, the dictionary user_profile contains two key-value pairs: username and email as keys and Tylor and [email protected] as values, respectively.

Now, create a function that updates the user profile email as shown below.

In the above code, the update_user_profile function takes two arguments: the user data through user_info and the user’s new email through user_email that you want to update.

Before calling the function with those values, note the user’s current email; now, let’s call the function with user_profile and new email ‘[email protected]’ as shown below.

Look at the output when you call the function update_user_profile, passing it a dictionary ‘user_profile’ whose email you want to update and the new email ‘[email protected]’. It updates both emails inside and outside the function.

This means it changes the original dictionary ‘user_profile’ outside the function you created.

This is how to call or pass by reference in Python.

Pass By Value in Python

In pass-by-value, when immutable objects such as integers, strings and tuples are passed to the function arguments. Any changes made to these objects within a function by an operation don’t change the original objects outside the function.

To understand this concept, let’s take a simple example.

Create a variable value and initialize it with 5, as shown below.

Create a function named ‘addition’ that accepts the value and increments it by 1, as shown below.

Call the function by passing the variable value (containing 5) you created, as shown below.

Look at the output; the value outside the function is not affected. It contains the same value, which is 5, but the value in the function is incremented by one; it includes the value 6.

Here, when you pass the variable value to function addition(value) , the copy of the variable is passed (in reality, it is an immutable object), so within the function, this line value = value + 1 adds the one to the copy of the variable, not on the original one.

So, only the variable value within a function is incremented, not the variable value outside the function.

This is how to pass by value in Python.

Difference Between Pass By Value and Pass By Reference in Python

Let’s understand the pass-by-reference vs. pass-by-value Python.

In this Python tutorial, you learned how to call by value and call by reference in Python with examples.

Additionally, You learned what call by value and reference means and the difference between them.

Master Python’s ‘Pass by Value’, ‘Pass by Reference’ & ‘Pass by Assignment’: Comprehensive Guide Revealed!

Pass by Reference in Python | With Examples

When a programming language uses “pass by reference”, it means that when you pass a variable as an argument to a function, you are actually passing a reference to the memory location of that variable, rather than a copy of its value. Because of this, any changes made to the variable inside the function will reflect on the original variable outside the function.

In simple terms, think of a variable as a box containing a value. Instead of handing over a separate box with the same contents (as is the case with “pass by value”), “pass by reference” gives someone a direct link or pointer to the original box. Any modifications made through this link will directly affect the contents of that original box.

It’s worth noting that not all languages strictly adhere to “pass by reference” or “pass by value”. Python, for example, has a unique behavior often termed as “pass by assignment” or “pass by object reference”. In Python’s case, whether the behavior seems like “pass by reference” or “pass by value” depends on whether the data type of the variable is mutable or immutable.

Table of Contents

How Python manages memory and variables?

Python, as a high-level programming language, abstracts many of the intricate details of memory management to simplify the development process for programmers.

Yet, understanding how Python handles memory and variables can be invaluable in certain scenarios, such as debugging, optimizing performance, and ensuring efficient use of resources. In this exposition, we’ll dive deep into Python’s memory management mechanism and use code to bring these concepts to life.

Python Manages Memory and Variables by following methods

Objects and Reference Counting
Garbage Collection
Immutable vs Mutable Objects
Memory Pools and Block Allocation
Dynamic Typing

Now I will explain these, one by one in more detail. Let’s start with that.

1. Objects and Reference Counting:

In Python, everything is an object. Every integer, string, list, or function is an instance of an object.

Python uses reference counting to track the number of references that point to an object.

The memory for objects with zero references can be reclaimed.

2. Garbage Collection:

Apart from reference counting, Python also has a garbage collector to detect and clean up objects that have circular references (i.e., they reference each other) and therefore would not be cleaned up by just using reference counting.
The garbage collector mainly works by identifying unreachable objects and making sure their memory is released.

3. Variable Assignment:

When a variable is assigned to an object in Python, the variable essentially points or references that object in memory.
For instance, when you do a = [1, 2, 3] , the variable a references the list object [1, 2, 3] in memory.
If you then do b = a , both a and b point to the same object in memory. This does not create a new list but merely a new reference to the same list.

4. Immutable vs Mutable Objects:

Python has both immutable objects (e.g., strings, integers, tuples) and mutable objects (e.g., lists, dictionaries).
Immutable objects can’t be changed after they are created. Any operation that appears to modify them actually returns a new, modified object, leaving the original object unchanged.
Mutable objects, on the other hand, can be modified in place. Therefore, changes made through one reference will be visible through all other references to the same object.

5. Memory Pools and Block Allocation:

Python uses a system of memory pools for integer and small-sized object allocation. This system helps reduce the overhead of memory allocation by reusing blocks of memory.
Large objects get their own dedicated memory chunks outside the pool.

6. Dynamic Typing:

Variables in Python do not have a fixed type. Instead, they can reference objects of any type, and their type can change during the program’s execution. This dynamic typing nature can lead to more memory overhead because the objects have to store type information.

Understanding Python's Data Model

Python’s data model is the foundation upon which the entire language operates. It provides a consistent and unified framework for interacting with objects and data structures in the language.

By understanding the data model, one gains insights into the fundamental building blocks of the language and how they interact with one another. Let’s delve into the core aspects of Python’s data model:

At the heart of Python’s data model is the notion that “everything is an object.” Whether it’s a basic type like an integer or a complex data structure like a list, everything in Python is an instance of some class or type.

Identity, Type, and Value:

Every object in Python possesses these three essential attributes:

Identity : A unique identifier, typically the object’s memory address, which remains constant throughout the object’s lifetime. You can obtain an object’s identity using the id() function.
Type : Represents the object’s data type (e.g., int, string, list). It determines the operations that the object supports. Once an object is created, its type cannot change. The type() function returns an object’s type.
Value : The content or data the object holds. Depending on whether the object is mutable (like a list) or immutable (like an integer or string), this value might or might not be changeable.

Attributes and Methods:

Objects can possess attributes (data) and methods (functions) associated with them, depending on their type/class definition.
Use the dot ( . ) operator to access an object’s attributes and methods.

Special Methods (Magic Methods or Dunder Methods):

These are methods with double underscores before and after their names, such as __init__ , __str__ , and __len__ .
They provide a way to define how objects of a class behave with built-in operations like print() or arithmetic operations. For example, the __len__ method allows us to use the len() function on objects of a class.
Protocols are essentially the “contracts” that classes can choose to adhere to. By implementing certain dunder methods, a class says it supports a particular protocol.
For example, an object is considered iterable if its class implements the __iter__ method, adhering to the iterable protocol.

Immutable vs Mutable Data Types

In Python, data types are categorized into two main categories based on whether the value they hold can be changed or not after they are created:

Immutable : These data types cannot be altered once they’ve been assigned a value. If you try to change their value, a new object is created instead. Common immutable types include:

Frozen sets

Mutable : These data types can be altered or modified after they’ve been assigned a value. Common mutable types include:

Dictionaries

Immutable Data Types:

In the above code, when we modify the string s , a new string object is created. The identity of s changes, confirming its immutability.

Mutable Data Types:

Here, even after modifying the list, the identity remains the same, indicating that the list is mutable and the changes were made in place.

Dictionary:

Similarly, the dictionary is mutable, as demonstrated by its consistent identity despite modifications.

Memory addresses and the id() function

In computer memory, every piece of data, be it a single integer or a complex data structure, is stored at a specific location. This location is often represented as a unique number called the memory address . Think of computer memory as a vast array of storage boxes, where each box has a unique number, and the contents of the box are the data values.

Python abstracts away many of the intricate details of memory management to make programming more straightforward. However, it does provide a way to peek behind the curtain and see the memory address of objects, and this is where the id() function comes into play.

The id() Function:

The built-in id() function in Python is used to obtain the “identity” of an object, which is unique and constant for the object during its lifetime. This “identity” is, in fact, the memory address where the object is stored.

In the above example, the id() function returns the memory address of the integer object 10 that the variable x is pointing to.

Examples and Observations:

Immutable objects:.

For immutable objects like integers or strings, if two variables have the same value, they might point to the same memory address (for reasons of optimization). However, this is not guaranteed, especially for larger or more complex immutable objects.

Mutable Objects:

Mutable objects like lists or dictionaries always have distinct memory addresses when created separately, even if their contents are the same.

Variables and Memory Addresses:

When you assign one variable’s value to another, both variables point to the same memory address, especially in the case of mutable objects.

The Myth of Pass-by-Value or Pass-by-Reference in Python

One of the common points of confusion among new Python programmers is how arguments are passed to functions — is it by value or by reference? Let’s break this down.

Definitions:

Pass-by-Value :

The called function receives a copy of the actual data, meaning changes made inside the function don’t affect the original data outside the function.

Pass-by-Reference :

The called function receives a reference to the actual data, meaning changes made inside the function directly affect the original data outside the function.

Python's Approach: Pass-by-Object-Reference:

Python’s argument-passing strategy isn’t strictly pass-by-value or pass-by-reference. Instead, it’s often described as pass-by-object-reference . This means when you pass a variable to a function:

You’re actually passing the reference (memory address) of the object the variable refers to, not the actual object itself.
Whether the original data outside the function is affected by changes inside the function depends on the mutability of the object being referenced.

Immutable Objects (like integers, strings) :

For immutable objects, even though they are passed by object reference, changes inside a function won’t affect the original data. This behavior is similar to pass-by-value.

Here, the integer inside the function is a new object, and num outside remains unchanged.

Mutable Objects (like lists, dictionaries) :

For mutable objects, changes inside a function directly affect the original data, akin to pass-by-reference behavior.

Here, the list inside and outside the function refers to the same object, and changes in the function reflect outside.

Mutable Objects

In programming, when we say an object is mutable, we mean that its state or value can be changed after it has been created. This contrasts with immutable objects, whose state cannot be changed after creation. In Python, common mutable data types include lists, dictionaries, and sets.

Definition : A list in Python is an ordered collection of items that can be of any type. Lists are defined by enclosing the items (elements) in square brackets [] .

You can modify a list by adding, removing, or changing items. For instance:

2. Dictionaries

Definition : A dictionary in Python is an unordered collection of data values used to store data values like a map. It’s defined by enclosing items (key-value pairs) in curly braces {} .

You can modify a dictionary by adding, removing, or changing items. For instance:

Definition : A set in Python is an unordered collection of unique items. Sets are defined by enclosing the items (elements) in curly braces {} or by using the set() constructor.

You can modify a set by adding or removing items. For instance:

Modifying Mutable Objects Within Functions

When you pass a mutable object to a function, the function works with a reference to the original object. As a result, any changes made to the object within the function are reflected in the original object outside the function.

Example: Modifying a list within a function :

Effect on the original list : In the above example, when we passed the fruits list to the add_fruit function and appended an “orange”, the original fruits list outside the function was modified. This illustrates the nature of mutable objects and how functions work with references to objects rather than copies.

Immutable Objects

Immutable objects, once created, cannot be changed, modified, or altered. Their state or value remains constant after their creation. This can be contrasted with mutable objects, which can be modified after creation.

Integers in Python represent whole numbers, both positive and negative.

Although you can reassign the value of num to another integer, the integer object 5 itself is immutable.

A string in Python is a sequence of characters. Strings are defined by enclosing characters in quotes.

Even if it seems you’re modifying a string using some operations, you’re in reality creating a new string.

A tuple in Python is similar to a list but is immutable. Tuples are defined by enclosing the items (elements) in parentheses () .

You cannot change the elements of a tuple once it’s defined.

Trying to Modify Immutable Objects Within Functions

When you pass an immutable object to a function, the function works with its value, but any attempt to modify that object creates a new object.

Example: Trying to modify a string within a function :

Why the Original String Remains Unchanged:

In the example above, when we pass the greeting string to the modify_string function, any modification inside the function doesn’t affect the original string. Instead, the variable inside the function gets associated with a new string object, leaving the original string untouched. This behavior exemplifies the immutable nature of strings.

Pitfalls and Common Mistakes

Confusion between reassignment and modification : For immutable types, reassignment (e.g., num = num + 1 ) creates a new object. It doesn’t modify the existing object. This is different from the behavior of mutable objects, where methods like append or extend change the object’s state.

Expecting immutables to act like mutables : A common mistake is expecting that operations on immutable types, especially within functions, will change the original data. As seen in the string example above, this isn’t the case.

Tuple with mutable items : While tuples themselves are immutable, they can contain mutable objects, like lists. This can lead to confusion because the tuple’s content can change if those mutable objects are modified.

Here, the list inside the tuple was modified, even though the tuple itself is immutable.

Modifying Mutable Objects vs Reassigning Reference

In Python, there’s a distinction between modifying the content of a mutable object and reassigning a variable’s reference.

Changing an entire list:

Changing an element inside the list:.

In the first example, you’re reassigning the variable’s reference to a new list. In the second, you’re modifying the content of the original list.

Unintended Side Effects When Modifying Mutable Objects in Functions : When you pass mutable objects (like lists) to a function and modify them inside, you affect the original object.

How to Mimic Pass by Value in Python

To prevent unintended modifications, you can create copies.

Copying Objects Using the Copy Module :

Shallow Copy : Copies the top-level object, but not the nested ones.

Deep Copy : Copies all nested objects.

When to Use Shallow vs Deep Copies :

Use a shallow copy when you want to clone the main object, but are okay with sharing nested objects.
Use a deep copy when you want a fully independent clone.

Best Practices

Use Clear Function Documentation : Ensure the behavior of functions is documented, especially if they modify input arguments.

Return Modified Objects to Make Changes Explicit : Instead of modifying input directly, return the modified data.

Avoid Modifying Input Arguments Unless Necessary : Minimize side effects by not changing inputs unless it’s integral to the function’s purpose.

Real-World Examples

Using Functions to Modify List Contents :
Using Functions to Modify Dictionary Key-Values :

Pitfalls in Real-world Scenarios and How to Avoid Them :

Watch out for modifying mutable defaults in function arguments.
Ensure that shared mutable objects are treated with caution.

Comparing Python’s Mechanism with Other Languages

Python vs C++ : Unlike Python, C++ has explicit pointers and can directly use pass-by-value and pass-by-reference.

Python vs Java : Java uses pass-by-value, but when it comes to objects, it passes the value of the reference.

Summary and Key Takeaways

Python doesn’t strictly use pass-by-value or pass-by-reference but rather pass-by-object-reference.
The effects of modifying data in functions are influenced by mutability.

Live Python Tutorials

Python is neither strictly pass-by-value nor strictly pass-by-reference. Instead, Python’s parameter passing is best described as “pass-by-object-reference”.

Integers and strings are immutable in Python. This means their values can’t be changed once they are created. Any modification creates a new object instead.

Lists are mutable objects. When you pass a list to a function, you’re actually passing a reference to that list. So, any changes made to the list inside the function reflect outside the function as well.

You can pass a copy (either shallow or deep) of the object to the function. This way, the original object remains unaffected by changes inside the function.

A shallow copy creates a new object, but doesn’t create copies of nested objects that reside within the original object. A deep copy, on the other hand, creates a new object and recursively adds copies of nested objects found in the original.

Yes, creating a deep copy can be slower, especially if the original object is large or has many nested objects. Use deep copies judiciously.

In C++, you can explicitly use pass-by-value or pass-by-reference. Java uses pass-by-value, but when passing objects, it’s the value of the reference that gets passed. Python’s mechanism is unique in that it’s always pass-by-object-reference.

Ensure that you’re not modifying mutable default values in function arguments and that shared mutable objects are treated with caution. Also, consult the tutorial’s section on common pitfalls and mistakes.

Refer to the “Further Reading and Resources” section of the tutorial. Books like “Fluent Python” provide in-depth discussions on Python’s data model and behaviors.

While the foundational ideas around mutability, references, and memory management are relevant in many programming contexts, the specific behaviors and best practices are tailored to Python.

About The Author

How To Compare String In Python? (String Comparison 101)

10 Ways to Square a Number in Python – Codingparks.com

Pass-by-value, reference, and assignment | Pydon't 🐍

When you call a function in Python and give it some arguments... Are they passed by value? No! By reference? No! They're passed by assignment.

Python snippet containing the code `x is y`.

(If you are new here and have no idea what a Pydon't is, you may want to read the Pydon't Manifesto .)

Introduction

Many traditional programming languages employ either one of two models when passing arguments to functions:

some languages use the pass-by-value model; and
most of the others use the pass-by-reference model.

Having said that, it is important to know the model that Python uses, because that influences the way your code behaves.

In this Pydon't, you will:

see that Python doesn't use the pass-by-value nor the pass-by-reference models;
understand that Python uses a pass-by-assignment model;
learn about the built-in function id ;
create a better understanding for the Python object model;
realise that every object has 3 very important properties that define it;
understand the difference between mutable and immutable objects;
learn the difference between shallow and deep copies; and
learn how to use the module copy to do both types of object copies.

You can now get your free copy of the ebook “Pydon'ts – Write elegant Python code” on Gumroad .

Is Python pass-by-value?

In the pass-by-value model, when you call a function with a set of arguments, the data is copied into the function. This means that you can modify the arguments however you please and that you won't be able to alter the state of the program outside the function. This is not what Python does, Python does not use the pass-by-value model.

Looking at the snippet of code that follows, it might look like Python uses pass-by-value:

This looks like the pass-by-value model because we gave it a 3, changed it to a 4, and the change wasn't reflected on the outside ( a is still 3).

But, in fact, Python is not copying the data into the function.

To prove this, I'll show you a different function:

As we can see, the list l , that was defined outside of the function, changed after calling the function clearly_not_pass_by_value . Hence, Python does not use a pass-by-value model.

Is Python pass-by-reference?

In a true pass-by-reference model, the called function gets access to the variables of the callee! Sometimes, it can look like that's what Python does, but Python does not use the pass-by-reference model.

I'll do my best to explain why that's not what Python does:

If Python used a pass-by-reference model, the function would've managed to completely change the value of l outside the function, but that's not what happened, as we can see.

Let me show you an actual pass-by-reference situation.

Here's some Pascal code:

Look at the last lines of that code:

we assign 2 to x with x := 2 ;
we print x ;
we call foo with x as argument; and
we print x again.

What's the output of this program?

I imagine that most of you won't have a Pascal interpreter lying around, so you can just go to tio.run and run this code online

If you run this, you'll see that the output is

which can be rather surprising, if the majority of your programming experience is in Python!

The procedure foo effectively received the variable x and changed the value that it contained. After foo was done, the variable x (that lives outside foo ) had a different value. You can't do anything like this in Python.

Python object model

To really understand the way Python behaves when calling functions, it's best if we first understand what Python objects are, and how to characterise them.

The three characteristics of objects

In Python, everything is an object, and each object is characterised by three things:

its identity (an integer that uniquely identifies the object, much like social security numbers identify people);
a type (that identifies the operations you can do with your object); and
the object's content.

Here is an object and its three characteristics:

As we can see above, id is the built-in function you use to query the identity of an object, and type is the built-in function you use to query the type of an object.

(Im)mutability

The (im)mutability of an object depends on its type. In other words, (im)mutability is a characteristic of types, not of specific objects!

But what exactly does it mean for an object to be mutable? Or for an object to be immutable?

Recall that an object is characterised by its identity, its type, and its contents. A type is mutable if you can change the contents of its objects without changing its identity and its type.

Lists are a great example of a mutable data type. Why? Because lists are containers : you can put things inside lists and you can remove stuff from inside those same lists.

Below, you can see how the contents of the list obj change as we make method calls, but the identity of the list remains the same:

However, when dealing with immutable objects, it's a completely different story. If we check an English dictionary, this is what we get for the definition of “immutable”:

adjective: immutable – unchanging over time or unable to be changed.

Immutable objects' contents never change. Take a string as an example:

Strings are a good example for this discussion because, sometimes, they can look mutable. But they are not!

A very good indicator that an object is immutable is when all its methods return something. This is unlike list's .append method, for example! If you use .append on a list, you get no return value. On the other hand, whatever method you use on a string, the result is returned to you:

Notice how obj wasn't updated automatically to "HELLO, WORLD!" . Instead, the new string was created and returned to you.

Another great hint at the fact that strings are immutable is that you cannot assign to its indices:

This shows that, when a string is created, it remains the same. It can be used to build other strings, but the string itself always. stays. unchanged.

As a reference, int , float , bool , str , tuple , and complex are the most common types of immutable objects; list , set , and dict are the most common types of mutable objects.

Variable names as labels

Another important thing to understand is that a variable name has very little to do with the object itself.

In fact, the name obj was just a label that I decided to attach to the object that has identity 2698212637504, has the list type, and contents 1, 2, 3.

Just like I attached the label obj to that object, I can attach many more names to it:

Again, these names are just labels. Labels that I decided to stick to the same object. How can we know it's the same object? Well, all their “social security numbers” (the ids) match, so they must be the same object:

Therefore, we conclude that foo , bar , baz , and obj , are variable names that all refer to the same object.

The operator is

This is exactly what the operator is does: it checks if the two objects are the same .

For two objects to be the same, they must have the same identity:

It is not enough to have the same type and contents! We can create a new list with contents [1, 2, 3] and that will not be the same object as obj :

Think of it in terms of perfect twins. When two siblings are perfect twins, they look identical. However, they are different people!

Just as a side note, but an important one, you should be aware of the operator is not .

Generally speaking, when you want to negate a condition, you put a not in front of it:

So, if you wanted to check if two variables point to different objects, you could be tempted to write

However, Python has the operator is not , which is much more similar to a proper English sentence, which I think is really cool!

Therefore, the example above should actually be written

Python does a similar thing for the in operator, providing a not in operator as well... How cool is that?!

Assignment as nicknaming

If we keep pushing this metaphor forward, assigning variables is just like giving a new nickname to someone.

My friends from middle school call me “Rojer”. My friends from college call me “Girão”. People I am not close to call me by my first name – “Rodrigo”. However, regardless of what they call me, I am still me , right?

If one day I decide to change my haircut, everyone will see the new haircut, regardless of what they call me!

In a similar fashion, if I modify the contents of an object, I can use whatever nickname I prefer to see that those changes happened. For example, we can change the middle element of the list we have been playing around with:

We used the nickname foo to modify the middle element, but that change is visible from all other nicknames as well.

Because they all pointed at the same list object.

Python is pass-by-assignment

Having laid out all of this, we are now ready to understand how Python passes arguments to functions.

When we call a function, each of the parameters of the function is assigned to the object they were passed in. In essence, each parameter now becomes a new nickname to the objects that were given in.

Immutable arguments

If we pass in immutable arguments, then we have no way of modifying the arguments themselves. After all, that's what immutable means: “doesn't change”.

That is why it can look like Python uses the pass-by-value model. Because the only way in which we can have the parameter hold something else is by assigning it to a completely different thing. When we do that, we are reusing the same nickname for a different object:

In the example above, when we call foo with the argument 5 , it's as if we were doing bar = 5 at the beginning of the function.

Immediately after that, we have bar = 3 . This means “take the nickname "bar" and point it at the integer 3 ”. Python doesn't care that bar , as a nickname (as a variable name) had already been used. It is now pointing at that 3 !

Mutable arguments

On the other hand, mutable arguments can be changed. We can modify their internal contents. A prime example of a mutable object is a list: its elements can change (and so can its length).

That is why it can look like Python uses a pass-by-reference model. However, when we change the contents of an object, we didn't change the identity of the object itself. Similarly, when you change your haircut or your clothes, your social security number does not change:

Do you understand what I'm trying to say? If not, drop a comment below and I'll try to help.

Beware when calling functions

This goes to show you should be careful when defining your functions. If your function expects mutable arguments, you should do one of the two:

do not mutate the argument in any way whatsoever; or
document explicitly that the argument may be mutated.

Personally, I prefer to go with the first approach: to not mutate the argument; but there are times and places for the second approach.

Sometimes, you do need to take the argument as the basis for some kind of transformation, which would mean you would want to mutate the argument. In those cases, you might think about doing a copy of the argument (discussed in the next section), but making that copy can be resource intensive. In those cases, mutating the argument might be the only sensible choice.

Making copies

Shallow vs deep copies.

“Copying an object” means creating a second object that has a different identity (therefore, is a different object) but that has the same contents. Generally speaking, we copy one object so that we can work with it and mutate it, while also preserving the first object.

When copying objects, there are a couple of nuances that should be discussed.

Copying immutable objects

The first thing that needs to be said is that, for immutable objects, it does not make sense to talk about copies.

“Copies” only make sense for mutable objects. If your object is immutable, and if you want to preserve a reference to it, you can just do a second assignment and work on it:

Or, sometimes, you can just call methods and other functions directly on the original, because the original is not going anywhere:

So, we only need to worry about mutable objects.

Shallow copy

Many mutable objects can contain, themselves, mutable objects. Because of that, two types of copies exist:

shallow copies; and
deep copies.

The difference lies in what happens to the mutable objects inside the mutable objects.

Lists and dictionaries have a method .copy that returns a shallow copy of the corresponding object.

Let's look at an example with a list:

First, we create a list inside a list, and we copy the outer list. Now, because it is a copy , the copied list isn't the same object as the original outer list:

But if they are not the same object, then we can modify the contents of one of the lists, and the other won't reflect the change:

That's what we saw: we changed the first element of the copy_list , and the outer_list remained unchanged.

Now, we try to modify the contents of sublist , and that's when the fun begins!

When we modify the contents of sublist , both the outer_list and the copy_list reflect those changes...

But wasn't the copy supposed to give me a second list that I could change without affecting the first one? Yes! And that is what happened!

In fact, modifying the contents of sublist doesn't really modify the contents of neither copy_list nor outer_list : after all, the third element of both was pointing at a list object, and it still is! It's the (inner) contents of the object to which we are pointing that changed.

Sometimes, we don't want this to happen: sometimes, we don't want mutable objects to share inner mutable objects.

Common shallow copy techniques

When working with lists, it is common to use slicing to produce a shallow copy of a list:

Using the built-in function for the respective type, on the object itself, also builds shallow copies. This works for lists and dictionaries, and is likely to work for other mutable types.

Here is an example with a list inside a list:

And here is an example with a list inside a dictionary:

When you want to copy an object “thoroughly”, and you don't want the copy to share references to inner objects, you need to do a “deep copy” of your object. You can think of a deep copy as a recursive algorithm.

You copy the elements of the first level and, whenever you find a mutable element on the first level, you recurse down and copy the contents of those elements.

To show this idea, here is a simple recursive implementation of a deep copy for lists that contain other lists:

We can use this function to copy the previous outer_list and see what happens:

As you can see here, modifying the contents of sublist only affected outer_list indirectly; it didn't affect copy_list .

Sadly, the list_deepcopy method I implemented isn't very robust, nor versatile, but the Python Standard Library has got us covered!

The module copy and the method deepcopy

The module copy is exactly what we need. The module provides two useful functions:

copy.copy for shallow copies; and
copy.deepcopy for deep copies.

And that's it! And, what is more, the method copy.deepcopy is smart enough to handle issues that might arise with circular definitions, for example! That is, when an object contains another that contains the first one: a naïve recursive implementation of a deep copy algorithm would enter an infinite loop!

If you write your own custom objects and you want to specify how shallow and deep copies of those should be made, you only need to implement __copy__ and __deepcopy__ , respectively!

It's a great module, in my opinion.

Examples in code

Now that we have gone deep into the theory – pun intended –, it is time to show you some actual code that plays with these concepts.

Mutable default arguments

Let's start with a Twitter favourite:

Python 🐍 is an incredible language but sometimes appears to have quirks 🤪 For example, one thing that often confuses beginners is why you shouldn't use lists as default values 👇 Here is a thread 👇🧵 that will help you understand this 💯 pic.twitter.com/HVhPjS2PSH — Rodrigo 🐍📝 (@mathsppblog) October 5, 2021

Apparently, it's a bad idea to use mutable objects as default arguments. Here is a snippet showing you why:

The function above appends an element to a list and, if no list is given, appends it to an empty list by default.

Great, let's put this function to good use:

We use it once with 1 , and we get a list with the 1 inside. Then, we use it to append a 1 to another list we had. And finally, we use it to append a 3 to an empty list... Except that's not what happens!

As it turns out, when we define a function, the default arguments are created and stored in a special place:

What this means is that the default argument is always the same object. Therefore, because it is a mutable object, its contents can change over time. That is why, in the code above, __defaults__ shows a list with two items already.

If we redefine the function, then its __defaults__ shows an empty list:

This is why, in general, mutable objects shouldn't be used as default arguments.

The standard practice, in these cases, is to use None and then use Boolean short-circuiting to assign the default value:

With this implementation, the function now works as expected:

is not None

Searching through the Python Standard Library shows that the is not operator is used a bit over 5,000 times. That's a lot.

And, by far and large, that operator is almost always followed by None . In fact, is not None appears 3169 times in the standard library!

x is not None does exactly what it's written: it checks if x is None or not.

Here is a simple example usage of that, from the argparse module to create command line interfaces:

Even without a great deal of context, we can see what is happening: when displaying command help for a given section, we may want to indent it (or not) to show hierarchical dependencies.

If a section's parent is None , then that section has no parent, and there is no need to indent. In other words, if a section's parent is not None , then we want to indent it. Notice how my English matches the code exactly!

Deep copy of the system environment

The method copy.deepcopy is used a couple of times in the standard library, and here I'd like to show an example usage where a dictionary is copied.

The module os provides the attribute environ , similar to a dictionary, that contains the environment variables that are defined.

Here are a couple of examples from my (Windows) machine:

The module http.server provides some classes for basic HTTP servers.

One of those classes, CGIHTTPRequestHandler , implements a HTTP server that can also run CGI scripts and, in its run_cgi method, it needs to set a bunch of environment variables.

These environment variables are set to give the necessary context for the CGI script that is going to be ran. However, we don't want to actually modify the current environment!

So, what we do is create a deep copy of the environment, and then we modify it to our heart's content! After we are done, we tell Python to execute the CGI script, and we provide the altered environment as an argument.

The exact way in which this is done may not be trivial to understand. I, for one, don't think I could explain it to you. But that doesn't mean we can't infer parts of it:

Here is the code:

As we can see, we copied the environment and defined some variables. Finally, we created a new subprocess that gets the modified environment.

Here's the main takeaway of this Pydon't, for you, on a silver platter:

“ Python uses a pass-by-assignment model, and understanding it requires you to realise all objects are characterised by an identity number, their type, and their contents. ”

This Pydon't showed you that:

Python doesn't use the pass-by-value model, nor the pass-by-reference one;
Python uses a pass-by-assignment model (using “nicknames”);
its identity;
its type; and
its contents.
the id function is used to query an object's identifier;
the type function is used to query an object's type;
the type of an object determines whether it is mutable or immutable;
shallow copies copy the reference of nested mutable objects;
deep copies perform copies that allow one object, and its inner elements, to be changed without ever affecting the copy;
copy.copy and copy.deepcopy can be used to perform shallow/deep copies; and
you can implement __copy__ and __deepcopy__ if you want your own objects to be copiable.

If you prefer video content, you can check this YouTube video , which was inspired by this article.

If you liked this Pydon't be sure to leave a reaction below and share this with your friends and fellow Pythonistas. Also, subscribe to the newsletter so you don't miss a single Pydon't!

Become a better Python 🐍 developer 🚀

+35 chapters. +400 pages. Hundreds of examples. Over 30,000 readers!

My book “Pydon'ts” teaches you how to write elegant, expressive, and Pythonic code, to help you become a better developer. Get it below!

Python 3 Docs, Programming FAQ, “How do I write a function with output parameters (call by reference)?”, https://docs.python.org/3/faq/programming.html#how-do-i-write-a-function-with-output-parameters-call-by-reference [last accessed 04-10-2021];
Python 3 Docs, The Python Standard Library, copy , https://docs.python.org/3/library/copy.html [last accessed 05-10-2021];
effbot.org, “Call by Object” (via “arquivo.pt”), https://arquivo.pt/wayback/20160516131553/http://effbot.org/zone/call-by-object.htm [last accessed 04-10-2021];
effbot.org, “Python Objects” (via “arquivo.pt”), https://arquivo.pt/wayback/20191115002033/http://effbot.org/zone/python-objects.htm [last accessed 04-10-2021];
Robert Heaton, “Is Python pass-by-reference or pass-by-value”, https://robertheaton.com/2014/02/09/pythons-pass-by-object-reference-as-explained-by-philip-k-dick/ [last accessed 04-10-2021];
StackOverflow question and answers, “How do I pass a variable by reference?”, https://stackoverflow.com/q/986006/2828287 [last accessed 04-10-2021];
StackOverflow question and answers, “Passing values in Python [duplicate]”, https://stackoverflow.com/q/534375/2828287 [last accessed 04-10-2021];
Twitter thread by @mathsppblog , https://twitter.com/mathsppblog/status/1445148566721335298 [last accessed 20-10-2021];

Previous Post Next Post

Random Article

Stay in the loop, popular tags.

5 March 2024
2 February 2024
8 January 2024
1 December 2023
22 November 2023
4 October 2023
6 September 2023
7 August 2023
12 July 2023
4 June 2023
5 April 2023

The number 1 is not a prime number.

Python Course #12: Pass by Assignment, Copy, Reference, and None

Now that the you know what mutable (e.g. lists , sets and dictionaries ) and immutable data types (e.g. tuples ) are it is important to talk about copies, references and None .

Python Pass by Assignment

When you call a pass data to a function such as print(...) there are two ways. The first option is to pass the data directly as a value:

The second option is to pass the data as a variable:

The difference between those two options is that the second option allows you to access the data you passed to the function later in your program by stating the variable. When the function that receives the data modifies it internally, you have to be aware of two critical things:

When a primitive data type ( bool , int , float , and str ) or immutable data type (e.g. tuple ) is passed to a function, its value is copied. Therefore, all changes made inside a function won’t affect the values stored in the variables passed to the function. This is called pass by value .

When a mutable data type (e.g. list , set , dict ) is passed to a function, the data isn’t copied. Because of this, changes that are made inside the function affect the values outside of the function. This is called pass by reference

This sounds pretty theoretical, so here comes an example:

Even though you haven’t learned about declaring functions in Python this example declares the function func(x, y) that takes two parameters. func(x, y) subtracts 1 from the first parameter, and calls pop() on the second one. That is everything you need to understand at the moment.

In the main program, the int i and the list l are declared and then passed to func(x, y) . When looking at i and l after func(x, y) has been executed, you can see that i is still 1 and not 0 because i ’s value was copied. However, l is missing its last element since it was passed as a reference.

This mix of pass by value and pass by reference in Python is called pass by assignment . It is essential to keep this concept always in mind when writing Python code.

In the previous parts of this Python course, you have seen that it is possible to get a copy of a mutable data type by calling the .copy() function:

By using .copy() , the data outside of the function isn’t changed.

In the following example the difference between a copy and reference is further amplified:

In the first line the list ['a', 'b', 'c'] is declared and than a new reference to this list is created with l = . In the second line another reference to the list ['a', 'b', 'c'] is created with: m = l . In the third line the list is copied and a reference to that copy is created with: n = l.copy() .

There are three references to two lists with the same content. l and m reference the first list and n reference the second list . Because l and m reference the same list every modification done using l or m will always be reflected in both. n won’t change as it references a different list .

Python is vs ==

To check if two variables reference the same value you can use the is operator to compare the values use the == operator:

l is n evaluates to False because they reference differnt list s, however, those two list s contain the same values and therefore l == n evaluates to True . You can also check the id that a variable is referencing using id(...) :

You can see that the id of l and m is the same and the id of n is different (The numbers are different everytime you run this code). The is operator is actually implemented using == with id(...) == id(...) .

Python None

Now that you know the difference between a copy and a reference, there is one last thing to talk about: ` None . The keyword None in Python indicates no value at all. And there is only one None`:

None can be used to initialize a variable without assigning a value. This can be useful when the value of a variable is assigned under a condition:

None actually has it’s own type and is an immutable data type because it can’t be changed:

None concludes this article. Throughout this Python course, you will come across pass by assignment, copies, references, and None reasonably often. Make sure to get the free Python Cheat Sheets in my Gumroad shop . If you have any questions about this article, feel free to join our Discord community to ask them over there.

Python Course #2: Variables and Primitive Datatypes for Absolute Beginners

After you have written your first Python Hello World program (find the article over here: Python Lesson 1: Your First Python Program (Complete Beginners Guide) ) it is time to talk about variables ...

Python Course #3: Introduction to Boolean Algebra

The term Boolean algebra itself might sound dry and dull, but it is one of the backbones of all the computers we use today. In this article, you will learn what Boolean algebra is and how to use it...

Estimate Gas in Ethereum Transactions with Python web3 and brownie

Change Windows 10/11 Display Resolution with a Python System Tray Application

Trending Tags

PYTHON PROGRAMMER

Everything i know about python..., learn to write pythonic code.

Check out the book Writing Idiomatic Python !

Looking for Python Tutoring? Remote and local (NYC) slots still available! Email me at [email protected] for more info.

On line 1, we create a binding between a name , some_guy , and a string object containing 'Fred'. In the context of program execution, the environment is altered; a binding of the name some_guy ' to a string object is created in the scope of the block where the statement occurred. When we later say some_guy = 'George' , the string object containing 'Fred' is unaffected. We've just changed the binding of the name some_guy . We haven't, however, changed either the 'Fred' or 'George' string objects . As far as we're concerned, they may live on indefinitely.

With only a single name binding, this may seem overly pedantic, but it becomes more important when bindings are shared and function calls are involved. Let's say we have the following bit of Python code:

So what get's printed in the final line? Well, to start, the binding of some_guy to the string object containing 'Fred' is added to the block's namespace . The name first_names is bound to an empty list object. On line 4, a method is called on the list object first_names is bound to, appending the object some_guy is bound to. At this point, there are still only two objects that exist: the string object and the list object. some_guy and first_names[0] both refer to the same object (Indeed, print(some_guy is first_names[0]) shows this).

Let's continue to break things down. On line 6, a new name is bound: another_list_of_names . Assignment between names does not create a new object. Rather, both names are simply bound to the same object. As a result, the string object and list object are still the only objects that have been created by the interpreter. On line 7, a member function is called on the object another_list_of_names is bound to and it is mutated to contain a reference to a new object: 'George'. So to answer our original question, the output of the code is

This brings us to an important point: there are actually two kinds of objects in Python. A mutable object exhibits time-varying behavior. Changes to a mutable object are visible through all names bound to it. Python's lists are an example of mutable objects. An immutable object does not exhibit time-varying behavior. The value of immutable objects can not be modified after they are created. They can be used to compute the values of new objects, which is how a function like string.join works. When you think about it, this dichotomy is necessary because, again, everything is an object in Python. If integers were not immutable I could change the meaning of the number '2' throughout my program.

It would be incorrect to say that "mutable objects can change and immutable ones can't", however. Consider the following:

Tuples in Python are immutable. We can't change the tuple object name_tuple is bound to. But immutable containers may contain references to mutable objects like lists. Therefore, even though name_tuple is immutable, it "changes" when 'Igor' is appended to first_names on the last line. It's a subtlety that can sometimes (though very infrequently) prove useful.

By now, you should almost be able to intuit how function calls work in Python. If I call foo(bar) , I'm merely creating a binding within the scope of foo to the object the argument bar is bound to when the function is called. If bar refers to a mutable object and foo changes its value, then these changes will be visible outside of the scope of the function.

On the other hand, if bar refers to an immutable object, the most that foo can do is create a name bar in its local namespace and bind it to some other object.

Hopefully by now it is clear why Python is neither "call-by-reference" nor "call-by-value". In Python a variable is not an alias for a location in memory. Rather, it is simply a binding to a Python object. While the notion of "everything is an object" is undoubtedly a cause of confusion for those new to the language, it allows for powerful and flexible language constructs, which I'll discuss in my next post.

« Starting a Django 1.4 Project the Right Way

Like this article?

Why not sign up for Python Tutoring ? Sessions can be held remotely using Google+/Skype or in-person if you're in the NYC area. Email [email protected] if interested.

Sign up for the free jeffknupp.com email newsletter. Sent roughly once a month, it focuses on Python programming, scalable web development, and growing your freelance consultancy. And of course, you'll never be spammed, your privacy is protected, and you can opt out at any time.

Learning OOP: Encapsulation, inheritance, aggregation vs composition, and more!

I’m taking a Udemy course by an instructor named Estafania Navone who is teaching Python OOP . While it is not for a college/school credit, I am treating this as a real homework assignment so for those who are willing to read my thread and provide feedback, I ask that you do not provide the solution or even a partial solution. Please just provide hints and tips.

I am about one third through the course. The first major project is a “Dice Game” intended to teach OOP principles covered so far such as:

Shared attributes
Encapsulation and inheritance
getters, setters, @property ’s
“Aggregation” vs “Composition” ( extra curricular cross - reference for an excellent guide I encountered )

For this project the instructor essentially provides the specs and pseudo code. Here it is . The task is for her students to model the game in OOP.

My best attempt you can find at the bottom of this post. When I run the script in my shell, nothing happens. It doesn’t even get stuck in a perpetual loop (I use two while loops). To remedy this I declared a game_obj at the very bottom like:

I am way off. I am stabbing in the dark here. Although I can already identify a number of problem areas like:

At lines 33 and 34 for the init method of the third class definition, I really struggled to distinguish the human player as True and the computer player as False . I realize I need a switch somehow to toggle between the two bools but the required Python syntax to achieve this desired result escapes me. I figure the answer to this frustrating pain point is trivial and obvious.
At line 53 (and even lines 55-63), I am pretty sure that the way I am referring to the two counters for the different player types (e.g. self.human.counter ) is wrong. Any guidance and suggestions on what I could try instead here would be great.
For the two setters in the second class ( Player ) for the winning and losing mechanic I am not sure if I should be using a return statement or if I could just increment / decrement the self.counter attribute and leave it at that.
I’ve added the suffix self liberally to every attribute whenever my text editor’s linter complained but I am thinking there may be certain variables with self added where there shouldn’t be.

Tips / guidance / suggestions welcome.

Script so far:

A few points:

You use the inheritance in the wrong way. DiceGame is NOT a Die and definitely is NOT a Player . Your DiceGame should contain a die and two players.

In this way you return the function object . If rather you want to call that method then you must add () at the end of roll

Same story here.

This may be a surprise, but your program does not contain any player! The class player is sort of a template to create different players. If you want to create a player, you need to instantiate a player from the class.

I created a smaller Player class to show the mechanics:

person and computer are the actual players. They can do anything defined in the Player class, like roll_dice and have properties defined in the Player class, like name.

So you do not need to :

Each player is an instance of Player.

There are more issues in your program, to me finding those out is one of the interesting tasks in programming, so I will not go into those. Just one:

If you write

that does not execute the method. You need to follow it by the parenthesis, just as in

What exactly do you want to happen, instead?

In your own words, exactly what do you believe is the overall purpose of the existing code - how much do you expect it to accomplish? (Hint: what do you believe the class keyword does; and what do you believe is the purpose of a class?)

Also, so that I can understand how we got to this point: what did your previous exercises and assignments look like? Have you had to write class at all before this project, for example?