constructor assignment in python

• Python Course
• Python Basics
• Interview Questions
• Python Quiz
• Popular Packages
• Python Projects
• Practice Python
• AI With Python
• Learn Python3
• Python Automation
• Python Web Dev
• DSA with Python
• Python OOPs
• Dictionaries

Constructors in Python

Prerequisites: Object-Oriented Programming in Python , Object-Oriented Programming in Python | Set 2   Constructors are generally used for instantiating an object. The task of constructors is to initialize(assign values) to the data members of the class when an object of the class is created. In Python the __init__() method is called the constructor and is always called when an object is created. Syntax of constructor declaration : 

Types of constructors :  

• default constructor: The default constructor is a simple constructor which doesn’t accept any arguments. Its definition has only one argument which is a reference to the instance being constructed.
• parameterized constructor: constructor with parameters is known as parameterized constructor. The parameterized constructor takes its first argument as a reference to the instance being constructed known as self and the rest of the arguments are provided by the programmer.

Example of default constructor :    

Example of the parameterized constructor :  

Explanation:

In this example, we define a class MyClass with both a default constructor and a parameterized constructor. The default constructor checks whether a parameter has been passed in or not, and prints a message to the console accordingly. The parameterized constructor takes in a single parameter name and sets the name attribute of the object to the value of that parameter.

We also define a method method() that checks whether the object has a name attribute or not, and prints a message to the console accordingly.

We create two objects of the class MyClass using both types of constructors. First, we create an object using the default constructor, which prints the message “Default constructor called” to the console. We then call the method() method on this object, which prints the message “Method called without a name” to the console.

Next, we create an object using the parameterized constructor, passing in the name “John”. The constructor is called automatically, and the message “Parameterized constructor called with name John” is printed to the console. We then call the method() method on this object, which prints the message “Method called with name John” to the console.

Overall, this example shows how both types of constructors can be implemented in a single class in Python.

Advantages of using constructors in Python:

• Initialization of objects : Constructors are used to initialize the objects of a class. They allow you to set default values for attributes or properties, and also allow you to initialize the object with custom data.
• Easy to implement: Constructors are easy to implement in Python, and can be defined using the __init__() method.
• Better readability: Constructors improve the readability of the code by making it clear what values are being initialized and how they are being initialized.
• Encapsulation : Constructors can be used to enforce encapsulation, by ensuring that the object’s attributes are initialized correctly and in a controlled manner.

Disadvantages of using constructors in Python:

• Overloading not supported: Unlike other object-oriented languages, Python does not support method overloading. This means that you cannot have multiple constructors with different parameters in a single class.
• Limited functionality: Constructors in Python are limited in their functionality compared to constructors in other programming languages. For example, Python does not have constructors with access modifiers like public, private or protected.
• Constructors may be unnecessary: In some cases, constructors may not be necessary, as the default values of attributes may be sufficient. In these cases, using a constructor may add unnecessary complexity to the code.

Overall, constructors in Python can be useful for initializing objects and enforcing encapsulation. However, they may not always be necessary and are limited in their functionality compared to constructors in other programming languages.

Constructors in Python – FAQs

Is __init__ a constructor in python.

Yes, __init__ is considered a constructor in Python. It is a special method that is automatically called when an instance (object) of a class is created. Its primary purpose is to initialize the attributes of the object.

What are the different types of construction in Python?

In Python, there is primarily one type of constructor: __init__ Constructor : This is the standard constructor used in Python classes. It initializes the attributes of an object when it is instantiated.

Can we have two __init__ in Python?

No, you cannot have two __init__ methods with the same name in a single class in Python. Python does not support method overloading based on the number or types of arguments, unlike some other programming languages.

Can we overload constructors in Python?

While Python does not support method overloading in the traditional sense (having multiple methods with the same name but different parameters), you can achieve a form of constructor overloading using default parameter values or by using class methods that act as alternative constructors. Here’s an example: class Person: def __init__(self, name=None, age=None): if name is not None and age is not None: self.name = name self.age = age else: self.name = "Unknown" self.age = 0 @classmethod def from_birth_year(cls, name, birth_year): return cls(name, 2024 - birth_year) # Using default constructor person1 = Person("Alice", 30) print(person1.name, person1.age) # Output: Alice 30 # Using alternative constructor person2 = Person.from_birth_year("Bob", 1990) print(person2.name, person2.age) # Output: Bob 34

How to call a constructor in Python?

The constructor ( __init__ method) in Python is automatically called when you create an instance (object) of a class using the class name followed by parentheses () . Here’s an example: class MyClass: def __init__(self, param): self.param = param # Creating an instance of MyClass obj = MyClass(10) # Calls __init__(self, param=10)

Please Login to comment...

Similar reads.

• PS5 Pro Launched: Controller, Price, Specs & Features, How to Pre-Order, and More
• How to Make Money on Twitch
• How to activate Twitch on smart TV
• 105 Funny Things to Do to Make Someone Laugh
• #geekstreak2024 – 21 Days POTD Challenge Powered By Deutsche Bank

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Learn Python Programming from Scratch

• Learn Python

Constructor in Python with Examples

by PythonGeeks Team

Master Programming with Our Comprehensive Courses Enroll Now!

In Object-Oriented Programming, a constructor is a special kind of method used to instantiate an object. The primary objective of Constructors is to assign values to the instance attributes of the class. 

Constructors provide state and uniqueness to the objects. Without constructors, all objects will have the same values and no object will be unique. 

In languages such as Java and C++, constructors are created by defining a method with the same name as the Class. In Python, constructors do not depend on the name of the class because they have their own name init and we can create a constructor by defining the __init__() method. 

Python automatically invokes the constructor whenever we create an object. Python calls the __new__() method followed by the __init__() method as soon as we create an object. __new__() creates the object while __init__() instantiates the created object.

Creating a Constructor in Python

To create a constructor in Python, we need to define a special kind of magic method called __init__() inside our class. 

By default, this method takes one argument known as self. Self takes the address of the object as its argument and it is automatically provided by Python. We can define as many parameters as we need.

Syntax for creating constructor in Python

Example of Python Constructor

In the above code example, we created a constructor by defining the __init__() method. By looking at the output, we can tell that the constructor is called as soon as we created the object.

Types of Constructor in Python

We have three types of constructors in Python: Non-Parameterized, Parameterized, and Default Constructors.

1. Non-Parameterized Constructor in python

Constructors with no parameters other than self are called Non-Parameterized Constructors. The values of attributes inside the non-parameterized constructors are defined when creating the class and can not be modified while instantiating.

Example of Non-Parameterized Constructor in Python

Cloth = Cotton

Type = T-Shirt

In the above code example, __init__() method doesn’t take any other arguments except self. 

2. Parameterized Constructor in Python

Constructors with at least two parameters including self are called Parameterized Constructors. The arguments for the parameters should be passed while creating the object. The values of attributes inside these constructors can be modified while instantiating with the help of parameters. Since the attributes can be modified, each object can have different values and be unique.

Example of Python Parameterized Constructor

In the above code example, __init__() method takes multiple parameters and because of this, the objects shirt and t_shirt both have different values.

Non-Parameterized vs Parameterized Constructor in Python

3. Default Constructor in Python

A constructor is a necessary tool for object creation. If we don’t define a constructor, then Python creates a non-parameterized constructor with an empty body. This constructor is called Default Constructor.  

Example of Python Default Constructor

Although we haven’t created a constructor in the above code example, Python still initialized the object shirt by creating an empty constructor.

Arguments in Python

The __init__() method supports all kinds of arguments in Python.

1. Positional Arguments in Python

Positional arguments pass values to parameters depending on their position. They are simpler and easier to use than other types of arguments.

Example of Python Positional Arguments

In the above code example, we used positional arguments to instantiate the object.

2. Keyword Arguments in Python

Arguments which should be passed by using a parameter name and an equal to sign are called keyword arguments. They are independent of position and dependent on the name of the parameter. These arguments are easier to read and provide better readability.

Example of Python Keyword Argument

In the above code example, we used keyword arguments to instantiate the object.

3. Arbitrary Argument in Python

Multiple arguments which are passed into a single indefinite length tuple are called arbitrary arguments. We use arbitrary arguments when we don’t know the number of arguments that will be passed to the function.

Example of Python Arbitrary Argument

In the above code example, we used arbitrary arguments to instantiate the object.

Adding Attributes in Python

We can add new attributes to the constructor even after we instantiated the object.

Example of Adding Attributes in Python

In the above code example, we created an empty constructor and created an object shirt. After creating the object, we added a new attribute size to the constructor. 

Count Objects Using Constructor in Python

Constructors are called everytime we create an object, so we can use them to count the number of objects we created. 

We do this by declaring a class attribute to keep count and every time a constructor is called, it increments the class attribute. 

Example Counting Objects using Constructor in python

In the above code example, we created 10 objects of the class Dress and using the attribute no_of_dresses and constructor __init__(), we counted the 10 objects.

Overloading in Python

Python doesn’t support Method Overloading. Whenever we define a second constructor, it overrides the first constructor.

Example of Python Overloading

In the above code example, the second __init__() method has overridden the first __init__() method and the first __init__() method no longer exists to call.

It doesn’t work even if we use different kinds of constructors by changing the number of parameters. 

For Example:

In the above code example, instead of calling the first constructor, Python called the second constructor.

One workaround to achieve overloading-like behavior is to use default arguments.

For Example

In the above code example, __init__() method prints the sum of two arguments if two arguments are passed, otherwise, it just prints the first argument.

Return Statement in Python

Like all other methods, __init__() method also has a return statement but unlike other methods, it can only return None . Trying to return anything other than None raises TypeError. Since returning only None is useless, we never use a return statement in the constructor in Python. 

Example of Python Return Statement

In the above code example, we tried to return a string rather than None and raised a TypeError.

Importance of Constructor in Python

The use of Constructor in Python is to instantiate the objects. Without constructors, we cannot define new values to new objects. All objects will have the same values and will no longer be unique. Objects will be nothing more than duplicates. To provide uniqueness to the objects, we need constructors. 

Constructors are also useful to call any methods while creating the object. This ability can help us in creating more dynamic and complex objects. 

In the above code example, instead of calling the function everytime we need to get an area, we use a constructor to automatically call the find_area() function and save the area value as soon as we create an object.

If we need to use the area multiple times, we can simply access the saved value rather than invoking the function multiple times. This helps to prevent invoking the method multiple times.

Method __new__() in Python

People often assume that __init__() is the first method Python calls while creating an object but it is false. To create an object, Python first calls __new__() method to create the object and then calls __init__() method to instantiate the created object.

Example of Python Method__new__()

By looking at the above code example, we can clearly understand that __new__() is called as soon as we define an object.

Python Interview Questions on Constructor in Python

Q1. Create a class and make the class print a string “Object Created” whenever we instantiate an object.

Ans 1. Below is the complete code:

The above code prints a string whenever we instantiate an object.

Q2. Create a non-parameterized constructor and set the default values for the following attributes:

make = “Aud”

model = “SQ”

Ans 2. Code is as follows:

Q3. Create a class Triangle and initialize it with height and base and create a method area to return the area of the triangle.

Ans 3. Code is as follows:

Q4. Use a return statement in the constructor without raising an error.

Ans 4. Code is as follows:

Q5. Change the output of the given code without editing it, add new code to the given code that only prints “New Object Created” when an object is instantiated.

Ans 5. Code and Output are as follows:

Quiz on Constructor in Python

Quiz summary.

0 of 10 Questions completed

Information

You have already completed the quiz before. Hence you can not start it again.

Quiz is loading…

You must sign in or sign up to start the quiz.

You must first complete the following:

Quiz complete. Results are being recorded.

0 of 10 Questions answered correctly

Time has elapsed

You have reached 0 of 0 point(s), ( 0 )

Earned Point(s): 0 of 0 , ( 0 ) 0 Essay(s) Pending (Possible Point(s): 0 )

• Not categorized 0%
• Review / Skip

1 . Question

Constructors ____ an object.

• Instantiate

2 . Question

 How many parameters do non-parameterized constructors contain?

• More than two

3 . Question

  What default parameter does a constructor contain?

• Both A and B
• None of the above

4 . Question

A constructor can only return ___.

5 . Question

Which of the following statement(s) is/are true?

Statement 1: __init__ instantiates the created object.

Statement 2: Python first invokes the __new__ and then invokes the __init__ method.

• Statement 1 is true
• Statement 2 is true
• Both statements are true
• None of the statements are true

6 . Question

What is the output of the below code?

>>> class SomeClass:

>>>    def __init__(self):

>>>        print(“Instantiated”)

>>> print(SomeClass())

• Instantiated
• SyntaxError

7 . Question

Read the code and choose the correct option.

>>> class RandomClass:

>>>    rand = 123

>>> print(RandomClass().rand)

The above code contains

• No constructor
• A default constructor
• A parameterized constructor
• Both B and C

8 . Question

 Read the code and choose the correct option.

>>> class Fruit:

>>>    def __init__(self, taste):

>>>        self.taste = taste

>>> print(Fruit(“Sweet”).taste)

9 . Question

>>> class Phone:

>>>    count = 0

>>>    def __init__(self, brand, model, os):

>>>        self.brand = brand

>>>        self.model = model

>>>        self.os = os

>>>        Phone.count += 1

>>> iPhone = Phone(“Apple”, 11, “iOS”)

>>> one_plus = Phone(“One Plus”, “Nord”, “Android”)

>>> iPhone.model = f”{one_plus.model}{Phone.count}”

>>> print(iPhone.model)

10 . Question

>>> class Dual:

>>>        print(“Constructor 1”)

>>>        print(“Constructor 2”)

>>> obj = Dual()

• Constructor 1
• Constructor 2
• The program compiles but prints nothing

In this article, we discussed the constructors in Python. We discussed the types and how to create those different types of constructors. We also learned about the different types of parameters we can use and how overloading works in Python. 

Furthermore, if you have any queries or thoughts, please feel free to share them with us in the comment section.

Your 15 seconds will encourage us to work even harder Please share your happy experience on Google | Facebook

Tags: Constructor in Python Constructors in Python Default Constructor in Python Non Parameterized constructor in Python Parameterized constructor in Python Types of constructor in Python

PythonGeeks Team

At PythonGeeks, our team provides comprehensive guides on Python programming, AI, Data Science, and machine learning. We are passionate about simplifying Python for coders of all levels, offering career-focused resources.

2 Responses

• Pingbacks 0

what is that f in return statement ?

hy, i am beginner and try to learn python, i learn a lot of things , which stuck in my mind for many days, i really feel happy and get inspire

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Save my name, email, and website in this browser for the next time I comment.

Username or Email Address

Remember Me

What is a constructor in Python?

• constructor

The constructor is a method that is called when an object is created. This method is defined in the class and can be used to initialize basic variables.

If you create four objects, the class constructor is called four times. Every class has a constructor, but its not required to explicitly define it.

Related course: Complete Python Programming Course & Exercises

Constructor

Each time an object is created a method is called. That methods is named the constructor .

The constructor is created with the function init . As parameter we write the self keyword, which refers to itself (the object). The process visually is:

The newly created object now has the variables set, without you having to define them manually. You could create tens or hundreds of objects without having to set the values each time.

python __init__

The function init (self) builds your object. Its not just variables you can set here, you can call class methods too. Everything you need to initialize the object(s).

Lets say you have a class Plane, which upon creation should start flying. There are many steps involved in taking off: accelerating, changing flaps, closing the wheels and so on.

The default actions can be defined in methods. These methods can be called in the constructor .

To summarize: A constructor is called if you create an object. In the constructor you can set variables and call methods.

Default value

The constructor of a class is unique: initiating objects from different classes will call different constructors.

Default values of newly created objects can be set in the constructor.

The example belwo shows two classes with constructors. Then two objects are created but different constructors are called.

But creating multiple objects from one class, will call the same constructor.

If you are a beginner, then I highly recommend this book.

Try the exercise below:

• Make two additional objects
• Add another variable and initialize it

Download answers

Class(es) and Objects in Python

Getter and Setter in Python

Python Programming

Constructors in Python

Updated on:  August 28, 2021 | 10 Comments

Constructor is a special method used to create and initialize an object of a class. On the other hand, a destructor is used to destroy the object.

After reading this article, you will learn:

• How to create a constructor to initialize an object in Python
• Different types of constructors
• Constructor overloading and chaining

Table of contents

Example: create a constructor in python, default constructor, non-parametrized constructor, parameterized constructor, constructor with default values, self keyword in python, constructor overloading, constructor chaining, counting the number of objects of a class, constructor return value, conclusion and quick recap, what is constructor in python.

In object-oriented programming , A constructor is a special method used to create and initialize an object of a class . This method is defined in the class.

• The constructor is executed automatically at the time of object creation.
• The primary use of a constructor is to declare and initialize data member/ instance variables of a class. The constructor contains a collection of statements (i.e., instructions) that executes at the time of object creation to initialize the attributes of an object.

For example, when we execute obj = Sample() , Python gets to know that obj is an object of class Sample and calls the constructor of that class to create an object.

Note : In Python, internally, the __new__ is the method that creates the object, and __del__ method is called to destroy the object when the reference count for that object becomes zero.

In Python, Object creation is divided into two parts in Object Creation and Object initialization

• Internally, the __new__ is the method that creates the object
• And, using the __init__() method we can implement constructor to initialize the object.

Syntax of a constructor

• def : The keyword is used to define function.
• __init__() Method: It is a reserved method. This method gets called as soon as an object of a class is instantiated.
• self : The first argument self refers to the current object. It binds the instance to the __init__() method. It’s usually named self to follow the naming convention.

Note : The __init__() method arguments are optional. We can define a constructor with any number of arguments.

In this example, we’ll create a Class Student with an instance variable student name. we’ll see how to use a constructor to initialize the student name at the time of object creation.

• In the above example, an object s1 is created using the constructor
• While creating a Student object name is passed as an argument to the __init__() method to initialize the object.
• Similarly, various objects of the Student class can be created by passing different names as arguments.

• For every object, the constructor will be executed only once. For example, if we create four objects, the constructor is called four times.
• In Python, every class has a constructor, but it’s not required to define it explicitly. Defining constructors in class is optional.
• Python will provide a default constructor if no constructor is defined.

Types of Constructors

In Python, we have the following three types of constructors.

• Non-parametrized constructor
• Parameterized constructor

Python will provide a default constructor if no constructor is defined. Python adds a default constructor when we do not include the constructor in the class or forget to declare it. It does not perform any task but initializes the objects. It is an empty constructor without a body.

If you do not implement any constructor in your class or forget to declare it, the Python inserts a default constructor into your code on your behalf. This constructor is known as the default constructor.

It does not perform any task but initializes the objects. It is an empty constructor without a body.

• The default constructor is not present in the source py file. It is inserted into the code during compilation if not exists. See the below image.
• If you implement your constructor, then the default constructor will not be added.

As you can see in the example, we do not have a constructor, but we can still create an object for the class because Python added the default constructor during a program compilation.

A constructor without any arguments is called a non-parameterized constructor. This type of constructor is used to initialize each object with default values.

This constructor doesn’t accept the arguments during object creation. Instead, it initializes every object with the same set of values.

As you can see in the example, we do not send any argument to a constructor while creating an object.

A constructor with defined parameters or arguments is called a parameterized constructor. We can pass different values to each object at the time of creation using a parameterized constructor.

The first parameter to constructor is self that is a reference to the being constructed, and the rest of the arguments are provided by the programmer. A parameterized constructor can have any number of arguments.

For example, consider a company that contains thousands of employees. In this case, while creating each employee object, we need to pass a different name, age, and salary. In such cases, use the parameterized constructor.

In the above example, we define a parameterized constructor which takes three parameters.

Python allows us to define a constructor with default values. The default value will be used if we do not pass arguments to the constructor at the time of object creation.

The following example shows how to use the default values with the constructor.

As you can see, we didn’t pass the age and classroom value at the time of object creation, so default values are used.

As you all know, the class contains instance variables and methods. Whenever we define instance methods for a class, we use self as the first parameter. Using self , we can access the instance variable and instance method of the object.

The first argument self refers to the current object.

Whenever we call an instance method through an object, the Python compiler implicitly passes object reference as the first argument commonly known as self.

It is not mandatory to name the first parameter as a self . We can give any name whatever we like, but it has to be the first parameter of an instance method.

Constructor overloading is a concept of having more than one constructor with a different parameters list in such a way so that each constructor can perform different tasks.

For example, we can create a three constructor which accepts a different set of parameters

Python does not support constructor overloading . If we define multiple constructors then, the interpreter will considers only the last constructor and throws an error if the sequence of the arguments doesn’t match as per the last constructor. The following example shows the same.

• As you can see in the above example, we defined multiple constructors with different arguments.
• At the time of object creation, the interpreter executed the second constructor because Python always considers the last constructor.
• Internally, the object of the class will always call the last constructor, even if the class has multiple constructors.
• In the example when we called a constructor only with one argument, we got a type error.

Constructors are used for instantiating an object. The task of the constructor is to assign value to data members when an object of the class is created.

Constructor chaining is the process of calling one constructor from another constructor. Constructor chaining is useful when you want to invoke multiple constructors, one after another, by initializing only one instance.

In Python, constructor chaining is convenient when we are dealing with inheritance . When an instance of a child class is initialized, the constructors of all the parent classes are first invoked and then, in the end, the constructor of the child class is invoked.

Using the super() method we can invoke the parent class constructor from a child class.

The constructor executes when we create the object of the class. For every object, the constructor is called only once. So for counting the number of objects of a class, we can add a counter in the constructor, which increments by one after each object creation.

In Python, the constructor does not return any value. Therefore, while declaring a constructor, we don’t have anything like return type. Instead, a constructor is implicitly called at the time of object instantiation. Thus, it has the sole purpose of initializing the instance variables.

The __init__() is required to return None. We can not return something else. If we try to return a non-None value from the __init__() method, it will raise TypeError.

In this lesson, we learned constructors and used them in object-oriented programming to design classes and create objects.

The below list contains the summary of the concepts we learned in this tutorial.

• A constructor is a unique method used to initialize an object of the class.
• Constructor is not a method and doesn’t return anything. it returns None
• In Python, we have three types of constructor default, Non-parametrized, and parameterized constructor.
• Using self, we can access the instance variable and instance method of the object. The first argument self refers to the current object.
• Constructor overloading is not possible in Python.
• If the parent class doesn’t have a default constructor, then the compiler would not insert a default constructor in the child class.
• A child class constructor can also invoke the parent class constructor using the super() method.

Did you find this page helpful? Let others know about it. Sharing helps me continue to create free Python resources.

About Vishal

I’m  Vishal Hule , the Founder of PYnative.com. As a Python developer, I enjoy assisting students, developers, and learners. Follow me on  Twitter .

Related Tutorial Topics:

Python exercises and quizzes.

Free coding exercises and quizzes cover Python basics, data structure, data analytics, and more.

• 15+ Topic-specific Exercises and Quizzes
• Each Exercise contains 10 questions
• Each Quiz contains 12-15 MCQ

Loading comments... Please wait.

About PYnative

PYnative.com is for Python lovers. Here, You can get Tutorials, Exercises, and Quizzes to practice and improve your Python skills .

Explore Python

• Learn Python
• Python Basics
• Python Databases
• Python Exercises
• Python Quizzes
• Online Python Code Editor
• Python Tricks

To get New Python Tutorials, Exercises, and Quizzes

Legal Stuff

We use cookies to improve your experience. While using PYnative, you agree to have read and accepted our Terms Of Use , Cookie Policy , and Privacy Policy .

Copyright © 2018–2024 pynative.com

What do you want to learn?

Constructors in Python

Written by Rahul Lath

Updated on: 07 Dec 2023

Python Tutorials

What are Constructors in Python ?

When an object of a class is created in Python, a constructor is a special kind of method that is automatically called. Instance variables of a class are initialized using constructors. They are defined by using the init() method and share the same name as the class.

An important concept in object-oriented programming, constructors are crucial for beginners. They enable programmers to produce objects of a class with their attributes set to initial values. By employing constructors, we can guarantee that the object is created in a usable state and prevent any potential undefined behavior.

Looking to Learn Python? Book a Free Trial Lesson and match with top Python Tutors for concepts, projects and assignment help on Wiingy today!

Types of Constructors in Python

In Python, there are three different kinds of constructors:

Default Constructor: This is the simplest constructor type and does not accept any parameters. Python automatically creates a default constructor when a class does not have one defined explicitly. All of the class’ instance variables are initialized to their default values by the default constructor.

Non-parameterized Constructor: This kind of constructor is explicitly defined by the programmer but does not accept any parameters. It is also known as the constructor without arguments. The instance variable values are initialized to some predetermined default values in this kind of constructor.

Parameterized Constructor: This type of constructor accepts one or more parameters and initializes the instance variables of the class with the values passed as arguments. It is also called the argument constructor.

Non-Parameterized Constructor

A non-parameterized constructor is one which does not accept parameters. It is used to set some default values for the instance variables of a class and is explicitly defined by the programmer.

In the above example, we have defined a non-parameterized constructor for the Person class. It initializes the name and age attributes of the object to “John” and 20, respectively. When we create an object of the Person class using the constructor, it sets the name and age attributes to their default values.

Benefits of using non-parameterized constructor:

• Easy to use: Non-parameterized constructors are easy to use and do not require any arguments to be passed while creating an object.
• Default values: Non-parameterized constructors provide default values to the instance variables of a class, which can be helpful in situations where we do not have any specific values to initialize the variables with.
• Code optimization: Using non-parameterized constructors can optimize the code by reducing the number of parameters that need to be passed while creating an object.

Default Constructor

A default constructor is a constructor that takes no arguments and is defined implicitly by Python if no other constructor is defined. It initializes all the instance variables of a class to their default values. The default constructor is called automatically when an object of the class is created.

In the above example, we have defined a default constructor for the Student class. The default constructor initializes the name, age, and grade attributes of the object to their default values. When we create an object of the Student class using the default constructor, it sets the name, age, and grade attributes to their default values.

Benefits of using default constructor:

• Easy to use: Default constructors are easy to use and do not require any arguments to be passed while creating an object.
• Code optimization: Using default constructors can optimize the code by reducing the number of parameters that need to be passed while creating an object.
• Consistency : Using default constructors can ensure consistency across all objects of a class by initializing them to their default values.

Parameterized Constructor

An instance variable of a class is initialized with the values passed as arguments by a parameterized constructor, which accepts one or more arguments. It enables programmers to create objects of a class with attributes that have unique values set.

In the above example, we have defined a parameterized constructor for the Rectangle class. The parameterized constructor takes two arguments, length and breadth, and initializes the length and breadth attributes of the object with the values passed as arguments. When we create an object of the Rectangle class using the parameterized constructor, it sets the length and breadth attributes to the values passed as arguments.

Benefits of using parameterized constructor:

• Customization: When creating objects of a class, parameterized constructors let programmers alter the values of instance variables.
• Flexibility: By allowing objects of the class to be created with different values assigned to their attributes, parameterized constructors can increase a class’s flexibility.
• Reusability: By allowing objects of the class to be created with different values assigned to their attributes, parameterized constructors can increase a class’s reusability.

Understanding Self Parameter in Constructors

A reference to the object being created is provided by the self parameter in constructors. It is a unique parameter that can be used to access the class’s instance variables and methods. When an object of the class is created, the self parameter, which is always the first parameter of a constructor, is automatically passed.

In the above example, we have defined a parameterized constructor for the Employee class, which takes three arguments, name, age, and salary, and initializes the instance variables of the class with the values passed as arguments. The self parameter is used to access the instance variables and set their values.

Explanation of how self parameter works in constructors :

When we create an object of a class, Python automatically passes the reference to that object as the first parameter to the constructor. This parameter is named self by convention, but it can be named anything else as well. The self parameter is used to access the instance variables and methods of the class within the constructor.

Example of self parameter in Python constructors:

In the example above, a Car class has been created with a parameterized constructor that accepts the three arguments make, model, and year and initializes the class’ instance variables with the values supplied. The display_car_details() method, which is invoked using the class object, is used to show the car’s details. In the method, the self parameter is used to access the class’ instance variables.

Initialization and Destructors

Initialization is the process of setting some default values for a class’s instance variables. Python constructors are used for this. Destructors, on the other hand, are procedures that are automatically called when an object is destroyed or garbage-collected. The del() method is used to define the destructor method in Python.

Explanation of how initialization and destructors work in Python:

The constructor of a class is automatically invoked when an object of that class is created in order to initialize the class’ instance variables. Similar to this, the destructor is automatically called when an object is destroyed or garbage collected to release the resources used by the object. When an object is no longer in use, Python automatically calls the destructor rather than the programmer explicitly doing so.

Example of initialization and destructors in Python:

In the example above, we defined a class called Book with a constructor that accepts the parameters title and author as well as initializes the class’ instance variables with those values. To release the resources used by the object, the del() method serves as a destructor. The constructor is automatically called when an object of the Book class is created, and the destructor is automatically called when an object is deleted using the del keyword.

Advantages of Using Constructors

The advantages of constructors in Python programming include:

• Code optimization: By lowering the number of parameters that must be passed when creating an object, constructors can improve the code.
• Consistency: By initializing all class objects to their default values using constructors, consistency can be guaranteed across all of the objects in the class.
• Flexibility: By allowing objects of the class to be created with different values assigned to their attributes, constructors can increase a class’s flexibility.

How constructors simplify and speed up programming:

Constructors in Python offer a way to create objects of a class with initial values set to its attributes, which can make programming simpler and more effective. They enable programmers to guarantee that the object is created in a valid state and prevent any undefined behavior that might otherwise happen. By placing the initialization logic in a separate method, constructors also improve the code’s readability and maintainability.

In this article, we covered Python constructors and their significance in programming, particularly for newcomers. Additionally, we discussed the various Python constructor types and described how they operate, including default, non-parameterized, and parameterized constructors.

We also went over the idea of the self parameter in constructors and how it functions. Finally, we talked about the advantages of using constructors in Python programming and how they facilitate and improve programming. Understanding constructors is essential for becoming a proficient Python programmer because they are a fundamental idea in object-oriented programming. 

What are constructors in Python?

When an object of a class is created in Python, a special method called a constructor is automatically called. They share the same name as the class name and are used to initialize the instance variables of a class.

What is init constructor in Python?

Python has a unique method called init that serves as a class’ constructor. It is used to initialize the class’ instance variables and is called automatically whenever an object of a given class is created.

What is the use of constructor in OOP Python?

In OOP Python, the constructor is used to initialize class instance variables and make sure the object is created in a usable state. It is a fundamental idea in object-oriented programming and enables developers to construct objects that belong to a class with their attributes set to initial values.

What is constructor vs init in Python?

In Python, the words “constructor” and “init” have identical definitions. A class’s constructor, the init method, is automatically called whenever an object belonging to that class is created.

Written by by

Reviewed by by

Share article on

• Contributors

Class Constructors

Table of contents, exploring python's class constructors, inheritance and constructors in python, delving into python's process of instantiating objects, initializing objects using the __init__() method, customizing python's object initialization, creating python class object with flexible initializers, object creation using the __new__() method.

Object instantiation is a fundamental concept in object-oriented programming that refers to the process of creating new objects from a class. This process involves using constructors, which are special methods that define how new objects are initialized. This article describes how to instantiate an object in Python and provides examples of how to create and use these objects in your code.

A class constructor in Python is a special method that is executed when an object of a class is instantiated. It is used to initialize the attributes of the class. The constructor method in Python is called __init__() and it is defined within the class.

How to Instantiate a Python Class

Let's explore how to instantiate a class in Python . In order to accomplish this, we must perform class instantiation in Python by creating an instance of the class that invokes its constructor method. Here's an example of a simple class and how to instantiate an object of that class.

In the above example, the Recipe class has a constructor that sets the attributes name and ingredients for each new object that is instantiated. The my_recipe object is instantiated with the name "Spaghetti Bolognese" and a list of ingredients. The print statements will output Recipe Name: Spaghetti Bolognese and Ingredients: ['spaghetti', 'tomato sauce', 'ground beef'] .

In Python, constructors play a crucial role in class inheritance, allowing child classes to inherit and extend attributes and behaviors from parent classes.

Constructor Inheritance Basics

Child classes inherit the constructor of their parent class, enabling them to reuse the initialization logic from the parent. For example:

In this example, the Car class inherits from Vehicle and extends its attributes.

Constructor Overriding

Child classes can also override the parent class's constructor to customize initialization:

Abstract Base Classes

Abstract base classes allow you to enforce initialization patterns across a class hierarchy. Please refer to the abstract classes page to read more.

Instantiating an object, in Python, means creating an instance of a class. When you create an instance of a class, you instantiate the object. In Python, the process of instantiating objects involves creating and initializing objects.

To instantiate a Python class, you need to use the constructor method, which is the __init__() method. The constructor method initializes the attributes or properties of an object.

In this example, we defined a class called Person with two attributes, name and age . We instantiated an object person1 and passed two arguments to the constructor method. Finally, we printed the values of the name and age attributes.

In this example, we defined a class called Employee with three attributes, firstname , lastname and salary . We instantiated an object employee1 and passed three arguments to the constructor method. Finally, we printed the values of the firstname, get_fullname() and salary attributes.

In Python, instantiating objects is a powerful and flexible way to create objects with specific behaviors and attributes.

The __init__() method is used in Python classes to initialize newly-created objects. It is automatically called when an object is created using the class constructor.

Here's an example of a class with an __init__() method:

In this example, the Person class has an init method that takes two arguments: name and age . When you create a new Person object, you pass in values for these arguments, and the __init__() method sets the corresponding instance variables .

You can also have optional or default arguments in the __init__() method:

In this example, the Rectangle class has an __init__() method that takes two optional arguments: width and height . If no arguments are provided, the default values of 0 are used.

In Python, the __init__() method is called when an object of a class is created. It is used to initialize the attributes of the object. However, sometimes we may need to customize object initialization by specifying our own parameters. This can be achieved using the following methods:

Creating Python Class without __init__()

One way to customize object initialization is to define a custom method that initializes the attributes. This method can take parameters which are used to set the values of the attributes. Here is an example:

In this example, we defined a custom method set_values() to initialize the attributes make , model , and year . We then called this method on an object of the Car class to set the attribute values.

Creating Class with __init__()

Another way to customize object initialization is to use class-level attributes. These attributes can be set in the class definition and used to initialize the attributes of the object. Here is an example:

In this example, we defined make , model , and year as class-level attributes and set their default values to an empty string and 0 . We then used these attributes to initialize the object's attributes in the __init__() method. We can later modify the attribute values of the object as in the previous example.

Object-oriented programming allows us to create objects with different properties. We can initialize an object with fixed properties or flexible properties by passing different arguments to the constructor. In Python, we can use the __init__() method to initialize an object with flexible properties.

In the above example, we initialized the Rectangle object with fixed properties width and height . The object returned by the constructor will always have the same properties.

In the above example, we initialized the Circle object with flexible properties radius , color , and border . We passed only one argument radius to the constructor, but we also specified default values for color and border . This allows us to create a Circle object with only one argument, or three arguments, or any number of arguments in between.

The __new__() method is used in Python to create objects dynamically. It allows the developer to create a class object using the class name, and then you can add attribute after init of python class.

In the above example, we create a class called Person and then use the .new() method to create an object called dave . We then add the attributes name and age to this object after initialization.

In this example, we create a class called Car and define its attributes during initialization using __init__() . We then create an object called car using the __new__() method and initialize it with the model and make attributes. Finally, we add the attribute color to the car object after initialization.

Contribute with us!

Do not hesitate to contribute to Python tutorials on GitHub: create a fork, update content and issue a pull request.

Explaining Constructor in Python With an Example self.__wrap_b=(t,n,e)=>{e=e||document.querySelector(`[data-br="${t}"]`);let s=e.parentElement,r=R=>e.style.maxWidth=R+"px";e.style.maxWidth="";let o=s.clientWidth,i=s.clientHeight,c=o/2-.25,l=o+.5,u;if(o){for(;c+1 {self.__wrap_b(0,+e.dataset.brr,e)})).observe(s)};self.__wrap_b(":Rid9j6:",1)

What are Constructor in Python?

• Syntax of constructor declaration : 

Function Of Constructor

Types of constructor in python, parameterized constructor, non-parameterized constructor, creating a constructor in python.

• Constructors can have how many parameters? 

Difference between parameterized and non-parameterized constructors

Counting the number of objects in a class, several constructors in a single class using python’s built-in class functions, built-in class attributes, frequently asked questions to resolve (faqs).

Classes and Objects are the things that define Object-Oriented Programming Languages, and Constructor and Destructors are the ones that define Classes and Objects.

In this article, we will briefly discuss what Constructor are, How to invoke them, their types, and How to Create them with real-time code examples.

Constructors are Basic Building Blocks of Python, Precisely A class. Constructors are used to initialize variables of a class so that the class variables do not point to a rubbish value before assigning values to it. By doing this, Some are initialized to zero and other to the specific values given by the user. In Python, the “__init__” method is used to define a constructor. We do not need a separate calling statement to call a constructor, It is called whenever we create an object to the class.

Syntax of constructor declaration : 

The “__init__” method is used to declare a constructor in python. It can be used simply using the “def” keyword in the code, just like a function.

The function of a constructor is to assign the default values to a constructor so that whenever the object is created, a constructor is invoked automatically and default values will be assigned to it.

There are two types of constructors in python, namely,

Default Constructor

Non-default constructor.

A default constructor is a constructor which takes no argument while defining the function. An example can be seen below.

Click Here to run the code!

Non-Default Constructors can also be called as Parameterized Constructors, meaning we can send values to the constructors while creating an object.

A parameterized Constructor is a non-default constructor. It takes arguments while creating the object. The Syntax can be seen below.

An example of the parameterized constructor is discussed in the above section.

A Non-Parameterized constructor is a simple default constructor. It takes no arguments. The syntax is almost the same as parameterized constructor except for the parameters part.

We can create a constructor by using the def keyword, which is often used for defining a function in python. As a Constructor is also a special method, we can create the same. The difference comes here, the function name of a constructor is always “__init__”.

Example Code

Constructors can have how many parameters .

A Constructor can have any number of parameters, starting from zero to any number until the memory is full, or the requirement is met.

This can be called a classical problem of constructors. We can solve this by simply learning the concept of Constructors. As we have discussed a constructor is invoked whenever an object is created, Hence, we initialize a variable count to count how many times an object is invoked which is, in turn, the number of objects created.

In Python, it is possible to define multiple constructors in a single class using the @classmethod decorator. A class method is a method bound to the class and not the instance of the class.

Here is an example of how you can define multiple constructors in a single class using class methods in Python:

In Python, every class has a number of built-in attributes that can be accessed using the dot notation. Some of the most commonly used built-in class attributes are:

• __doc__ : This attribute holds the documentation string of the class if one is provided.
• __name__ : This attribute holds the name of the class as a string.
• __module__ : This attribute holds the name of the module in which the class is defined as a string.
• __dict__ : This attribute is a dictionary that holds the namespace of the class. It contains the names and values of the class’s attributes and methods.
• __bases__ : This attribute is a tuple that holds the base classes of the class.

Here is an example of how you can access these attributes in Python:

In this article, we have discussed constructors and their types and differences among them. Later, we discussed about Creating several constructors using inbuilt methods and Class Attributes.

What are constructors in Python?

In Python, a constructor is a special method that is automatically called when an object of a class is created. It is used to initialize the attributes of the object. The constructor method is named init and it is defined within the class definition.

How do Python constructors work?

Constructors are involved whenever an object is created. When a new object is created using the class, the init method is automatically called with the newly created object as the first argument and any additional arguments are passed to the class constructor. The init method can then use the self keyword to initialize the attributes of the object.

What is the purpose of Python constructors?

The main purpose of constructors in Python is to initialize the attributes of an object when it is created. The constructor method init is called automatically when a new object is created using a class and it allows you to set the initial state of the object by defining the values of its attributes. This is particularly useful when you want to ensure that every object of a class has certain attributes set to specific values when it is created.

How are Python constructors used?

In python, Constructors can be used to initialize attributes of a particular class and also to allocate memory to an object using the init method.

What are the applications of Python constructors?

In Python, constructors are used in initializing an object’s state when it is first created. The constructor method is called automatically when an object of the class is created. The constructor method is defined using the init() method, and it takes self as the first parameter.

Sharing is caring

Did you like what Krishna Bethina wrote? Thank them for their work by sharing it on social media.

No comment s so far

Curious about this topic? Continue your journey with these coding courses:

275 students learning

Python Crash Course for Beginners

Surendra varma Pericherla

Learn Data Structures Using Python

Learn Python practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn python interactively, python introduction.

• Get Started With Python
• Your First Python Program
• Python Comments

Python Fundamentals

• Python Variables and Literals
• Python Type Conversion
• Python Basic Input and Output
• Python Operators

Python Flow Control

• Python if...else Statement
• Python for Loop
• Python while Loop
• Python break and continue
• Python pass Statement

Python Data types

• Python Numbers and Mathematics
• Python List
• Python Tuple
• Python String
• Python Dictionary
• Python Functions
• Python Function Arguments
• Python Variable Scope
• Python Global Keyword
• Python Recursion
• Python Modules
• Python Package
• Python Main function

Python Files

• Python Directory and Files Management
• Python CSV: Read and Write CSV files
• Reading CSV files in Python
• Writing CSV files in Python
• Python Exception Handling
• Python Exceptions
• Python Custom Exceptions

Python Object & Class

• Python Objects and Classes

Python Inheritance

• Python Multiple Inheritance

Polymorphism in Python

• Python Operator Overloading

Python Advanced Topics

• List comprehension
• Python Lambda/Anonymous Function
• Python Iterators
• Python Generators
• Python Namespace and Scope
• Python Closures
• Python Decorators
• Python @property decorator
• Python RegEx

Python Date and Time

• Python datetime
• Python strftime()
• Python strptime()
• How to get current date and time in Python?
• Python Get Current Time
• Python timestamp to datetime and vice-versa
• Python time Module
• Python sleep()

Additional Topic

• Precedence and Associativity of Operators in Python
• Python Keywords and Identifiers
• Python Asserts
• Python Json
• Python *args and **kwargs

Python Tutorials

Python Object Oriented Programming

Python object()

• Python Docstrings

Python Classes and Objects

In the last tutorial, we learned about Python OOP . We know that Python also supports the concept of objects and classes.

An object is simply a collection of data (variables) and methods (functions). Similarly, a class is a blueprint for that object.

Before we learn about objects, let's first learn about classes in Python.

• Python Classes

A class is considered a blueprint of objects.

We can think of the class as a sketch (prototype) of a house. It contains all the details about the floors, doors, windows, etc.

Based on these descriptions, we build the house; the house is the object.

Since many houses can be made from the same description, we can create many objects from a class.

• Define Python Class

We use the class keyword to create a class in Python. For example,

Here, we have created a class named ClassName .

Let's see an example,

• Bike - the name of the class
• name/gear - variables inside the class with default values "" and 0 respectively.

Note : The variables inside a class are called attributes.

• Python Objects

An object is called an instance of a class.

Suppose Bike is a class then we can create objects like bike1 , bike2 , etc from the class.

Here's the syntax to create an object.

Here, bike1 is the object of the class. Now, we can use this object to access the class attributes.

• Access Class Attributes Using Objects

We use the . notation to access the attributes of a class. For example,

Here, we have used bike1.name and bike1.gear to change and access the value of name and gear attributes, respectively.

• Example 1: Python Class and Objects

In the above example, we have defined the class named Bike with two attributes: name and gear .

We have also created an object bike1 of the class Bike .

Finally, we have accessed and modified the properties of an object using the . notation.

• Create Multiple Objects of Python Class

We can also create multiple objects from a single class. For example,

In the above example, we have created two objects employee1 and employee2 of the Employee class.

• Python Methods

We can also define a function inside a Python class. A Python function defined inside a class is called a method .

In the above example, we have created a class named Room with:

• Attributes : length and breadth
• Method : calculate_area()

Here, we have created an object named study_room from the Room class.

We then used the object to assign values to attributes: length and breadth .

Notice that we have also used the object to call the method inside the class,

Here, we have used the . notation to call the method. Finally, the statement inside the method is executed.

• Python Constructors

Earlier we assigned a default value to a class attribute,

However, we can also initialize values using the constructors. For example,

Here, __init__() is the constructor function that is called whenever a new object of that class is instantiated.

The constructor above initializes the value of the name attribute.

We have used the self.name to refer to the name attribute of the bike1 object.

If we use a constructor to initialize values inside a class, we need to pass the corresponding value during the object creation of the class.

Here, "Mountain Bike" is passed to the name parameter of __init__() .

• Python inheritance
• Python classmethod()

Table of Contents

• Introduction

Video: Python Classes and Objects

Sorry about that.

Our premium learning platform, created with over a decade of experience and thousands of feedbacks .

Learn and improve your coding skills like never before.

• Interactive Courses
• Certificates
• 2000+ Challenges

Related Tutorials

Python Tutorial

Python Library

Python Tutorial

File handling, python modules, python numpy, python pandas, python matplotlib, python scipy, machine learning, python mysql, python mongodb, python reference, module reference, python how to, python examples, python classes and objects, python classes/objects.

Python is an object oriented programming language.

Almost everything in Python is an object, with its properties and methods.

A Class is like an object constructor, or a "blueprint" for creating objects.

Create a Class

To create a class, use the keyword class :

Create a class named MyClass, with a property named x:

Create Object

Now we can use the class named MyClass to create objects:

Create an object named p1, and print the value of x:

The __init__() Function

The examples above are classes and objects in their simplest form, and are not really useful in real life applications.

To understand the meaning of classes we have to understand the built-in __init__() function.

All classes have a function called __init__(), which is always executed when the class is being initiated.

Use the __init__() function to assign values to object properties, or other operations that are necessary to do when the object is being created:

Create a class named Person, use the __init__() function to assign values for name and age:

Note: The __init__() function is called automatically every time the class is being used to create a new object.

Advertisement

The __str__() Function

The __str__() function controls what should be returned when the class object is represented as a string.

If the __str__() function is not set, the string representation of the object is returned:

The string representation of an object WITHOUT the __str__() function:

The string representation of an object WITH the __str__() function:

Object Methods

Objects can also contain methods. Methods in objects are functions that belong to the object.

Let us create a method in the Person class:

Insert a function that prints a greeting, and execute it on the p1 object:

Note: The self parameter is a reference to the current instance of the class, and is used to access variables that belong to the class.

The self Parameter

The self parameter is a reference to the current instance of the class, and is used to access variables that belongs to the class.

It does not have to be named self , you can call it whatever you like, but it has to be the first parameter of any function in the class:

Use the words mysillyobject and abc instead of self :

Modify Object Properties

You can modify properties on objects like this:

Set the age of p1 to 40:

Delete Object Properties

You can delete properties on objects by using the del keyword:

Delete the age property from the p1 object:

Delete Objects

You can delete objects by using the del keyword:

Delete the p1 object:

The pass Statement

class definitions cannot be empty, but if you for some reason have a class definition with no content, put in the pass statement to avoid getting an error.

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

• Python »
• 3.12.6 Documentation »
• The Python Tutorial »
• 5. Data Structures
• Theme Auto Light Dark |

5. Data Structures ¶

This chapter describes some things you’ve learned about already in more detail, and adds some new things as well.

5.1. More on Lists ¶

The list data type has some more methods. Here are all of the methods of list objects:

Add an item to the end of the list. Equivalent to a[len(a):] = [x] .

Extend the list by appending all the items from the iterable. Equivalent to a[len(a):] = iterable .

Insert an item at a given position. The first argument is the index of the element before which to insert, so a.insert(0, x) inserts at the front of the list, and a.insert(len(a), x) is equivalent to a.append(x) .

Remove the first item from the list whose value is equal to x . It raises a ValueError if there is no such item.

Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list. It raises an IndexError if the list is empty or the index is outside the list range.

Remove all items from the list. Equivalent to del a[:] .

Return zero-based index in the list of the first item whose value is equal to x . Raises a ValueError if there is no such item.

The optional arguments start and end are interpreted as in the slice notation and are used to limit the search to a particular subsequence of the list. The returned index is computed relative to the beginning of the full sequence rather than the start argument.

Return the number of times x appears in the list.

Sort the items of the list in place (the arguments can be used for sort customization, see sorted() for their explanation).

Reverse the elements of the list in place.

Return a shallow copy of the list. Equivalent to a[:] .

An example that uses most of the list methods:

You might have noticed that methods like insert , remove or sort that only modify the list have no return value printed – they return the default None . [ 1 ] This is a design principle for all mutable data structures in Python.

Another thing you might notice is that not all data can be sorted or compared. For instance, [None, 'hello', 10] doesn’t sort because integers can’t be compared to strings and None can’t be compared to other types. Also, there are some types that don’t have a defined ordering relation. For example, 3+4j < 5+7j isn’t a valid comparison.

5.1.1. Using Lists as Stacks ¶

The list methods make it very easy to use a list as a stack, where the last element added is the first element retrieved (“last-in, first-out”). To add an item to the top of the stack, use append() . To retrieve an item from the top of the stack, use pop() without an explicit index. For example:

5.1.2. Using Lists as Queues ¶

It is also possible to use a list as a queue, where the first element added is the first element retrieved (“first-in, first-out”); however, lists are not efficient for this purpose. While appends and pops from the end of list are fast, doing inserts or pops from the beginning of a list is slow (because all of the other elements have to be shifted by one).

To implement a queue, use collections.deque which was designed to have fast appends and pops from both ends. For example:

5.1.3. List Comprehensions ¶

List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition.

For example, assume we want to create a list of squares, like:

Note that this creates (or overwrites) a variable named x that still exists after the loop completes. We can calculate the list of squares without any side effects using:

or, equivalently:

which is more concise and readable.

A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. The result will be a new list resulting from evaluating the expression in the context of the for and if clauses which follow it. For example, this listcomp combines the elements of two lists if they are not equal:

and it’s equivalent to:

Note how the order of the for and if statements is the same in both these snippets.

If the expression is a tuple (e.g. the (x, y) in the previous example), it must be parenthesized.

List comprehensions can contain complex expressions and nested functions:

5.1.4. Nested List Comprehensions ¶

The initial expression in a list comprehension can be any arbitrary expression, including another list comprehension.

Consider the following example of a 3x4 matrix implemented as a list of 3 lists of length 4:

The following list comprehension will transpose rows and columns:

As we saw in the previous section, the inner list comprehension is evaluated in the context of the for that follows it, so this example is equivalent to:

which, in turn, is the same as:

In the real world, you should prefer built-in functions to complex flow statements. The zip() function would do a great job for this use case:

See Unpacking Argument Lists for details on the asterisk in this line.

5.2. The del statement ¶

There is a way to remove an item from a list given its index instead of its value: the del statement. This differs from the pop() method which returns a value. The del statement can also be used to remove slices from a list or clear the entire list (which we did earlier by assignment of an empty list to the slice). For example:

del can also be used to delete entire variables:

Referencing the name a hereafter is an error (at least until another value is assigned to it). We’ll find other uses for del later.

5.3. Tuples and Sequences ¶

We saw that lists and strings have many common properties, such as indexing and slicing operations. They are two examples of sequence data types (see Sequence Types — list, tuple, range ). Since Python is an evolving language, other sequence data types may be added. There is also another standard sequence data type: the tuple .

A tuple consists of a number of values separated by commas, for instance:

As you see, on output tuples are always enclosed in parentheses, so that nested tuples are interpreted correctly; they may be input with or without surrounding parentheses, although often parentheses are necessary anyway (if the tuple is part of a larger expression). It is not possible to assign to the individual items of a tuple, however it is possible to create tuples which contain mutable objects, such as lists.

Though tuples may seem similar to lists, they are often used in different situations and for different purposes. Tuples are immutable , and usually contain a heterogeneous sequence of elements that are accessed via unpacking (see later in this section) or indexing (or even by attribute in the case of namedtuples ). Lists are mutable , and their elements are usually homogeneous and are accessed by iterating over the list.

A special problem is the construction of tuples containing 0 or 1 items: the syntax has some extra quirks to accommodate these. Empty tuples are constructed by an empty pair of parentheses; a tuple with one item is constructed by following a value with a comma (it is not sufficient to enclose a single value in parentheses). Ugly, but effective. For example:

The statement t = 12345, 54321, 'hello!' is an example of tuple packing : the values 12345 , 54321 and 'hello!' are packed together in a tuple. The reverse operation is also possible:

This is called, appropriately enough, sequence unpacking and works for any sequence on the right-hand side. Sequence unpacking requires that there are as many variables on the left side of the equals sign as there are elements in the sequence. Note that multiple assignment is really just a combination of tuple packing and sequence unpacking.

5.4. Sets ¶

Python also includes a data type for sets . A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries. Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.

Curly braces or the set() function can be used to create sets. Note: to create an empty set you have to use set() , not {} ; the latter creates an empty dictionary, a data structure that we discuss in the next section.

Here is a brief demonstration:

Similarly to list comprehensions , set comprehensions are also supported:

5.5. Dictionaries ¶

Another useful data type built into Python is the dictionary (see Mapping Types — dict ). Dictionaries are sometimes found in other languages as “associative memories” or “associative arrays”. Unlike sequences, which are indexed by a range of numbers, dictionaries are indexed by keys , which can be any immutable type; strings and numbers can always be keys. Tuples can be used as keys if they contain only strings, numbers, or tuples; if a tuple contains any mutable object either directly or indirectly, it cannot be used as a key. You can’t use lists as keys, since lists can be modified in place using index assignments, slice assignments, or methods like append() and extend() .

It is best to think of a dictionary as a set of key: value pairs, with the requirement that the keys are unique (within one dictionary). A pair of braces creates an empty dictionary: {} . Placing a comma-separated list of key:value pairs within the braces adds initial key:value pairs to the dictionary; this is also the way dictionaries are written on output.

The main operations on a dictionary are storing a value with some key and extracting the value given the key. It is also possible to delete a key:value pair with del . If you store using a key that is already in use, the old value associated with that key is forgotten. It is an error to extract a value using a non-existent key.

Performing list(d) on a dictionary returns a list of all the keys used in the dictionary, in insertion order (if you want it sorted, just use sorted(d) instead). To check whether a single key is in the dictionary, use the in keyword.

Here is a small example using a dictionary:

The dict() constructor builds dictionaries directly from sequences of key-value pairs:

In addition, dict comprehensions can be used to create dictionaries from arbitrary key and value expressions:

When the keys are simple strings, it is sometimes easier to specify pairs using keyword arguments:

5.6. Looping Techniques ¶

When looping through dictionaries, the key and corresponding value can be retrieved at the same time using the items() method.

When looping through a sequence, the position index and corresponding value can be retrieved at the same time using the enumerate() function.

To loop over two or more sequences at the same time, the entries can be paired with the zip() function.

To loop over a sequence in reverse, first specify the sequence in a forward direction and then call the reversed() function.

To loop over a sequence in sorted order, use the sorted() function which returns a new sorted list while leaving the source unaltered.

Using set() on a sequence eliminates duplicate elements. The use of sorted() in combination with set() over a sequence is an idiomatic way to loop over unique elements of the sequence in sorted order.

It is sometimes tempting to change a list while you are looping over it; however, it is often simpler and safer to create a new list instead.

5.7. More on Conditions ¶

The conditions used in while and if statements can contain any operators, not just comparisons.

The comparison operators in and not in are membership tests that determine whether a value is in (or not in) a container. The operators is and is not compare whether two objects are really the same object. All comparison operators have the same priority, which is lower than that of all numerical operators.

Comparisons can be chained. For example, a < b == c tests whether a is less than b and moreover b equals c .

Comparisons may be combined using the Boolean operators and and or , and the outcome of a comparison (or of any other Boolean expression) may be negated with not . These have lower priorities than comparison operators; between them, not has the highest priority and or the lowest, so that A and not B or C is equivalent to (A and (not B)) or C . As always, parentheses can be used to express the desired composition.

The Boolean operators and and or are so-called short-circuit operators: their arguments are evaluated from left to right, and evaluation stops as soon as the outcome is determined. For example, if A and C are true but B is false, A and B and C does not evaluate the expression C . When used as a general value and not as a Boolean, the return value of a short-circuit operator is the last evaluated argument.

It is possible to assign the result of a comparison or other Boolean expression to a variable. For example,

Note that in Python, unlike C, assignment inside expressions must be done explicitly with the walrus operator := . This avoids a common class of problems encountered in C programs: typing = in an expression when == was intended.

5.8. Comparing Sequences and Other Types ¶

Sequence objects typically may be compared to other objects with the same sequence type. The comparison uses lexicographical ordering: first the first two items are compared, and if they differ this determines the outcome of the comparison; if they are equal, the next two items are compared, and so on, until either sequence is exhausted. If two items to be compared are themselves sequences of the same type, the lexicographical comparison is carried out recursively. If all items of two sequences compare equal, the sequences are considered equal. If one sequence is an initial sub-sequence of the other, the shorter sequence is the smaller (lesser) one. Lexicographical ordering for strings uses the Unicode code point number to order individual characters. Some examples of comparisons between sequences of the same type:

Note that comparing objects of different types with < or > is legal provided that the objects have appropriate comparison methods. For example, mixed numeric types are compared according to their numeric value, so 0 equals 0.0, etc. Otherwise, rather than providing an arbitrary ordering, the interpreter will raise a TypeError exception.

Table of Contents

• 5.1.1. Using Lists as Stacks
• 5.1.2. Using Lists as Queues
• 5.1.3. List Comprehensions
• 5.1.4. Nested List Comprehensions
• 5.2. The del statement
• 5.3. Tuples and Sequences
• 5.5. Dictionaries
• 5.6. Looping Techniques
• 5.7. More on Conditions
• 5.8. Comparing Sequences and Other Types

Previous topic

4. More Control Flow Tools

• Report a Bug
• Show Source

Python's Assignment Operator: Write Robust Assignments

Table of Contents

The Assignment Statement Syntax

The assignment operator, assignments and variables, other assignment syntax, initializing and updating variables, making multiple variables refer to the same object, updating lists through indices and slices, adding and updating dictionary keys, doing parallel assignments, unpacking iterables, providing default argument values, augmented mathematical assignment operators, augmented assignments for concatenation and repetition, augmented bitwise assignment operators, annotated assignment statements, assignment expressions with the walrus operator, managed attribute assignments, define or call a function, work with classes, import modules and objects, use a decorator, access the control variable in a for loop or a comprehension, use the as keyword, access the _ special variable in an interactive session, built-in objects, named constants.

Python’s assignment operators allow you to define assignment statements . This type of statement lets you create, initialize, and update variables throughout your code. Variables are a fundamental cornerstone in every piece of code, and assignment statements give you complete control over variable creation and mutation.

Learning about the Python assignment operator and its use for writing assignment statements will arm you with powerful tools for writing better and more robust Python code.

In this tutorial, you’ll:

• Use Python’s assignment operator to write assignment statements
• Take advantage of augmented assignments in Python
• Explore assignment variants, like assignment expressions and managed attributes
• Become aware of illegal and dangerous assignments in Python

You’ll dive deep into Python’s assignment statements. To get the most out of this tutorial, you should be comfortable with several basic topics, including variables , built-in data types , comprehensions , functions , and Python keywords . Before diving into some of the later sections, you should also be familiar with intermediate topics, such as object-oriented programming , constants , imports , type hints , properties , descriptors , and decorators .

Free Source Code: Click here to download the free assignment operator source code that you’ll use to write assignment statements that allow you to create, initialize, and update variables in your code.

Assignment Statements and the Assignment Operator

One of the most powerful programming language features is the ability to create, access, and mutate variables . In Python, a variable is a name that refers to a concrete value or object, allowing you to reuse that value or object throughout your code.

To create a new variable or to update the value of an existing one in Python, you’ll use an assignment statement . This statement has the following three components:

• A left operand, which must be a variable
• The assignment operator ( = )
• A right operand, which can be a concrete value , an object , or an expression

Here’s how an assignment statement will generally look in Python:

Here, variable represents a generic Python variable, while expression represents any Python object that you can provide as a concrete value—also known as a literal —or an expression that evaluates to a value.

To execute an assignment statement like the above, Python runs the following steps:

• Evaluate the right-hand expression to produce a concrete value or object . This value will live at a specific memory address in your computer.
• Store the object’s memory address in the left-hand variable . This step creates a new variable if the current one doesn’t already exist or updates the value of an existing variable.

The second step shows that variables work differently in Python than in other programming languages. In Python, variables aren’t containers for objects. Python variables point to a value or object through its memory address. They store memory addresses rather than objects.

This behavior difference directly impacts how data moves around in Python, which is always by reference . In most cases, this difference is irrelevant in your day-to-day coding, but it’s still good to know.

The central component of an assignment statement is the assignment operator . This operator is represented by the = symbol, which separates two operands:

• A value or an expression that evaluates to a concrete value

Operators are special symbols that perform mathematical , logical , and bitwise operations in a programming language. The objects (or object) on which an operator operates are called operands .

Unary operators, like the not Boolean operator, operate on a single object or operand, while binary operators act on two. That means the assignment operator is a binary operator.

Note: Like C , Python uses == for equality comparisons and = for assignments. Unlike C, Python doesn’t allow you to accidentally use the assignment operator ( = ) in an equality comparison.

Equality is a symmetrical relationship, and assignment is not. For example, the expression a == 42 is equivalent to 42 == a . In contrast, the statement a = 42 is correct and legal, while 42 = a isn’t allowed. You’ll learn more about illegal assignments later on.

The right-hand operand in an assignment statement can be any Python object, such as a number , list , string , dictionary , or even a user-defined object. It can also be an expression. In the end, expressions always evaluate to concrete objects, which is their return value.

Here are a few examples of assignments in Python:

The first two sample assignments in this code snippet use concrete values, also known as literals , to create and initialize number and greeting . The third example assigns the result of a math expression to the total variable, while the last example uses a Boolean expression.

Note: You can use the built-in id() function to inspect the memory address stored in a given variable.

Here’s a short example of how this function works:

The number in your output represents the memory address stored in number . Through this address, Python can access the content of number , which is the integer 42 in this example.

If you run this code on your computer, then you’ll get a different memory address because this value varies from execution to execution and computer to computer.

Unlike expressions, assignment statements don’t have a return value because their purpose is to make the association between the variable and its value. That’s why the Python interpreter doesn’t issue any output in the above examples.

Now that you know the basics of how to write an assignment statement, it’s time to tackle why you would want to use one.

The assignment statement is the explicit way for you to associate a name with an object in Python. You can use this statement for two main purposes:

• Creating and initializing new variables
• Updating the values of existing variables

When you use a variable name as the left operand in an assignment statement for the first time, you’re creating a new variable. At the same time, you’re initializing the variable to point to the value of the right operand.

On the other hand, when you use an existing variable in a new assignment, you’re updating or mutating the variable’s value. Strictly speaking, every new assignment will make the variable refer to a new value and stop referring to the old one. Python will garbage-collect all the values that are no longer referenced by any existing variable.

Assignment statements not only assign a value to a variable but also determine the data type of the variable at hand. This additional behavior is another important detail to consider in this kind of statement.

Because Python is a dynamically typed language, successive assignments to a given variable can change the variable’s data type. Changing the data type of a variable during a program’s execution is considered bad practice and highly discouraged. It can lead to subtle bugs that can be difficult to track down.

Unlike in math equations, in Python assignments, the left operand must be a variable rather than an expression or a value. For example, the following construct is illegal, and Python flags it as invalid syntax:

In this example, you have expressions on both sides of the = sign, and this isn’t allowed in Python code. The error message suggests that you may be confusing the equality operator with the assignment one, but that’s not the case. You’re really running an invalid assignment.

To correct this construct and convert it into a valid assignment, you’ll have to do something like the following:

In this code snippet, you first import the sqrt() function from the math module. Then you isolate the hypotenuse variable in the original equation by using the sqrt() function. Now your code works correctly.

Now you know what kind of syntax is invalid. But don’t get the idea that assignment statements are rigid and inflexible. In fact, they offer lots of room for customization, as you’ll learn next.

Python’s assignment statements are pretty flexible and versatile. You can write them in several ways, depending on your specific needs and preferences. Here’s a quick summary of the main ways to write assignments in Python:

Up to this point, you’ve mostly learned about the base assignment syntax in the above code snippet. In the following sections, you’ll learn about multiple, parallel, and augmented assignments. You’ll also learn about assignments with iterable unpacking.

Read on to see the assignment statements in action!

Assignment Statements in Action

You’ll find and use assignment statements everywhere in your Python code. They’re a fundamental part of the language, providing an explicit way to create, initialize, and mutate variables.

You can use assignment statements with plain names, like number or counter . You can also use assignments in more complicated scenarios, such as with:

• Qualified attribute names , like user.name
• Indices and slices of mutable sequences, like a_list[i] and a_list[i:j]
• Dictionary keys , like a_dict[key]

This list isn’t exhaustive. However, it gives you some idea of how flexible these statements are. You can even assign multiple values to an equal number of variables in a single line, commonly known as parallel assignment . Additionally, you can simultaneously assign the values in an iterable to a comma-separated group of variables in what’s known as an iterable unpacking operation.

In the following sections, you’ll dive deeper into all these topics and a few other exciting things that you can do with assignment statements in Python.

The most elementary use case of an assignment statement is to create a new variable and initialize it using a particular value or expression:

All these statements create new variables, assigning them initial values or expressions. For an initial value, you should always use the most sensible and least surprising value that you can think of. For example, initializing a counter to something different from 0 may be confusing and unexpected because counters almost always start having counted no objects.

Updating a variable’s current value or state is another common use case of assignment statements. In Python, assigning a new value to an existing variable doesn’t modify the variable’s current value. Instead, it causes the variable to refer to a different value. The previous value will be garbage-collected if no other variable refers to it.

Consider the following examples:

These examples run two consecutive assignments on the same variable. The first one assigns the string "Hello, World!" to a new variable named greeting .

The second assignment updates the value of greeting by reassigning it the "Hi, Pythonistas!" string. In this example, the original value of greeting —the "Hello, World!" string— is lost and garbage-collected. From this point on, you can’t access the old "Hello, World!" string.

Even though running multiple assignments on the same variable during a program’s execution is common practice, you should use this feature with caution. Changing the value of a variable can make your code difficult to read, understand, and debug. To comprehend the code fully, you’ll have to remember all the places where the variable was changed and the sequential order of those changes.

Because assignments also define the data type of their target variables, it’s also possible for your code to accidentally change the type of a given variable at runtime. A change like this can lead to breaking errors, like AttributeError exceptions. Remember that strings don’t have the same methods and attributes as lists or dictionaries, for example.

In Python, you can make several variables reference the same object in a multiple-assignment line. This can be useful when you want to initialize several similar variables using the same initial value:

In this example, you chain two assignment operators in a single line. This way, your two variables refer to the same initial value of 0 . Note how both variables hold the same memory address, so they point to the same instance of 0 .

When it comes to integer variables, Python exhibits a curious behavior. It provides a numeric interval where multiple assignments behave the same as independent assignments. Consider the following examples:

To create n and m , you use independent assignments. Therefore, they should point to different instances of the number 42 . However, both variables hold the same object, which you confirm by comparing their corresponding memory addresses.

Now check what happens when you use a greater initial value:

Now n and m hold different memory addresses, which means they point to different instances of the integer number 300 . In contrast, when you use multiple assignments, both variables refer to the same object. This tiny difference can save you small bits of memory if you frequently initialize integer variables in your code.

The implicit behavior of making independent assignments point to the same integer number is actually an optimization called interning . It consists of globally caching the most commonly used integer values in day-to-day programming.

Under the hood, Python defines a numeric interval in which interning takes place. That’s the interning interval for integer numbers. You can determine this interval using a small script like the following:

This script helps you determine the interning interval by comparing integer numbers from -10 to 500 . If you run the script from your command line, then you’ll get an output like the following:

This output means that if you use a single number between -5 and 256 to initialize several variables in independent statements, then all these variables will point to the same object, which will help you save small bits of memory in your code.

In contrast, if you use a number that falls outside of the interning interval, then your variables will point to different objects instead. Each of these objects will occupy a different memory spot.

You can use the assignment operator to mutate the value stored at a given index in a Python list. The operator also works with list slices . The syntax to write these types of assignment statements is the following:

In the first construct, expression can return any Python object, including another list. In the second construct, expression must return a series of values as a list, tuple, or any other sequence. You’ll get a TypeError if expression returns a single value.

Note: When creating slice objects, you can use up to three arguments. These arguments are start , stop , and step . They define the number that starts the slice, the number at which the slicing must stop retrieving values, and the step between values.

Here’s an example of updating an individual value in a list:

In this example, you update the value at index 2 using an assignment statement. The original number at that index was 7 , and after the assignment, the number is 3 .

Note: Using indices and the assignment operator to update a value in a tuple or a character in a string isn’t possible because tuples and strings are immutable data types in Python.

Their immutability means that you can’t change their items in place :

You can’t use the assignment operator to change individual items in tuples or strings. These data types are immutable and don’t support item assignments.

It’s important to note that you can’t add new values to a list by using indices that don’t exist in the target list:

In this example, you try to add a new value to the end of numbers by using an index that doesn’t exist. This assignment isn’t allowed because there’s no way to guarantee that new indices will be consecutive. If you ever want to add a single value to the end of a list, then use the .append() method.

If you want to update several consecutive values in a list, then you can use slicing and an assignment statement:

In the first example, you update the letters between indices 1 and 3 without including the letter at 3 . The second example updates the letters from index 3 until the end of the list. Note that this slicing appends a new value to the list because the target slice is shorter than the assigned values.

Also note that the new values were provided through a tuple, which means that this type of assignment allows you to use other types of sequences to update your target list.

The third example updates a single value using a slice where both indices are equal. In this example, the assignment inserts a new item into your target list.

In the final example, you use a step of 2 to replace alternating letters with their lowercase counterparts. This slicing starts at index 1 and runs through the whole list, stepping by two items each time.

Updating the value of an existing key or adding new key-value pairs to a dictionary is another common use case of assignment statements. To do these operations, you can use the following syntax:

The first construct helps you update the current value of an existing key, while the second construct allows you to add a new key-value pair to the dictionary.

For example, to update an existing key, you can do something like this:

In this example, you update the current inventory of oranges in your store using an assignment. The left operand is the existing dictionary key, and the right operand is the desired new value.

While you can’t add new values to a list by assignment, dictionaries do allow you to add new key-value pairs using the assignment operator. In the example below, you add a lemon key to inventory :

In this example, you successfully add a new key-value pair to your inventory with 100 units. This addition is possible because dictionaries don’t have consecutive indices but unique keys, which are safe to add by assignment.

The assignment statement does more than assign the result of a single expression to a single variable. It can also cope nicely with assigning multiple values to multiple variables simultaneously in what’s known as a parallel assignment .

Here’s the general syntax for parallel assignments in Python:

Note that the left side of the statement can be either a tuple or a list of variables. Remember that to create a tuple, you just need a series of comma-separated elements. In this case, these elements must be variables.

The right side of the statement must be a sequence or iterable of values or expressions. In any case, the number of elements in the right operand must match the number of variables on the left. Otherwise, you’ll get a ValueError exception.

In the following example, you compute the two solutions of a quadratic equation using a parallel assignment:

In this example, you first import sqrt() from the math module. Then you initialize the equation’s coefficients in a parallel assignment.

The equation’s solution is computed in another parallel assignment. The left operand contains a tuple of two variables, x1 and x2 . The right operand consists of a tuple of expressions that compute the solutions for the equation. Note how each result is assigned to each variable by position.

A classical use case of parallel assignment is to swap values between variables:

The highlighted line does the magic and swaps the values of previous_value and next_value at the same time. Note that in a programming language that doesn’t support this kind of assignment, you’d have to use a temporary variable to produce the same effect:

In this example, instead of using parallel assignment to swap values between variables, you use a new variable to temporarily store the value of previous_value to avoid losing its reference.

For a concrete example of when you’d need to swap values between variables, say you’re learning how to implement the bubble sort algorithm , and you come up with the following function:

In the highlighted line, you use a parallel assignment to swap values in place if the current value is less than the next value in the input list. To dive deeper into the bubble sort algorithm and into sorting algorithms in general, check out Sorting Algorithms in Python .

You can use assignment statements for iterable unpacking in Python. Unpacking an iterable means assigning its values to a series of variables one by one. The iterable must be the right operand in the assignment, while the variables must be the left operand.

Like in parallel assignments, the variables must come as a tuple or list. The number of variables must match the number of values in the iterable. Alternatively, you can use the unpacking operator ( * ) to grab several values in a variable if the number of variables doesn’t match the iterable length.

Here’s the general syntax for iterable unpacking in Python:

Iterable unpacking is a powerful feature that you can use all around your code. It can help you write more readable and concise code. For example, you may find yourself doing something like this:

Whenever you do something like this in your code, go ahead and replace it with a more readable iterable unpacking using a single and elegant assignment, like in the following code snippet:

The numbers list on the right side contains four values. The assignment operator unpacks these values into the four variables on the left side of the statement. The values in numbers get assigned to variables in the same order that they appear in the iterable. The assignment is done by position.

Note: Because Python sets are also iterables, you can use them in an iterable unpacking operation. However, it won’t be clear which value goes to which variable because sets are unordered data structures.

The above example shows the most common form of iterable unpacking in Python. The main condition for the example to work is that the number of variables matches the number of values in the iterable.

What if you don’t know the iterable length upfront? Will the unpacking work? It’ll work if you use the * operator to pack several values into one of your target variables.

For example, say that you want to unpack the first and second values in numbers into two different variables. Additionally, you would like to pack the rest of the values in a single variable conveniently called rest . In this case, you can use the unpacking operator like in the following code:

In this example, first and second hold the first and second values in numbers , respectively. These values are assigned by position. The * operator packs all the remaining values in the input iterable into rest .

The unpacking operator ( * ) can appear at any position in your series of target variables. However, you can only use one instance of the operator:

The iterable unpacking operator works in any position in your list of variables. Note that you can only use one unpacking operator per assignment. Using more than one unpacking operator isn’t allowed and raises a SyntaxError .

Dropping away unwanted values from the iterable is a common use case for the iterable unpacking operator. Consider the following example:

In Python, if you want to signal that a variable won’t be used, then you use an underscore ( _ ) as the variable’s name. In this example, useful holds the only value that you need to use from the input iterable. The _ variable is a placeholder that guarantees that the unpacking works correctly. You won’t use the values that end up in this disposable variable.

Note: In the example above, if your target iterable is a sequence data type, such as a list or tuple, then it’s best to access its last item directly.

To do this, you can use the -1 index:

Using -1 gives you access to the last item of any sequence data type. In contrast, if you’re dealing with iterators , then you won’t be able to use indices. That’s when the *_ syntax comes to your rescue.

The pattern used in the above example comes in handy when you have a function that returns multiple values, and you only need a few of these values in your code. The os.walk() function may provide a good example of this situation.

This function allows you to iterate over the content of a directory recursively. The function returns a generator object that yields three-item tuples. Each tuple contains the following items:

• The path to the current directory as a string
• The names of all the immediate subdirectories as a list of strings
• The names of all the files in the current directory as a list of strings

Now say that you want to iterate over your home directory and list only the files. You can do something like this:

This code will issue a long output depending on the current content of your home directory. Note that you need to provide a string with the path to your user folder for the example to work. The _ placeholder variable will hold the unwanted data.

In contrast, the filenames variable will hold the list of files in the current directory, which is the data that you need. The code will print the list of filenames. Go ahead and give it a try!

The assignment operator also comes in handy when you need to provide default argument values in your functions and methods. Default argument values allow you to define functions that take arguments with sensible defaults. These defaults allow you to call the function with specific values or to simply rely on the defaults.

As an example, consider the following function:

This function takes one argument, called name . This argument has a sensible default value that’ll be used when you call the function without arguments. To provide this sensible default value, you use an assignment.

Note: According to PEP 8 , the style guide for Python code, you shouldn’t use spaces around the assignment operator when providing default argument values in function definitions.

Here’s how the function works:

If you don’t provide a name during the call to greet() , then the function uses the default value provided in the definition. If you provide a name, then the function uses it instead of the default one.

Up to this point, you’ve learned a lot about the Python assignment operator and how to use it for writing different types of assignment statements. In the following sections, you’ll dive into a great feature of assignment statements in Python. You’ll learn about augmented assignments .

Augmented Assignment Operators in Python

Python supports what are known as augmented assignments . An augmented assignment combines the assignment operator with another operator to make the statement more concise. Most Python math and bitwise operators have an augmented assignment variation that looks something like this:

Note that $ isn’t a valid Python operator. In this example, it’s a placeholder for a generic operator. This statement works as follows:

• Evaluate expression to produce a value.
• Run the operation defined by the operator that prefixes the = sign, using the previous value of variable and the return value of expression as operands.
• Assign the resulting value back to variable .

In practice, an augmented assignment like the above is equivalent to the following statement:

As you can conclude, augmented assignments are syntactic sugar . They provide a shorthand notation for a specific and popular kind of assignment.

For example, say that you need to define a counter variable to count some stuff in your code. You can use the += operator to increment counter by 1 using the following code:

In this example, the += operator, known as augmented addition , adds 1 to the previous value in counter each time you run the statement counter += 1 .

It’s important to note that unlike regular assignments, augmented assignments don’t create new variables. They only allow you to update existing variables. If you use an augmented assignment with an undefined variable, then you get a NameError :

Python evaluates the right side of the statement before assigning the resulting value back to the target variable. In this specific example, when Python tries to compute x + 1 , it finds that x isn’t defined.

Great! You now know that an augmented assignment consists of combining the assignment operator with another operator, like a math or bitwise operator. To continue this discussion, you’ll learn which math operators have an augmented variation in Python.

An equation like x = x + b doesn’t make sense in math. But in programming, a statement like x = x + b is perfectly valid and can be extremely useful. It adds b to x and reassigns the result back to x .

As you already learned, Python provides an operator to shorten x = x + b . Yes, the += operator allows you to write x += b instead. Python also offers augmented assignment operators for most math operators. Here’s a summary:

The Example column provides generic examples of how to use the operators in actual code. Note that x must be previously defined for the operators to work correctly. On the other hand, y can be either a concrete value or an expression that returns a value.

Note: The matrix multiplication operator ( @ ) doesn’t support augmented assignments yet.

Consider the following example of matrix multiplication using NumPy arrays:

Note that the exception traceback indicates that the operation isn’t supported yet.

To illustrate how augmented assignment operators work, say that you need to create a function that takes an iterable of numeric values and returns their sum. You can write this function like in the code below:

In this function, you first initialize total to 0 . In each iteration, the loop adds a new number to total using the augmented addition operator ( += ). When the loop terminates, total holds the sum of all the input numbers. Variables like total are known as accumulators . The += operator is typically used to update accumulators.

Note: Computing the sum of a series of numeric values is a common operation in programming. Python provides the built-in sum() function for this specific computation.

Another interesting example of using an augmented assignment is when you need to implement a countdown while loop to reverse an iterable. In this case, you can use the -= operator:

In this example, custom_reversed() is a generator function because it uses yield . Calling the function creates an iterator that yields items from the input iterable in reverse order. To decrement the control variable, index , you use an augmented subtraction statement that subtracts 1 from the variable in every iteration.

Note: Similar to summing the values in an iterable, reversing an iterable is also a common requirement. Python provides the built-in reversed() function for this specific computation, so you don’t have to implement your own. The above example only intends to show the -= operator in action.

Finally, counters are a special type of accumulators that allow you to count objects. Here’s an example of a letter counter:

To create this counter, you use a Python dictionary. The keys store the letters. The values store the counts. Again, to increment the counter, you use an augmented addition.

Counters are so common in programming that Python provides a tool specially designed to facilitate the task of counting. Check out Python’s Counter: The Pythonic Way to Count Objects for a complete guide on how to use this tool.

The += and *= augmented assignment operators also work with sequences , such as lists, tuples, and strings. The += operator performs augmented concatenations , while the *= operator performs augmented repetition .

These operators behave differently with mutable and immutable data types:

Note that the augmented concatenation operator operates on two sequences, while the augmented repetition operator works on a sequence and an integer number.

Consider the following examples and pay attention to the result of calling the id() function:

Mutable sequences like lists support the += augmented assignment operator through the .__iadd__() method, which performs an in-place addition. This method mutates the underlying list, appending new values to its end.

Note: If the left operand is mutable, then x += y may not be completely equivalent to x = x + y . For example, if you do list_1 = list_1 + list_2 instead of list_1 += list_2 above, then you’ll create a new list instead of mutating the existing one. This may be important if other variables refer to the same list.

Immutable sequences, such as tuples and strings, don’t provide an .__iadd__() method. Therefore, augmented concatenations fall back to the .__add__() method, which doesn’t modify the sequence in place but returns a new sequence.

There’s another difference between mutable and immutable sequences when you use them in an augmented concatenation. Consider the following examples:

With mutable sequences, the data to be concatenated can come as a list, tuple, string, or any other iterable. In contrast, with immutable sequences, the data can only come as objects of the same type. You can concatenate tuples to tuples and strings to strings, for example.

Again, the augmented repetition operator works with a sequence on the left side of the operator and an integer on the right side. This integer value represents the number of repetitions to get in the resulting sequence:

When the *= operator operates on a mutable sequence, it falls back to the .__imul__() method, which performs the operation in place, modifying the underlying sequence. In contrast, if *= operates on an immutable sequence, then .__mul__() is called, returning a new sequence of the same type.

Note: Values of n less than 0 are treated as 0 , which returns an empty sequence of the same data type as the target sequence on the left side of the *= operand.

Note that a_list[0] is a_list[3] returns True . This is because the *= operator doesn’t make a copy of the repeated data. It only reflects the data. This behavior can be a source of issues when you use the operator with mutable values.

For example, say that you want to create a list of lists to represent a matrix, and you need to initialize the list with n empty lists, like in the following code:

In this example, you use the *= operator to populate matrix with three empty lists. Now check out what happens when you try to populate the first sublist in matrix :

The appended values are reflected in the three sublists. This happens because the *= operator doesn’t make copies of the data that you want to repeat. It only reflects the data. Therefore, every sublist in matrix points to the same object and memory address.

If you ever need to initialize a list with a bunch of empty sublists, then use a list comprehension :

This time, when you populate the first sublist of matrix , your changes aren’t propagated to the other sublists. This is because all the sublists are different objects that live in different memory addresses.

Bitwise operators also have their augmented versions. The logic behind them is similar to that of the math operators. The following table summarizes the augmented bitwise operators that Python provides:

The augmented bitwise assignment operators perform the intended operation by taking the current value of the left operand as a starting point for the computation. Consider the following example, which uses the & and &= operators:

Programmers who work with high-level languages like Python rarely use bitwise operations in day-to-day coding. However, these types of operations can be useful in some situations.

For example, say that you’re implementing a Unix-style permission system for your users to access a given resource. In this case, you can use the characters "r" for reading, "w" for writing, and "x" for execution permissions, respectively. However, using bit-based permissions could be more memory efficient:

You can assign permissions to your users with the OR bitwise operator or the augmented OR bitwise operator. Finally, you can use the bitwise AND operator to check if a user has a certain permission, as you did in the final two examples.

You’ve learned a lot about augmented assignment operators and statements in this and the previous sections. These operators apply to math, concatenation, repetition, and bitwise operations. Now you’re ready to look at other assignment variants that you can use in your code or find in other developers’ code.

Other Assignment Variants

So far, you’ve learned that Python’s assignment statements and the assignment operator are present in many different scenarios and use cases. Those use cases include variable creation and initialization, parallel assignments, iterable unpacking, augmented assignments, and more.

In the following sections, you’ll learn about a few variants of assignment statements that can be useful in your future coding. You can also find these assignment variants in other developers’ code. So, you should be aware of them and know how they work in practice.

In short, you’ll learn about:

• Annotated assignment statements with type hints
• Assignment expressions with the walrus operator
• Managed attribute assignments with properties and descriptors
• Implicit assignments in Python

These topics will take you through several interesting and useful examples that showcase the power of Python’s assignment statements.

PEP 526 introduced a dedicated syntax for variable annotation back in Python 3.6 . The syntax consists of the variable name followed by a colon ( : ) and the variable type:

Even though these statements declare three variables with their corresponding data types, the variables aren’t actually created or initialized. So, for example, you can’t use any of these variables in an augmented assignment statement:

If you try to use one of the previously declared variables in an augmented assignment, then you get a NameError because the annotation syntax doesn’t define the variable. To actually define it, you need to use an assignment.

The good news is that you can use the variable annotation syntax in an assignment statement with the = operator:

The first statement in this example is what you can call an annotated assignment statement in Python. You may ask yourself why you should use type annotations in this type of assignment if everybody can see that counter holds an integer number. You’re right. In this example, the variable type is unambiguous.

However, imagine what would happen if you found a variable initialization like the following:

What would be the data type of each user in users ? If the initialization of users is far away from the definition of the User class, then there’s no quick way to answer this question. To clarify this ambiguity, you can provide the appropriate type hint for users :

Now you’re clearly communicating that users will hold a list of User instances. Using type hints in assignment statements that initialize variables to empty collection data types—such as lists, tuples, or dictionaries—allows you to provide more context about how your code works. This practice will make your code more explicit and less error-prone.

Up to this point, you’ve learned that regular assignment statements with the = operator don’t have a return value. They just create or update variables. Therefore, you can’t use a regular assignment to assign a value to a variable within the context of an expression.

Python 3.8 changed this by introducing a new type of assignment statement through PEP 572 . This new statement is known as an assignment expression or named expression .

Note: Expressions are a special type of statement in Python. Their distinguishing characteristic is that expressions always have a return value, which isn’t the case with all types of statements.

Unlike regular assignments, assignment expressions have a return value, which is why they’re called expressions in the first place. This return value is automatically assigned to a variable. To write an assignment expression, you must use the walrus operator ( := ), which was named for its resemblance to the eyes and tusks of a walrus lying on its side.

The general syntax of an assignment statement is as follows:

This expression looks like a regular assignment. However, instead of using the assignment operator ( = ), it uses the walrus operator ( := ). For the expression to work correctly, the enclosing parentheses are required in most use cases. However, there are certain situations in which these parentheses are superfluous. Either way, they won’t hurt you.

Assignment expressions come in handy when you want to reuse the result of an expression or part of an expression without using a dedicated assignment to grab this value beforehand.

Note: Assignment expressions with the walrus operator have several practical use cases. They also have a few restrictions. For example, they’re illegal in certain contexts, such as lambda functions, parallel assignments, and augmented assignments.

For a deep dive into this special type of assignment, check out The Walrus Operator: Python’s Assignment Expressions .

A particularly handy use case for assignment expressions is when you need to grab the result of an expression used in the context of a conditional statement. For example, say that you need to write a function to compute the mean of a sample of numeric values. Without the walrus operator, you could do something like this:

In this example, the sample size ( n ) is a value that you need to reuse in two different computations. First, you need to check whether the sample has data points or not. Then you need to use the sample size to compute the mean. To be able to reuse n , you wrote a dedicated assignment statement at the beginning of your function to grab the sample size.

You can avoid this extra step by combining it with the first use of the target value, len(sample) , using an assignment expression like the following:

The assignment expression introduced in the conditional computes the sample size and assigns it to n . This way, you guarantee that you have a reference to the sample size to use in further computations.

Because the assignment expression returns the sample size anyway, the conditional can check whether that size equals 0 or not and then take a certain course of action depending on the result of this check. The return statement computes the sample’s mean and sends the result back to the function caller.

Python provides a few tools that allow you to fine-tune the operations behind the assignment of attributes. The attributes that run implicit operations on assignments are commonly referred to as managed attributes .

Properties are the most commonly used tool for providing managed attributes in your classes. However, you can also use descriptors and, in some cases, the .__setitem__() special method.

To understand what fine-tuning the operation behind an assignment means, say that you need a Point class that only allows numeric values for its coordinates, x and y . To write this class, you must set up a validation mechanism to reject non-numeric values. You can use properties to attach the validation functionality on top of x and y .

Here’s how you can write your class:

In Point , you use properties for the .x and .y coordinates. Each property has a getter and a setter method . The getter method returns the attribute at hand. The setter method runs the input validation using a try … except block and the built-in float() function. Then the method assigns the result to the actual attribute.

Here’s how your class works in practice:

When you use a property-based attribute as the left operand in an assignment statement, Python automatically calls the property’s setter method, running any computation from it.

Because both .x and .y are properties, the input validation runs whenever you assign a value to either attribute. In the first example, the input values are valid numbers and the validation passes. In the final example, "one" isn’t a valid numeric value, so the validation fails.

If you look at your Point class, you’ll note that it follows a repetitive pattern, with the getter and setter methods looking quite similar. To avoid this repetition, you can use a descriptor instead of a property.

A descriptor is a class that implements the descriptor protocol , which consists of four special methods :

• .__get__() runs when you access the attribute represented by the descriptor.
• .__set__() runs when you use the attribute in an assignment statement.
• .__delete__() runs when you use the attribute in a del statement.
• .__set_name__() sets the attribute’s name, creating a name-aware attribute.

Here’s how your code may look if you use a descriptor to represent the coordinates of your Point class:

You’ve removed repetitive code by defining Coordinate as a descriptor that manages the input validation in a single place. Go ahead and run the following code to try out the new implementation of Point :

Great! The class works as expected. Thanks to the Coordinate descriptor, you now have a more concise and non-repetitive version of your original code.

Another way to fine-tune the operations behind an assignment statement is to provide a custom implementation of .__setitem__() in your class. You’ll use this method in classes representing mutable data collections, such as custom list-like or dictionary-like classes.

As an example, say that you need to create a dictionary-like class that stores its keys in lowercase letters:

In this example, you create a dictionary-like class by subclassing UserDict from collections . Your class implements a .__setitem__() method, which takes key and value as arguments. The method uses str.lower() to convert key into lowercase letters before storing it in the underlying dictionary.

Python implicitly calls .__setitem__() every time you use a key as the left operand in an assignment statement. This behavior allows you to tweak how you process the assignment of keys in your custom dictionary.

Implicit Assignments in Python

Python implicitly runs assignments in many different contexts. In most cases, these implicit assignments are part of the language syntax. In other cases, they support specific behaviors.

Whenever you complete an action in the following list, Python runs an implicit assignment for you:

• Define or call a function
• Define or instantiate a class
• Use the current instance , self
• Import modules and objects
• Use a decorator
• Use the control variable in a for loop or a comprehension
• Use the as qualifier in with statements , imports, and try … except blocks
• Access the _ special variable in an interactive session

Behind the scenes, Python performs an assignment in every one of the above situations. In the following subsections, you’ll take a tour of all these situations.

When you define a function, the def keyword implicitly assigns a function object to your function’s name. Here’s an example:

From this point on, the name greet refers to a function object that lives at a given memory address in your computer. You can call the function using its name and a pair of parentheses with appropriate arguments. This way, you can reuse greet() wherever you need it.

If you call your greet() function with fellow as an argument, then Python implicitly assigns the input argument value to the name parameter on the function’s definition. The parameter will hold a reference to the input arguments.

When you define a class with the class keyword, you’re assigning a specific name to a class object . You can later use this name to create instances of that class. Consider the following example:

In this example, the name User holds a reference to a class object, which was defined in __main__.User . Like with a function, when you call the class’s constructor with the appropriate arguments to create an instance, Python assigns the arguments to the parameters defined in the class initializer .

Another example of implicit assignments is the current instance of a class, which in Python is called self by convention. This name implicitly gets a reference to the current object whenever you instantiate a class. Thanks to this implicit assignment, you can access .name and .job from within the class without getting a NameError in your code.

Import statements are another variant of implicit assignments in Python. Through an import statement, you assign a name to a module object, class, function, or any other imported object. This name is then created in your current namespace so that you can access it later in your code:

In this example, you import the sys module object from the standard library and assign it to the sys name, which is now available in your namespace, as you can conclude from the second call to the built-in dir() function.

You also run an implicit assignment when you use a decorator in your code. The decorator syntax is just a shortcut for a formal assignment like the following:

Here, you call decorator() with a function object as an argument. This call will typically add functionality on top of the existing function, func() , and return a function object, which is then reassigned to the func name.

The decorator syntax is syntactic sugar for replacing the previous assignment, which you can now write as follows:

Even though this new code looks pretty different from the above assignment, the code implicitly runs the same steps.

Another situation in which Python automatically runs an implicit assignment is when you use a for loop or a comprehension. In both cases, you can have one or more control variables that you then use in the loop or comprehension body:

The memory address of control_variable changes on each iteration of the loop. This is because Python internally reassigns a new value from the loop iterable to the loop control variable on each cycle.

The same behavior appears in comprehensions:

In the end, comprehensions work like for loops but use a more concise syntax. This comprehension creates a new list of strings that mimic the output from the previous example.

The as keyword in with statements, except clauses, and import statements is another example of an implicit assignment in Python. This time, the assignment isn’t completely implicit because the as keyword provides an explicit way to define the target variable.

In a with statement, the target variable that follows the as keyword will hold a reference to the context manager that you’re working with. As an example, say that you have a hello.txt file with the following content:

You want to open this file and print each of its lines on your screen. In this case, you can use the with statement to open the file using the built-in open() function.

In the example below, you accomplish this. You also add some calls to print() that display information about the target variable defined by the as keyword:

This with statement uses the open() function to open hello.txt . The open() function is a context manager that returns a text file object represented by an io.TextIOWrapper instance.

Since you’ve defined a hello target variable with the as keyword, now that variable holds a reference to the file object itself. You confirm this by printing the object and its memory address. Finally, the for loop iterates over the lines and prints this content to the screen.

When it comes to using the as keyword in the context of an except clause, the target variable will contain an exception object if any exception occurs:

In this example, you run a division that raises a ZeroDivisionError . The as keyword assigns the raised exception to error . Note that when you print the exception object, you get only the message because exceptions have a custom .__str__() method that supports this behavior.

There’s a final detail to remember when using the as specifier in a try … except block like the one in the above example. Once you leave the except block, the target variable goes out of scope , and you can’t use it anymore.

Finally, Python’s import statements also support the as keyword. In this context, you can use as to import objects with a different name:

In these examples, you use the as keyword to import the numpy package with the np name and pandas with the name pd . If you call dir() , then you’ll realize that np and pd are now in your namespace. However, the numpy and pandas names are not.

Using the as keyword in your imports comes in handy when you want to use shorter names for your objects or when you need to use different objects that originally had the same name in your code. It’s also useful when you want to make your imported names non-public using a leading underscore, like in import sys as _sys .

The final implicit assignment that you’ll learn about in this tutorial only occurs when you’re using Python in an interactive session. Every time you run a statement that returns a value, the interpreter stores the result in a special variable denoted by a single underscore character ( _ ).

You can access this special variable as you’d access any other variable:

These examples cover several situations in which Python internally uses the _ variable. The first two examples evaluate expressions. Expressions always have a return value, which is automatically assigned to the _ variable every time.

When it comes to function calls, note that if your function returns a fruitful value, then _ will hold it. In contrast, if your function returns None , then the _ variable will remain untouched.

The next example consists of a regular assignment statement. As you already know, regular assignments don’t return any value, so the _ variable isn’t updated after these statements run. Finally, note that accessing a variable in an interactive session returns the value stored in the target variable. This value is then assigned to the _ variable.

Note that since _ is a regular variable, you can use it in other expressions:

In this example, you first create a list of values. Then you call len() to get the number of values in the list. Python automatically stores this value in the _ variable. Finally, you use _ to compute the mean of your list of values.

Now that you’ve learned about some of the implicit assignments that Python runs under the hood, it’s time to dig into a final assignment-related topic. In the following few sections, you’ll learn about some illegal and dangerous assignments that you should be aware of and avoid in your code.

Illegal and Dangerous Assignments in Python

In Python, you’ll find a few situations in which using assignments is either forbidden or dangerous. You must be aware of these special situations and try to avoid them in your code.

In the following sections, you’ll learn when using assignment statements isn’t allowed in Python. You’ll also learn about some situations in which using assignments should be avoided if you want to keep your code consistent and robust.

You can’t use Python keywords as variable names in assignment statements. This kind of assignment is explicitly forbidden. If you try to use a keyword as a variable name in an assignment, then you get a SyntaxError :

Whenever you try to use a keyword as the left operand in an assignment statement, you get a SyntaxError . Keywords are an intrinsic part of the language and can’t be overridden.

If you ever feel the need to name one of your variables using a Python keyword, then you can append an underscore to the name of your variable:

In this example, you’re using the desired name for your variables. Because you added a final underscore to the names, Python doesn’t recognize them as keywords, so it doesn’t raise an error.

Note: Even though adding an underscore at the end of a name is an officially recommended practice , it can be confusing sometimes. Therefore, try to find an alternative name or use a synonym whenever you find yourself using this convention.

For example, you can write something like this:

In this example, using the name booking_class for your variable is way clearer and more descriptive than using class_ .

You’ll also find that you can use only a few keywords as part of the right operand in an assignment statement. Those keywords will generally define simple statements that return a value or object. These include lambda , and , or , not , True , False , None , in , and is . You can also use the for keyword when it’s part of a comprehension and the if keyword when it’s used as part of a ternary operator .

In an assignment, you can never use a compound statement as the right operand. Compound statements are those that require an indented block, such as for and while loops, conditionals, with statements, try … except blocks, and class or function definitions.

Sometimes, you need to name variables, but the desired or ideal name is already taken and used as a built-in name. If this is your case, think harder and find another name. Don’t shadow the built-in.

Shadowing built-in names can cause hard-to-identify problems in your code. A common example of this issue is using list or dict to name user-defined variables. In this case, you override the corresponding built-in names, which won’t work as expected if you use them later in your code.

Consider the following example:

The exception in this example may sound surprising. How come you can’t use list() to build a list from a call to map() that returns a generator of square numbers?

By using the name list to identify your list of numbers, you shadowed the built-in list name. Now that name points to a list object rather than the built-in class. List objects aren’t callable, so your code no longer works.

In Python, you’ll have nothing that warns against using built-in, standard-library, or even relevant third-party names to identify your own variables. Therefore, you should keep an eye out for this practice. It can be a source of hard-to-debug errors.

In programming, a constant refers to a name associated with a value that never changes during a program’s execution. Unlike other programming languages, Python doesn’t have a dedicated syntax for defining constants. This fact implies that Python doesn’t have constants in the strict sense of the word.

Python only has variables. If you need a constant in Python, then you’ll have to define a variable and guarantee that it won’t change during your code’s execution. To do that, you must avoid using that variable as the left operand in an assignment statement.

To tell other Python programmers that a given variable should be treated as a constant, you must write your variable’s name in capital letters with underscores separating the words. This naming convention has been adopted by the Python community and is a recommendation that you’ll find in the Constants section of PEP 8 .

In the following examples, you define some constants in Python:

The problem with these constants is that they’re actually variables. Nothing prevents you from changing their value during your code’s execution. So, at any time, you can do something like the following:

These assignments modify the value of two of your original constants. Python doesn’t complain about these changes, which can cause issues later in your code. As a Python developer, you must guarantee that named constants in your code remain constant.

The only way to do that is never to use named constants in an assignment statement other than the constant definition.

You’ve learned a lot about Python’s assignment operators and how to use them for writing assignment statements . With this type of statement, you can create, initialize, and update variables according to your needs. Now you have the required skills to fully manage the creation and mutation of variables in your Python code.

In this tutorial, you’ve learned how to:

• Write assignment statements using Python’s assignment operators
• Work with augmented assignments in Python
• Explore assignment variants, like assignment expression and managed attributes
• Identify illegal and dangerous assignments in Python

Learning about the Python assignment operator and how to use it in assignment statements is a fundamental skill in Python. It empowers you to write reliable and effective Python code.

🐍 Python Tricks 💌

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About Leodanis Pozo Ramos

Leodanis is an industrial engineer who loves Python and software development. He's a self-taught Python developer with 6+ years of experience. He's an avid technical writer with a growing number of articles published on Real Python and other sites.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

What Do You Think?

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal . Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session . Happy Pythoning!

Keep Learning

Related Topics: intermediate best-practices python

Related Tutorials:

• The Walrus Operator: Python's Assignment Expressions
• Operators and Expressions in Python
• Using and Creating Global Variables in Your Python Functions
• Iterators and Iterables in Python: Run Efficient Iterations
• The Python return Statement: Usage and Best Practices

Keep reading Real Python by creating a free account or signing in:

Already have an account? Sign-In

Almost there! Complete this form and click the button below to gain instant access:

Python's Assignment Operator: Write Robust Assignments (Source Code)

🔒 No spam. We take your privacy seriously.

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Assign function arguments to `self`

I've noticed that a common pattern I use is to assign SomeClass.__init__() arguments to self attributes of the same name. Example:

In fact it must be a common task for others as well as PyDev has a shortcut for this - if you place the cursor on the parameter list and click Ctrl+1 you're given the option to Assign parameters to attributes which will create that boilerplate code for you.

Is there a different, short and elegant way to perform this assignment?

• variable-assignment
• boilerplate
• function-parameter

• 8 personal opinion: boilerplate code such as this is a common indication of a missing language construct... –  Jonathan Livni Commented Dec 30, 2011 at 18:48
• 1 Yes you can do it with a decorator, but doing it explicitly will be better for you on the long run. Also it will not mess up PyDevs autocompletion if you do it explicitly –  ojii Commented Dec 30, 2011 at 19:05
• 16 Doing it manually builds character. –  derekerdmann Commented Dec 30, 2011 at 19:18
• 6 python.org/dev/peps/pep-0020 (in particular, "explicit is better than implicit", "simple is better than complex", "readability counts"). –  user97370 Commented Dec 30, 2011 at 19:20
• 1 Most of the constructor parameters my classes take shouldn't be copied into self under the same name without transformation. I make stuff private, validate values, normalize them, fill in mutable objects which would be default values if default arguments worked differently, etc. –  user395760 Commented Dec 30, 2011 at 19:48

10 Answers 10

You could do this, which has the virtue of simplicity:

This leaves it up to whatever code creates an instance of C to decide what the instance's attributes will be after construction, e.g.:

If you want all C objects to have a , b , and c attributes, this approach won't be useful.

(BTW, this pattern comes from Guido his own bad self, as a general solution to the problem of defining enums in Python. Create a class like the above called Enum , and then you can write code like Colors = Enum(Red=0, Green=1, Blue=2) , and henceforth use Colors.Red , Colors.Green , and Colors.Blue .)

It's a worthwhile exercise to figure out what kinds of problems you could have if you set self.__dict__ to kwargs instead of dict(kwargs) .

• 2 Can you add a link to Guido's discussion of this pattern and enums? –  Air Commented Apr 12, 2016 at 17:23
• This should be the top solution, specifically for its elegance and high probability of successful implementation. It functions correctly, is unlikely to behave unexpectedly, and takes only one---at most two---lines. –  TheLoneDeranger Commented Oct 15, 2018 at 16:14
• This is a very nice solution. In case explicit naming is desired, something like this can be done: def __init__(self, a, b, c): --> self.__dict__ = dict(vars()) –  Dave Commented Jan 11 at 14:08

I sympathize with your sense that boilerplate code is a bad thing. But in this case, I'm not sure there even could be a better alternative. Let's consider the possibilities.

If you're talking about just a few variables, then a series of self.x = x lines is easy to read. In fact, I think its explicitness makes that approach preferable from a readability standpoint. And while it might be a slight pain to type, that alone isn't quite enough to justify a new language construct that might obscure what's really going on. Certainly using vars(self).update() shenanigans would be more confusing than it's worth in this case.

On the other hand, if you're passing nine, ten, or more parameters to __init__ , you probably need to refactor anyway. So this concern really only applies to cases that involve passing, say, 5-8 parameters. Now I can see how eight lines of self.x = x would be annoying both to type and to read; but I'm not sure that the 5-8 parameter case is common enough or troublesome enough to justify using a different method. So I think that, while the concern you're raising is a good one in principle, in practice, there are other limiting issues that make it irrelevant.

To make this point more concrete, let's consider a function that takes an object, a dict, and a list of names, and assigns values from the dict to names from the list. This ensures that you're still being explicit about which variables are being assigned to self. (I would never suggest a solution to this problem that didn't call for an explicit enumeration of the variables to be assigned; that would be a rare-earth bug magnet):

Now, while not horribly unattractive, this is still harder to figure out than a straightforward series of self.x = x lines. And it's also longer and more trouble to type than one, two, and maybe even three or four lines, depending on circumstances. So you only get certain payoff starting with the five-parameter case. But that's also the exact moment that you begin to approach the limit on human short-term memory capacity (= 7 +/- 2 "chunks"). So in this case, your code is already a bit challenging to read, and this would only make it more challenging.

• Since we're talking about arbitrary numbers of attributes, in python3, using locals().keys() is much more efficient than listing then names of the attributes manually. ex: assignAttributes(self, vars(), locals().keys()) –  Skyler Commented Jun 13, 2018 at 15:00
• @Skyler, I think you may have missed my main premise. I specifically think it's a bad idea to name the attributes of a class implicitly. The names of attributes should be specified explicitly. It ensures a minimal standard of self-documentation. Have you ever tried to read code that does something like this? Not fun! –  senderle Commented Jun 13, 2018 at 15:07

Mod for @pcperini's answer:

• @ThiefMaster - removed the list comprehension. (you could give people a chance to correct their mistakes before taking action, guess this is true here as it is in life) –  Jonathan Livni Commented Jan 2, 2012 at 7:00
• 1 Votes can be changed for an indefinite period after the related answer/question has been edited ;) So there's nothing to say against downvoting+commenting and later removing the downvote and/or upvoting. –  ThiefMaster Commented Jan 2, 2012 at 11:51
• List comprehension version of the above: [ setattr(self, var[0], var[1]) for var in vars().items() if var[0] != "self" ] –  Seth Robertson Commented Jul 1, 2020 at 13:17

Your specific case could also be handled with a namedtuple :

Decorator magic!!

while defining:

Of course you could define this decorator once and use it throughout your project. Also, This decorator works on any object function, not only __init__ .

• python probably already has code somewhere that matches args,kwargs,defaults into locals() or vars() , so I could save on implementing it again in this decorator - I'm open for suggestions... –  Jonathan Livni Commented Dec 31, 2011 at 10:57
• btw, I believe that in most cases @senderle is right, however under certain circumstances this approach could be very convenient. A language construct could be even more elegant than this decorator, and also PyDev could support it thus not losing Ctrl+space functionality. Alas... –  Jonathan Livni Commented Dec 31, 2011 at 11:00
• This is exactly how it should be done! And I don't agree with @senderle completely. Yes If you have to many arguments, this is a hint for refactoring. But still it is tedious to type even a few, especially when they are quite long, and anyways it is all boilerplate code, which isn't really necessary. The only reason, why I will not use this decorator, is that it doesn't work well with the LSP of my editor. But I'm quite sure, that there will be a native language extension in the future. Other languages, like php, have it already. –  Lord Bo Commented Apr 29 at 17:46

You can do it via setattr(), like:

[setattr(self, key, value) for key, value in kwargs.items()]

Is not very beautiful, but can save some space :)

So, you'll get:

• True, but then I can't define the function's argument list, which in most cases is preferred –  Jonathan Livni Commented Dec 30, 2011 at 19:14
• 3 Why use a list comprehension rather than a loop? for key, value in kwargs.items(): setattr(self, key, value) is slightly shorter and yet more straightforward. I'd use iteritems() rather than items() in Py<3. –  user97370 Commented Dec 30, 2011 at 19:27
• 2 And for brevity, for a in kwargs.items(): setattr(self, *a) –  user97370 Commented Dec 30, 2011 at 19:28
• 3 -1 for using a list comprehension as a shortcut for a for-loop, this is not a good style and should not be promoted to new learners. (Creates a throwaway list of None s which are the return values from all the setattr calls, for no purpose.) –  PaulMcG Commented Dec 30, 2011 at 23:08
• 1 -1 too. For me it's uglier than simply assigning and you also loose which are the accepted attributes (added an answer explaining how to use a Bunch class which I think it's better). –  Fabio Zadrozny Commented Dec 31, 2011 at 23:14

For that simple use-case I must say I like putting things explicitly (using the Ctrl+1 from PyDev), but sometimes I also end up using a bunch implementation, but with a class where the accepted attributes are created from attributes pre-declared in the class, so that I know what's expected (and I like it more than a namedtuple as I find it more readable -- and it won't confuse static code analysis or code-completion).

I've put on a recipe for it at: http://code.activestate.com/recipes/577999-bunch-class-created-from-attributes-in-class/

The basic idea is that you declare your class as a subclass of Bunch and it'll create those attributes in the instance (either from default or from values passed in the constructor):

Also, Alex Martelli also provided a bunch implementation: http://code.activestate.com/recipes/52308-the-simple-but-handy-collector-of-a-bunch-of-named/ with the idea of updating the instance from the arguments, but that'll confuse static code-analysis (and IMO can make things harder to follow) so, I'd only use that approach for an instance that's created locally and thrown away inside that same scope without passing it anywhere else).

• Nice, although this solves specifically the __init__ case, whereas the decorator is more generic in this sense –  Jonathan Livni Commented Jan 1, 2012 at 10:05
• True, but I think that pattern is only common in the constructor and setter methods (but as setter methods usually have only 1 argument, changing the assign line for the decorator line only makes the come more unreadable to me). –  Fabio Zadrozny Commented Jan 1, 2012 at 14:04

I solved it for myself using locals() and __dict__ :

Do not use this: I was simply trying to create the answer closest to OPs initial intentions. As pointed out in comments, this relies on entirely undefined behavior , and explicitly prohibited modifications of the symbol table.

It does work though, and has been tested under extremely basic circumstances .

Using the vars() built-in function, this snippet iterates through all of the variables available in the __init__ method (which should, at this point, just be self , a , b , and c ) and set's self 's variables equal to the same, obviously ignoring the argument-reference to self (because self.self seemed like a poor decision.)

• 2 docs.python.org/library/functions.html#vars explicitly disallows modifying vars(). –  user97370 Commented Dec 30, 2011 at 19:18
• 1 disclaimer updated. i'm hesitant to take it down though, just because i feel it's a pretty cool answer :) –  Patrick Perini Commented Dec 30, 2011 at 19:22

One of the problems with @user3638162's answer is that locals() contain the 'self' variable. Hence, you end up with an extra self.self . If one doesn't mind the extra self, that solution can simply be

The self can be removed after construction by del self.__dict__['self']

Alternatively, one can remove the self during construction using dictionary comprehensions introduced in Python3

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged python variable-assignment boilerplate function-parameter or ask your own question .

• The Overflow Blog
• The world’s largest open-source business has plans for enhancing LLMs
• Featured on Meta
• User activation: Learnings and opportunities
• Site maintenance - Mon, Sept 16 2024, 21:00 UTC to Tue, Sept 17 2024, 2:00...
• What does a new user need in a homepage experience on Stack Overflow?
• Announcing the new Staging Ground Reviewer Stats Widget

Hot Network Questions

• What's the strongest material known to humanity that we could use to make Powered Armor Plates?
• Why does fdisk create a 512B partition when I enter +256K?
• Do carbon fiber wings need a wing spar?
• How to deal with coauthors who just do a lot of unnecessary work and exploration to be seen as hard-working and grab authorship?
• Offline autocue prog for Windows?
• Do black holes convert 100% of their mass into energy via Hawking radiation?
• Recover lost disk space (> 270 GB)
• crontab schedule on Alpine Linux does not seem to run on Sundays
• The consequence of a good letter of recommendation when things do not work out
• Could a Gamma Ray Burst knock a Space Mirror out of orbit?
• I have been trying to solve this Gaussian integral, which comes up during the perturbation theory
• If one is arrested, but has a baby/pet in their house, what are they supposed to do?
• How to make a soundless world
• The walk radical in Traditional Chinese
• How can we speed up the process of returning our lost luggage?
• ASCII 2D landscape
• Doesn't nonlocality follow from nonrealism in the EPR thought experiment and Bell tests?
• What properties of the fundamental group functor are needed to uniquely determine it upto natural isomorphism?
• Why is steaming food faster than boiling it?
• Conservation of energy in cosmological redshift
• Where are the DC-3 parked at KOPF?
• How to change my document's font
• Seeking a Text-Based Version of Paul Dirac's 1926 Paper on Quantum Mechanics
• Will there be Sanhedrin in Messianic Times?