definition of assignment operator in python

What is Assignment Operator in Python?

Before deep-diving into the assignment operators in Python, first, understand what operators are. So operators are used in between the operands to perform various operations, like mathematical operations , bitwise operations , logical operations , and so on. Here, operands are the values on which operators perform the actions. So, assignment operators are used to assigning values to the operands on the left-hand side. Assignment operators assign the right-hand side values to the operand that is present on the left-hand side. The assignment operator in Python is used as the "=" symbol.

Let’s see a very basic example of the assignment operator.

Table Of Assignment Operators

Here we will see different assignment operators in Python with their names, descriptions, and syntax. Let's take them one by one.

Assignment Operator :

This is an assignment operator in Python which assigns the right-hand side expression value to the operand present on the left-hand side.

Sample Code :

Addition Assignment Operator :

This type of assignment operator in Python adds left and right operands, and after that, it assigns the calculated value to the left-hand operand.

Subtraction Assignment Operator :

This operator subtracts the right operand from the left operand and assigns the result to the left operand.

Multiplication Assignment Operator:

This operator will multiply the left-hand side operand by the right-hand side operand and, after that, assign the result to the left-hand operand.

Division Assignment Operator :

This type of assignment operator in Python will divide the left-hand side operand from the right-hand side operand and, after that, assign the result to the left-hand operand.

Modulus Assignment Operator :

This operator will divide the left-hand side operand to the right-hand side operand and, after that, assign the reminder to the left-hand operand.

Click here, to learn more about modulus in python .

Exponentiation Assignment Operator :

This operator raises the left-side operand to the power of the right-side operand and assigns the result to the left-side value.

Floor Division Assignment Operator :

This operator will divide the left operand by the right operand and assign the quotient value (which would be in the form of an integer) to the left operand.

Bitwise AND Assignment Operator :

This operator will perform the bitwise operation on both the left and right operands and, after that, it will assign the resultant value to the left operand.

Bitwise OR Assignment Operator:

This operator will perform the bitwise or operation on both the left and right operands and, after that, it will assign the resultant value to the left operand.

Bitwise XOR Assignment Operator:

This operator will perform the bitwise XOR operation on the left and right operands and, after that, it will assign the resultant value to the left operand.

Bitwise Right Shift Assignment Operator :

This operator will right shift the left operand by the specified position, i.e., b , and after that, it will assign the resultant value to the left operand.

Bitwise Left Shift Assignment Operator:

This operator will left shift the left operand by the specified position, i.e., b , and after that, it will assign the resultant value to the left operand.

Assignment operators in Python assign the right-hand side values to the operand that is present on the left-hand side.
The assignment operators in Python is used as the "=" symbol.
We have different types of assignment operators like +=, -=, \*=, %=, /=, //=, \*\*=, &=, |=, ^=, >>=, <<= .
All the operators have the same precedence, and hence we prioritise operations based on their associativiy . The associativity is from right to left.

Learn More:

XOR in Python .

Assignment Operators

Add and assign, subtract and assign, multiply and assign, divide and assign, floor divide and assign, exponent and assign, modulo and assign.

For demonstration purposes, let’s use a single variable, num . Initially, we set num to 6. We can apply all of these operators to num and update it accordingly.

Assigning the value of 6 to num results in num being 6.

Expression: num = 6

Adding 3 to num and assigning the result back to num would result in 9.

Expression: num += 3

Subtracting 3 from num and assigning the result back to num would result in 6.

Expression: num -= 3

Multiplying num by 3 and assigning the result back to num would result in 18.

Expression: num *= 3

Dividing num by 3 and assigning the result back to num would result in 6.0 (always a float).

Expression: num /= 3

Performing floor division on num by 3 and assigning the result back to num would result in 2.

Expression: num //= 3

Raising num to the power of 3 and assigning the result back to num would result in 216.

Expression: num **= 3

Calculating the remainder when num is divided by 3 and assigning the result back to num would result in 2.

Expression: num %= 3

We can effectively put this into Python code, and you can experiment with the code yourself! Click the “Run” button to see the output.

The above code is useful when we want to update the same number. We can also use two different numbers and use the assignment operators to apply them on two different values.

PrepBytes Blog

ONE-STOP RESOURCE FOR EVERYTHING RELATED TO CODING

Sign in to your account

Forgot your password?

Login via OTP

We will send you an one time password on your mobile number

An OTP has been sent to your mobile number please verify it below

Register with PrepBytes

Assignment operator in python.

Last Updated on June 8, 2023 by Prepbytes

definition of assignment operator in python

To fully comprehend the assignment operators in Python, it is important to have a basic understanding of what operators are. Operators are utilized to carry out a variety of operations, including mathematical, bitwise, and logical operations, among others, by connecting operands. Operands are the values that are acted upon by operators. In Python, the assignment operator is used to assign a value to a variable. The assignment operator is represented by the equals sign (=), and it is the most commonly used operator in Python. In this article, we will explore the assignment operator in Python, how it works, and its different types.

What is an Assignment Operator in Python?

The assignment operator in Python is used to assign a value to a variable. The assignment operator is represented by the equals sign (=), and it is used to assign a value to a variable. When an assignment operator is used, the value on the right-hand side is assigned to the variable on the left-hand side. This is a fundamental operation in programming, as it allows developers to store data in variables that can be used throughout their code.

For example, consider the following line of code:

Explanation: In this case, the value 10 is assigned to the variable a using the assignment operator. The variable a now holds the value 10, and this value can be used in other parts of the code. This simple example illustrates the basic usage and importance of assignment operators in Python programming.

Types of Assignment Operator in Python

There are several types of assignment operator in Python that are used to perform different operations. Let’s explore each type of assignment operator in Python in detail with the help of some code examples.

1. Simple Assignment Operator (=)

The simple assignment operator is the most commonly used operator in Python. It is used to assign a value to a variable. The syntax for the simple assignment operator is:

Here, the value on the right-hand side of the equals sign is assigned to the variable on the left-hand side. For example

Explanation: In this case, the value 25 is assigned to the variable a using the simple assignment operator. The variable a now holds the value 25.

2. Addition Assignment Operator (+=)

The addition assignment operator is used to add a value to a variable and store the result in the same variable. The syntax for the addition assignment operator is:

Here, the value on the right-hand side is added to the variable on the left-hand side, and the result is stored back in the variable on the left-hand side. For example

Explanation: In this case, the value of a is incremented by 5 using the addition assignment operator. The result, 15, is then printed to the console.

3. Subtraction Assignment Operator (-=)

The subtraction assignment operator is used to subtract a value from a variable and store the result in the same variable. The syntax for the subtraction assignment operator is

Here, the value on the right-hand side is subtracted from the variable on the left-hand side, and the result is stored back in the variable on the left-hand side. For example

Explanation: In this case, the value of a is decremented by 5 using the subtraction assignment operator. The result, 5, is then printed to the console.

4. Multiplication Assignment Operator (*=)

The multiplication assignment operator is used to multiply a variable by a value and store the result in the same variable. The syntax for the multiplication assignment operator is:

Here, the value on the right-hand side is multiplied by the variable on the left-hand side, and the result is stored back in the variable on the left-hand side. For example

Explanation: In this case, the value of a is multiplied by 5 using the multiplication assignment operator. The result, 50, is then printed to the console.

5. Division Assignment Operator (/=)

The division assignment operator is used to divide a variable by a value and store the result in the same variable. The syntax for the division assignment operator is:

Here, the variable on the left-hand side is divided by the value on the right-hand side, and the result is stored back in the variable on the left-hand side. For example

Explanation: In this case, the value of a is divided by 5 using the division assignment operator. The result, 2.0, is then printed to the console.

6. Modulus Assignment Operator (%=)

The modulus assignment operator is used to find the remainder of the division of a variable by a value and store the result in the same variable. The syntax for the modulus assignment operator is

Here, the variable on the left-hand side is divided by the value on the right-hand side, and the remainder is stored back in the variable on the left-hand side. For example

Explanation: In this case, the value of a is divided by 3 using the modulus assignment operator. The remainder, 1, is then printed to the console.

7. Floor Division Assignment Operator (//=)

The floor division assignment operator is used to divide a variable by a value and round the result down to the nearest integer, and store the result in the same variable. The syntax for the floor division assignment operator is:

Here, the variable on the left-hand side is divided by the value on the right-hand side, and the result is rounded down to the nearest integer. The rounded result is then stored back in the variable on the left-hand side. For example

Explanation: In this case, the value of a is divided by 3 using the floor division assignment operator. The result, 3, is then printed to the console.

8. Exponentiation Assignment Operator (**=)

The exponentiation assignment operator is used to raise a variable to the power of a value and store the result in the same variable. The syntax for the exponentiation assignment operator is:

Here, the variable on the left-hand side is raised to the power of the value on the right-hand side, and the result is stored back in the variable on the left-hand side. For example

Explanation: In this case, the value of a is raised to the power of 3 using the exponentiation assignment operator. The result, 8, is then printed to the console.

9. Bitwise AND Assignment Operator (&=)

The bitwise AND assignment operator is used to perform a bitwise AND operation on the binary representation of a variable and a value, and store the result in the same variable. The syntax for the bitwise AND assignment operator is:

Here, the variable on the left-hand side is ANDed with the value on the right-hand side using the bitwise AND operator, and the result is stored back in the variable on the left-hand side. For example,

Explanation: In this case, the value of a is ANDed with 3 using the bitwise AND assignment operator. The result, 2, is then printed to the console.

10. Bitwise OR Assignment Operator (|=)

The bitwise OR assignment operator is used to perform a bitwise OR operation on the binary representation of a variable and a value, and store the result in the same variable. The syntax for the bitwise OR assignment operator is:

Here, the variable on the left-hand side is ORed with the value on the right-hand side using the bitwise OR operator, and the result is stored back in the variable on the left-hand side. For example,

Explanation: In this case, the value of a is ORed with 3 using the bitwise OR assignment operator. The result, 7, is then printed to the console.

11. Bitwise XOR Assignment Operator (^=)

The bitwise XOR assignment operator is used to perform a bitwise XOR operation on the binary representation of a variable and a value, and store the result in the same variable. The syntax for the bitwise XOR assignment operator is:

Here, the variable on the left-hand side is XORed with the value on the right-hand side using the bitwise XOR operator, and the result are stored back in the variable on the left-hand side. For example,

Explanation: In this case, the value of a is XORed with 3 using the bitwise XOR assignment operator. The result, 5, is then printed to the console.

12. Bitwise Right Shift Assignment Operator (>>=)

The bitwise right shift assignment operator is used to shift the bits of a variable to the right by a specified number of positions, and store the result in the same variable. The syntax for the bitwise right shift assignment operator is:

Here, the variable on the left-hand side has its bits shifted to the right by the number of positions specified by the value on the right-hand side, and the result is stored back in the variable on the left-hand side. For example,

Explanation: In this case, the value of a is shifted 2 positions to the right using the bitwise right shift assignment operator. The result, 2, is then printed to the console.

13. Bitwise Left Shift Assignment Operator (<<=)

The bitwise left shift assignment operator is used to shift the bits of a variable to the left by a specified number of positions, and store the result in the same variable. The syntax for the bitwise left shift assignment operator is:

Here, the variable on the left-hand side has its bits shifted to the left by the number of positions specified by the value on the right-hand side, and the result is stored back in the variable on the left-hand side. For example,

Conclusion Assignment operator in Python is used to assign values to variables, and it comes in different types. The simple assignment operator (=) assigns a value to a variable. The augmented assignment operators (+=, -=, *=, /=, %=, &=, |=, ^=, >>=, <<=) perform a specified operation and assign the result to the same variable in one step. The modulus assignment operator (%) calculates the remainder of a division operation and assigns the result to the same variable. The bitwise assignment operators (&=, |=, ^=, >>=, <<=) perform bitwise operations and assign the result to the same variable. The bitwise right shift assignment operator (>>=) shifts the bits of a variable to the right by a specified number of positions and stores the result in the same variable. The bitwise left shift assignment operator (<<=) shifts the bits of a variable to the left by a specified number of positions and stores the result in the same variable. These operators are useful in simplifying and shortening code that involves assigning and manipulating values in a single step.

Here are some Frequently Asked Questions on Assignment Operator in Python:

Q1 – Can I use the assignment operator to assign multiple values to multiple variables at once? Ans – Yes, you can use the assignment operator to assign multiple values to multiple variables at once, separated by commas. For example, "x, y, z = 1, 2, 3" would assign the value 1 to x, 2 to y, and 3 to z.

Q2 – Is it possible to chain assignment operators in Python? Ans – Yes, you can chain assignment operators in Python to perform multiple operations in one line of code. For example, "x = y = z = 1" would assign the value 1 to all three variables.

Q3 – How do I perform a conditional assignment in Python? Ans – To perform a conditional assignment in Python, you can use the ternary operator. For example, "x = a (if a > b) else b" would assign the value of a to x if a is greater than b, otherwise it would assign the value of b to x.

Q4 – What happens if I use an undefined variable in an assignment operation in Python? Ans – If you use an undefined variable in an assignment operation in Python, you will get a NameError. Make sure you have defined the variable before trying to assign a value to it.

Q5 – Can I use assignment operators with non-numeric data types in Python? Ans – Yes, you can use assignment operators with non-numeric data types in Python, such as strings or lists. For example, "my_list += [4, 5, 6]" would append the values 4, 5, and 6 to the end of the list named my_list.

Python Assignment Operators

In Python, an assignment operator is used to assign a value to a variable. The assignment operator is a single equals sign (=). Here is an example of using the assignment operator to assign a value to a variable:

In this example, the variable x is assigned the value 5.

There are also several compound assignment operators in Python, which are used to perform an operation and assign the result to a variable in a single step. These operators include:

+=: adds the right operand to the left operand and assigns the result to the left operand
-=: subtracts the right operand from the left operand and assigns the result to the left operand
*=: multiplies the left operand by the right operand and assigns the result to the left operand
/=: divides the left operand by the right operand and assigns the result to the left operand
%=: calculates the remainder of the left operand divided by the right operand and assigns the result to the left operand
//=: divides the left operand by the right operand and assigns the result as an integer to the left operand
**=: raises the left operand to the power of the right operand and assigns the result to the left operand

Here are some examples of using compound assignment operators:

Welcome! This site is currently in beta. Get 10% off everything with promo code BETA10.

Python Assignment Operator

Introduction

Chained Assignment

Shorthand assignment, shorthand assignment operators, playground: assignment operator practice, assignment methods.

All assignment operators are used to assign values to variables. Wait, is there more than one assignment operator? Yes, but they're all quite similar to the ones you've seen. You've used the most common assignment operator, and its symbol is a single equals sign ( = ).

For example, to assign x the value of 10 you type the following:

Different Assignment Methods

You have used this assignment statement before to assign values to variables. Apart from this very common way of using it, a few other situations use the same symbol for slightly different assignments.

You can assign the same value to multiple variables in one swoop by using an assignment chain:

This construct assigns 10 to x , y , and z . Using the chained assignment statement in Python is rare, but if you see it around, now you know what that's about.

Shorthand assignments, on the other hand, are a common occurrence in Python code. This is where the other assignment operators come into play. Shorthand assignments make writing code more efficient and can improve readability---at least once you know about them!

For example, think of a situation where you have a variable x and you want to add 1 to that variable:

This works well and is perfectly fine Python code. However, there is a more concise way of writing the same code using shorthand assignment :

Check out how the second line in these two code snippets is different. You don't need to write the name of the variable x a second time using the shorthand operator += like in the example above.

Both code examples shown achieve the exact same result and are equivalent. The shorthand assignment allows you to use less code to complete the task.

Python comes with a couple of shorthand assignment operators. Some of the most common ones include the following:

These operators are combinations of familiar arithmetic operators with the assignment operator ( = ). You have already used some of Python's arithmetic operators, and you'll learn more about them in the upcoming lesson.

Play around and combine different operators you can think of with the assignment operator below.

Which ones work and do what you expect them to?
Which ones don't?

Summary: Python Assignment Operator

Assignment operators are used to assign values to variables
Shorthand assignment is the most commonly used in Python
The table summarizing the assignment operators is provided in the lesson
Chain Assignment : A method used to assign multiple variables at one
Shorthand Assignment : A series of short forms for manipulating data

Case Studies
Our Pricing
Do my Programming Homework
Java Homework Help
HTML Homework Help
Do my computer science homework
C++ Homework Help
C Homework Help
Python Assignment Help
Android Assignment help
Database Homework Help
PHP Assignment Help
JavaScript Assignment Help
R Assignment Help
Node.Js Homework Help
Data Structures Assignment Help
Machine Learning Assignment Help
MATLAB Assignment Help
C Sharp Assignment Help
Operating System Assignment Help
Assembly Language Assignment Help
Scala Assignment Help
Visual Basic Assignment Help
Live Java Tutoring
Python Tutoring
Our Experts
Testimonials
Submit Your Assignment

Assignment Operators in Python

In this article, we will learn about all the “ Assignment Operators in Python ” with examples of each. Assignment operators in Python are essential tools for manipulating and assigning values to variables. These operators not only let you store data in variables but also perform various operations simultaneously. Understanding these operators is crucial for efficient Python programming, as they streamline code while making it more readable and maintainable. If you encounter any challenges in grasping these operators, don’t hesitate to seek Python help from the experts at CodingZap.

What Are Operators and Operands?

Operators can be understood as the mathematical symbols we have seen since childhood, like the +, -, *, / =. They are used to perform mathematical, logical or bitwise operations in a programming language.

Operands are the values or variables on which operators act. For example, “+” will add the values of two operands, and similarly “*” will multiply the values of the 2 operands.

In the expression “a+b”, “+” is the operator and “a” and “b” are the operands.

What Is Assignment Operators in Python?

Assignment operators are a fundamental concept in Python and most programming languages. They are used to assign values to variables, as well as initialize and update them. They assign the value on the right-hand side to the variable on the left.

In Python, the primary assignment operator is the “Simple assignment operator (=)”, which as the name suggests, assigns values to variables. However, Python offers a rich set of assignment operators that provide more functionality than simple assignments. These operators not only assign values but also perform specific operations at the same time, such as addition, subtraction, multiplication, division, bitwise operations, and more.

What Are the Basics of Assignments?

First, we’ll clarify some basic rules about the assignments in Python. For this, we’ll use the simple assignment operator “=”.

A sample program using “=” is as follows:

In the above example, the value on the right-hand side is assigned to the variable on the left. We check the value assigned by printing the variable and get the expected result, i.e. 5.

In the example above, the statement a = 5 is called an assignment statement, which assigns values to the variables.

The syntax for an assignment statement is as follows:

As we can see, it is composed of three components:

The left operand of an assignment statement must always and only be a variable.
Then comes the assignment operator itself.
The right operand can be a value, an expression or an object.

Now that we have this rule clear let us look at the assignment operators in Python. The assignment operators allow us to create, initialise and update the variables.

The simple assignment operator “=”

It is the primary assignment operator

Let’s look at some examples to understand the uses of the simple assignment operator:

As we can see in the above code, the simple assignment operator is used to create every variable type in Python, be it a primitive integer, string, or complex data structure. Strings are also an interesting concept in Python, if you’re interested to know how to compare strings in Python then you can check out our article.

Updating values

The assignment operators are also used to update variable values in Python. An example is as follows:

In the above example, we initialized our integer and list with initial values and printed them for reference. Then, we modified these values and printed them again to verify the changes.

Multiple and parallel assignments

Python provides additional functionality to perform multiple and parallel assignments to variables in a single line. This reduces lines of code and complexity. Let’s understand them with an example:

In the above code, we demonstrate multiple and parallel assignments.

We can assign the same literal value to multiple variables in multiple assignments. In the above code, the integer value 45 is assigned to all the variables a,b,c. The data type of all the variables in a multiple-assignment statement must be the same.

In parallel assignments, we can assign different values to different variables using comma-separated variables and values on either side of the assignment operator. The values are stored in the order of writing the pairs. The variable types need not be the same in parallel assignments.

Augmented assignment operators in Python

The simple assignment operator is used to assign values to variables in Python. However, Python also supports complex assignments using which we can calculate various values and assign them to the variable in a single line.

The basic syntax for augmented assignment operators is as follows:

The ‘$’ in the above syntax can be replaced by various operators to perform operations on operands before assigning the final value to the variable.

Python equates the above syntax to the following expression:

We’ll understand these operators better if we directly look at their examples.

Let’s have a look at all the augmented assignment operators in Python one at a time:

Add assignment operator “+=”

This operator adds the left and the right operands and assigns the resulting value to the variable on the left.

An example would be

Which will equate to

It is important to note that only the value of “a” will change, whereas the value of “b” will remain the same. This is because the sum of “a” and “b” is finally stored in the variable “a”.

Let’s look at the code and its output:

In the above code, we initialized 2 variables and added the value of the second variable to the first one using the add assignment operator. Note that the value of “a” changes, but the value of “b” remains the same.

This operator can also be used on some data structures like lists and tuples, using which we can append values at the end of the list, as can be seen in the code above.

Subtract assignment operator

This operator is used to subtract the right operand from the left and assign the resulting value to the variable on the left.

A sample code is as follows:

In the above code, we initialized the 2 variables “a” and “b” and printed their values for reference. Then, we subtracted the value of “b” from “a” using the subtract assignment operator. The final expression equated to “a=a-b”. At last, we printed the final values of “a” and “b”.

Multiplication assignment operator

The multiplication assignment operator is used to multiply the right operand with the left and assign the resulting value to the variable on the left.

In the above code, we initialized the 2 variables “a” and “b” and printed their values for reference. Then, we multiplied the values of “a” and “b” using the multiplication assignment operator. The final expression equated to “a=a*b”. At last, we printed the final values of “a” and “b” to check the resulting values.

Division assignment operator

The division assignment operator divides the left operand from the right and assigns the resulting value to the operand on the left.

In the above code, we initialized the 2 variables “a” and “b” and printed their values for reference. Then, we divided “a” by “b” using the division assignment operator. The final expression equated to “a=a/b”. At last, we printed the final values of “a” and “b”.

Floor assignment operator

The floor assignment operator divides the operand on the left from the right and rounds the value to the greatest integer less than or equal to the resultant value. This value is then stored in the operand on the left.

Sample code is as follows:

In the above code, we initialized the 2 variables “a” and “b” and printed their values for reference. Then, we divided “a” from “b” using the floor assignment operator. This operator also divides the variables in the same way as the division assignment operator but rounds off the answer to the greatest integer less than or equal to the answer. In this case, the value “16.66” was rounded off to “16”.

At last, we printed the final values of “a” and “b”.

Modulus assignment operator

The modulus assignment operator is used to extract the remainder after dividing the operand on the left from the right. The remainder is then stored in the operand on the left.

In the above code, we initialized the 2 variables “a” and “b” and printed their values for reference. We then used the modulus assignment operator to get the remainder of the division “a/b”, and store the resulting value in “a”. At last, we printed the final values of “a” and “b”.

Exponentiation assignment operator

This operator is used to calculate the exponent of the left-side operand raised to the power of the right-side operand, which is then stored in the operand on the left.

In the above code, we initialized the 2 variables “a” and “b” and printed their values for reference. We then used the exponentiation assignment operator to get the value of “a” raised to the power of “b”, and store the resulting value in “a”. At last, we printed the final values of “a” and “b”.

Bitwise AND assignment operator

This operator calculates the Bitwise AND value of the operands on the left and right and stores the value in the left operand.

Sample code:

In the above code, we initialized the 2 variables “a” and “b” and printed their values for reference. We then used the bitwise AND assignment operator to get the bitwise AND of “a” and “b”, and store the resulting value in “a”. At last, we printed the final values of “a” and “b”.

Bitwise OR assignment operator

This operator calculates the Bitwise OR value of the operands on the left and right and stores the value in the left operand.

In the above code, we initialized the 2 variables “a” and “b” and printed their values for reference. We then used the bitwise OR assignment operator to get the bitwise

OR of “a” and “b”, and store the resulting value in “a”. At last, we printed the final values of “a” and “b”.

Bitwise XOR assignment operator

This operator calculates the XOR of the 2 operands and stores the value in the left operand.

In the above code, we initialized the 2 variables “a” and “b” and printed their values for reference. We then used the bitwise XOR assignment operator to get the bitwise XOR of “a” and “b” and store the resulting value in “a”. At last, we printed the final values of “a” and “b”.

Bitwise Left Shift assignment operator

This operator left-shifts the bits of the operand on the left by the units as declared by the operand on the right and stores the value in the left operand.

In the above code, we initialized the 2 variables “a” and “b” and printed their values for reference. We then used the bitwise left shift assignment operator to left shift the bits of “a” by “b” units and store the resulting value in “a”. At last, we printed the final values of “a” and “b”.

Bitwise Right Shift assignment operator

This operator right-shifts the bits of the operand on the left by the units as declared by the operand on the right, and stores the value in the left operand.

In the above code, we initialized the 2 variables “a” and “b” and printed their values for reference. We then used the bitwise right shift assignment operator to right shift the bits of “a” by “b” units, and store the resulting value in “a”. At last, we printed the final values of “a” and “b”.

In this article, we learned about the assignment operators in Python. The primary assignment operator is the simple assignment operator (“=”).

We then learned that Python supports more complex assignment operators that can be used to calculate values in place.

The assignment operators can be used to calculate mathematical, logical, and bitwise operations.

We also saw a consistent property of all the assignment operators, in which they calculated the expression on the right and assigned the resulting value to the variable on the left.

There are many reasons why students look for assignment help online like difficulty in understanding the assignment, time limitation, etc. So, if you’re also looking then you can always hire CodinngZap experts.

Sounetra Ghosal

Programming Help Expertise

HQ USA: 920 Beach Park Blvd, Foster City, USA
+1 (332) 895-6153
[email protected]

CodingZap accepts all major Debit and Credit cards payment.

Important Links

Python Enhancement Proposals

Python »
PEP Index »

PEP 572 – Assignment Expressions

The importance of real code, exceptional cases, scope of the target, relative precedence of :=, change to evaluation order, differences between assignment expressions and assignment statements, specification changes during implementation, _pydecimal.py, datetime.py, sysconfig.py, simplifying list comprehensions, capturing condition values, changing the scope rules for comprehensions, alternative spellings, special-casing conditional statements, special-casing comprehensions, lowering operator precedence, allowing commas to the right, always requiring parentheses, why not just turn existing assignment into an expression, with assignment expressions, why bother with assignment statements, why not use a sublocal scope and prevent namespace pollution, style guide recommendations, acknowledgements, a numeric example, appendix b: rough code translations for comprehensions, appendix c: no changes to scope semantics.

This is a proposal for creating a way to assign to variables within an expression using the notation NAME := expr .

As part of this change, there is also an update to dictionary comprehension evaluation order to ensure key expressions are executed before value expressions (allowing the key to be bound to a name and then re-used as part of calculating the corresponding value).

During discussion of this PEP, the operator became informally known as “the walrus operator”. The construct’s formal name is “Assignment Expressions” (as per the PEP title), but they may also be referred to as “Named Expressions” (e.g. the CPython reference implementation uses that name internally).

Naming the result of an expression is an important part of programming, allowing a descriptive name to be used in place of a longer expression, and permitting reuse. Currently, this feature is available only in statement form, making it unavailable in list comprehensions and other expression contexts.

Additionally, naming sub-parts of a large expression can assist an interactive debugger, providing useful display hooks and partial results. Without a way to capture sub-expressions inline, this would require refactoring of the original code; with assignment expressions, this merely requires the insertion of a few name := markers. Removing the need to refactor reduces the likelihood that the code be inadvertently changed as part of debugging (a common cause of Heisenbugs), and is easier to dictate to another programmer.

During the development of this PEP many people (supporters and critics both) have had a tendency to focus on toy examples on the one hand, and on overly complex examples on the other.

The danger of toy examples is twofold: they are often too abstract to make anyone go “ooh, that’s compelling”, and they are easily refuted with “I would never write it that way anyway”.

The danger of overly complex examples is that they provide a convenient strawman for critics of the proposal to shoot down (“that’s obfuscated”).

Yet there is some use for both extremely simple and extremely complex examples: they are helpful to clarify the intended semantics. Therefore, there will be some of each below.

However, in order to be compelling , examples should be rooted in real code, i.e. code that was written without any thought of this PEP, as part of a useful application, however large or small. Tim Peters has been extremely helpful by going over his own personal code repository and picking examples of code he had written that (in his view) would have been clearer if rewritten with (sparing) use of assignment expressions. His conclusion: the current proposal would have allowed a modest but clear improvement in quite a few bits of code.

Another use of real code is to observe indirectly how much value programmers place on compactness. Guido van Rossum searched through a Dropbox code base and discovered some evidence that programmers value writing fewer lines over shorter lines.

Case in point: Guido found several examples where a programmer repeated a subexpression, slowing down the program, in order to save one line of code, e.g. instead of writing:

they would write:

Another example illustrates that programmers sometimes do more work to save an extra level of indentation:

This code tries to match pattern2 even if pattern1 has a match (in which case the match on pattern2 is never used). The more efficient rewrite would have been:

Syntax and semantics

In most contexts where arbitrary Python expressions can be used, a named expression can appear. This is of the form NAME := expr where expr is any valid Python expression other than an unparenthesized tuple, and NAME is an identifier.

The value of such a named expression is the same as the incorporated expression, with the additional side-effect that the target is assigned that value:

There are a few places where assignment expressions are not allowed, in order to avoid ambiguities or user confusion:

This rule is included to simplify the choice for the user between an assignment statement and an assignment expression – there is no syntactic position where both are valid.

Again, this rule is included to avoid two visually similar ways of saying the same thing.

This rule is included to disallow excessively confusing code, and because parsing keyword arguments is complex enough already.

This rule is included to discourage side effects in a position whose exact semantics are already confusing to many users (cf. the common style recommendation against mutable default values), and also to echo the similar prohibition in calls (the previous bullet).

The reasoning here is similar to the two previous cases; this ungrouped assortment of symbols and operators composed of : and = is hard to read correctly.

This allows lambda to always bind less tightly than := ; having a name binding at the top level inside a lambda function is unlikely to be of value, as there is no way to make use of it. In cases where the name will be used more than once, the expression is likely to need parenthesizing anyway, so this prohibition will rarely affect code.

This shows that what looks like an assignment operator in an f-string is not always an assignment operator. The f-string parser uses : to indicate formatting options. To preserve backwards compatibility, assignment operator usage inside of f-strings must be parenthesized. As noted above, this usage of the assignment operator is not recommended.

An assignment expression does not introduce a new scope. In most cases the scope in which the target will be bound is self-explanatory: it is the current scope. If this scope contains a nonlocal or global declaration for the target, the assignment expression honors that. A lambda (being an explicit, if anonymous, function definition) counts as a scope for this purpose.

There is one special case: an assignment expression occurring in a list, set or dict comprehension or in a generator expression (below collectively referred to as “comprehensions”) binds the target in the containing scope, honoring a nonlocal or global declaration for the target in that scope, if one exists. For the purpose of this rule the containing scope of a nested comprehension is the scope that contains the outermost comprehension. A lambda counts as a containing scope.

The motivation for this special case is twofold. First, it allows us to conveniently capture a “witness” for an any() expression, or a counterexample for all() , for example:

Second, it allows a compact way of updating mutable state from a comprehension, for example:

However, an assignment expression target name cannot be the same as a for -target name appearing in any comprehension containing the assignment expression. The latter names are local to the comprehension in which they appear, so it would be contradictory for a contained use of the same name to refer to the scope containing the outermost comprehension instead.

For example, [i := i+1 for i in range(5)] is invalid: the for i part establishes that i is local to the comprehension, but the i := part insists that i is not local to the comprehension. The same reason makes these examples invalid too:

While it’s technically possible to assign consistent semantics to these cases, it’s difficult to determine whether those semantics actually make sense in the absence of real use cases. Accordingly, the reference implementation [1] will ensure that such cases raise SyntaxError , rather than executing with implementation defined behaviour.

This restriction applies even if the assignment expression is never executed:

For the comprehension body (the part before the first “for” keyword) and the filter expression (the part after “if” and before any nested “for”), this restriction applies solely to target names that are also used as iteration variables in the comprehension. Lambda expressions appearing in these positions introduce a new explicit function scope, and hence may use assignment expressions with no additional restrictions.

Due to design constraints in the reference implementation (the symbol table analyser cannot easily detect when names are re-used between the leftmost comprehension iterable expression and the rest of the comprehension), named expressions are disallowed entirely as part of comprehension iterable expressions (the part after each “in”, and before any subsequent “if” or “for” keyword):

A further exception applies when an assignment expression occurs in a comprehension whose containing scope is a class scope. If the rules above were to result in the target being assigned in that class’s scope, the assignment expression is expressly invalid. This case also raises SyntaxError :

(The reason for the latter exception is the implicit function scope created for comprehensions – there is currently no runtime mechanism for a function to refer to a variable in the containing class scope, and we do not want to add such a mechanism. If this issue ever gets resolved this special case may be removed from the specification of assignment expressions. Note that the problem already exists for using a variable defined in the class scope from a comprehension.)

See Appendix B for some examples of how the rules for targets in comprehensions translate to equivalent code.

The := operator groups more tightly than a comma in all syntactic positions where it is legal, but less tightly than all other operators, including or , and , not , and conditional expressions ( A if C else B ). As follows from section “Exceptional cases” above, it is never allowed at the same level as = . In case a different grouping is desired, parentheses should be used.

The := operator may be used directly in a positional function call argument; however it is invalid directly in a keyword argument.

Some examples to clarify what’s technically valid or invalid:

Most of the “valid” examples above are not recommended, since human readers of Python source code who are quickly glancing at some code may miss the distinction. But simple cases are not objectionable:

This PEP recommends always putting spaces around := , similar to PEP 8 ’s recommendation for = when used for assignment, whereas the latter disallows spaces around = used for keyword arguments.)

In order to have precisely defined semantics, the proposal requires evaluation order to be well-defined. This is technically not a new requirement, as function calls may already have side effects. Python already has a rule that subexpressions are generally evaluated from left to right. However, assignment expressions make these side effects more visible, and we propose a single change to the current evaluation order:

In a dict comprehension {X: Y for ...} , Y is currently evaluated before X . We propose to change this so that X is evaluated before Y . (In a dict display like {X: Y} this is already the case, and also in dict((X, Y) for ...) which should clearly be equivalent to the dict comprehension.)

Most importantly, since := is an expression, it can be used in contexts where statements are illegal, including lambda functions and comprehensions.

Conversely, assignment expressions don’t support the advanced features found in assignment statements:

Multiple targets are not directly supported: x = y = z = 0 # Equivalent: (z := (y := (x := 0)))
Single assignment targets other than a single NAME are not supported: # No equivalent a [ i ] = x self . rest = []
Priority around commas is different: x = 1 , 2 # Sets x to (1, 2) ( x := 1 , 2 ) # Sets x to 1
Iterable packing and unpacking (both regular or extended forms) are not supported: # Equivalent needs extra parentheses loc = x , y # Use (loc := (x, y)) info = name , phone , * rest # Use (info := (name, phone, *rest)) # No equivalent px , py , pz = position name , phone , email , * other_info = contact
Inline type annotations are not supported: # Closest equivalent is "p: Optional[int]" as a separate declaration p : Optional [ int ] = None
Augmented assignment is not supported: total += tax # Equivalent: (total := total + tax)

The following changes have been made based on implementation experience and additional review after the PEP was first accepted and before Python 3.8 was released:

for consistency with other similar exceptions, and to avoid locking in an exception name that is not necessarily going to improve clarity for end users, the originally proposed TargetScopeError subclass of SyntaxError was dropped in favour of just raising SyntaxError directly. [3]
due to a limitation in CPython’s symbol table analysis process, the reference implementation raises SyntaxError for all uses of named expressions inside comprehension iterable expressions, rather than only raising them when the named expression target conflicts with one of the iteration variables in the comprehension. This could be revisited given sufficiently compelling examples, but the extra complexity needed to implement the more selective restriction doesn’t seem worthwhile for purely hypothetical use cases.

Examples from the Python standard library

env_base is only used on these lines, putting its assignment on the if moves it as the “header” of the block.

Current: env_base = os . environ . get ( "PYTHONUSERBASE" , None ) if env_base : return env_base
Improved: if env_base := os . environ . get ( "PYTHONUSERBASE" , None ): return env_base

Avoid nested if and remove one indentation level.

Current: if self . _is_special : ans = self . _check_nans ( context = context ) if ans : return ans
Improved: if self . _is_special and ( ans := self . _check_nans ( context = context )): return ans

Code looks more regular and avoid multiple nested if. (See Appendix A for the origin of this example.)

Current: reductor = dispatch_table . get ( cls ) if reductor : rv = reductor ( x ) else : reductor = getattr ( x , "__reduce_ex__" , None ) if reductor : rv = reductor ( 4 ) else : reductor = getattr ( x , "__reduce__" , None ) if reductor : rv = reductor () else : raise Error ( "un(deep)copyable object of type %s " % cls )
Improved: if reductor := dispatch_table . get ( cls ): rv = reductor ( x ) elif reductor := getattr ( x , "__reduce_ex__" , None ): rv = reductor ( 4 ) elif reductor := getattr ( x , "__reduce__" , None ): rv = reductor () else : raise Error ( "un(deep)copyable object of type %s " % cls )

tz is only used for s += tz , moving its assignment inside the if helps to show its scope.

Current: s = _format_time ( self . _hour , self . _minute , self . _second , self . _microsecond , timespec ) tz = self . _tzstr () if tz : s += tz return s
Improved: s = _format_time ( self . _hour , self . _minute , self . _second , self . _microsecond , timespec ) if tz := self . _tzstr (): s += tz return s

Calling fp.readline() in the while condition and calling .match() on the if lines make the code more compact without making it harder to understand.

Current: while True : line = fp . readline () if not line : break m = define_rx . match ( line ) if m : n , v = m . group ( 1 , 2 ) try : v = int ( v ) except ValueError : pass vars [ n ] = v else : m = undef_rx . match ( line ) if m : vars [ m . group ( 1 )] = 0
Improved: while line := fp . readline (): if m := define_rx . match ( line ): n , v = m . group ( 1 , 2 ) try : v = int ( v ) except ValueError : pass vars [ n ] = v elif m := undef_rx . match ( line ): vars [ m . group ( 1 )] = 0

A list comprehension can map and filter efficiently by capturing the condition:

Similarly, a subexpression can be reused within the main expression, by giving it a name on first use:

Note that in both cases the variable y is bound in the containing scope (i.e. at the same level as results or stuff ).

Assignment expressions can be used to good effect in the header of an if or while statement:

Particularly with the while loop, this can remove the need to have an infinite loop, an assignment, and a condition. It also creates a smooth parallel between a loop which simply uses a function call as its condition, and one which uses that as its condition but also uses the actual value.

An example from the low-level UNIX world:

Rejected alternative proposals

Proposals broadly similar to this one have come up frequently on python-ideas. Below are a number of alternative syntaxes, some of them specific to comprehensions, which have been rejected in favour of the one given above.

A previous version of this PEP proposed subtle changes to the scope rules for comprehensions, to make them more usable in class scope and to unify the scope of the “outermost iterable” and the rest of the comprehension. However, this part of the proposal would have caused backwards incompatibilities, and has been withdrawn so the PEP can focus on assignment expressions.

Broadly the same semantics as the current proposal, but spelled differently.

Since EXPR as NAME already has meaning in import , except and with statements (with different semantics), this would create unnecessary confusion or require special-casing (e.g. to forbid assignment within the headers of these statements).

(Note that with EXPR as VAR does not simply assign the value of EXPR to VAR – it calls EXPR.__enter__() and assigns the result of that to VAR .)

Additional reasons to prefer := over this spelling include:

In if f(x) as y the assignment target doesn’t jump out at you – it just reads like if f x blah blah and it is too similar visually to if f(x) and y .
import foo as bar
except Exc as var
with ctxmgr() as var

To the contrary, the assignment expression does not belong to the if or while that starts the line, and we intentionally allow assignment expressions in other contexts as well.

NAME = EXPR
if NAME := EXPR

reinforces the visual recognition of assignment expressions.

This syntax is inspired by languages such as R and Haskell, and some programmable calculators. (Note that a left-facing arrow y <- f(x) is not possible in Python, as it would be interpreted as less-than and unary minus.) This syntax has a slight advantage over ‘as’ in that it does not conflict with with , except and import , but otherwise is equivalent. But it is entirely unrelated to Python’s other use of -> (function return type annotations), and compared to := (which dates back to Algol-58) it has a much weaker tradition.

This has the advantage that leaked usage can be readily detected, removing some forms of syntactic ambiguity. However, this would be the only place in Python where a variable’s scope is encoded into its name, making refactoring harder.

Execution order is inverted (the indented body is performed first, followed by the “header”). This requires a new keyword, unless an existing keyword is repurposed (most likely with: ). See PEP 3150 for prior discussion on this subject (with the proposed keyword being given: ).

This syntax has fewer conflicts than as does (conflicting only with the raise Exc from Exc notation), but is otherwise comparable to it. Instead of paralleling with expr as target: (which can be useful but can also be confusing), this has no parallels, but is evocative.

One of the most popular use-cases is if and while statements. Instead of a more general solution, this proposal enhances the syntax of these two statements to add a means of capturing the compared value:

This works beautifully if and ONLY if the desired condition is based on the truthiness of the captured value. It is thus effective for specific use-cases (regex matches, socket reads that return '' when done), and completely useless in more complicated cases (e.g. where the condition is f(x) < 0 and you want to capture the value of f(x) ). It also has no benefit to list comprehensions.

Advantages: No syntactic ambiguities. Disadvantages: Answers only a fraction of possible use-cases, even in if / while statements.

Another common use-case is comprehensions (list/set/dict, and genexps). As above, proposals have been made for comprehension-specific solutions.

This brings the subexpression to a location in between the ‘for’ loop and the expression. It introduces an additional language keyword, which creates conflicts. Of the three, where reads the most cleanly, but also has the greatest potential for conflict (e.g. SQLAlchemy and numpy have where methods, as does tkinter.dnd.Icon in the standard library).

As above, but reusing the with keyword. Doesn’t read too badly, and needs no additional language keyword. Is restricted to comprehensions, though, and cannot as easily be transformed into “longhand” for-loop syntax. Has the C problem that an equals sign in an expression can now create a name binding, rather than performing a comparison. Would raise the question of why “with NAME = EXPR:” cannot be used as a statement on its own.

As per option 2, but using as rather than an equals sign. Aligns syntactically with other uses of as for name binding, but a simple transformation to for-loop longhand would create drastically different semantics; the meaning of with inside a comprehension would be completely different from the meaning as a stand-alone statement, while retaining identical syntax.

Regardless of the spelling chosen, this introduces a stark difference between comprehensions and the equivalent unrolled long-hand form of the loop. It is no longer possible to unwrap the loop into statement form without reworking any name bindings. The only keyword that can be repurposed to this task is with , thus giving it sneakily different semantics in a comprehension than in a statement; alternatively, a new keyword is needed, with all the costs therein.

There are two logical precedences for the := operator. Either it should bind as loosely as possible, as does statement-assignment; or it should bind more tightly than comparison operators. Placing its precedence between the comparison and arithmetic operators (to be precise: just lower than bitwise OR) allows most uses inside while and if conditions to be spelled without parentheses, as it is most likely that you wish to capture the value of something, then perform a comparison on it:

Once find() returns -1, the loop terminates. If := binds as loosely as = does, this would capture the result of the comparison (generally either True or False ), which is less useful.

While this behaviour would be convenient in many situations, it is also harder to explain than “the := operator behaves just like the assignment statement”, and as such, the precedence for := has been made as close as possible to that of = (with the exception that it binds tighter than comma).

Some critics have claimed that the assignment expressions should allow unparenthesized tuples on the right, so that these two would be equivalent:

(With the current version of the proposal, the latter would be equivalent to ((point := x), y) .)

However, adopting this stance would logically lead to the conclusion that when used in a function call, assignment expressions also bind less tight than comma, so we’d have the following confusing equivalence:

The less confusing option is to make := bind more tightly than comma.

It’s been proposed to just always require parentheses around an assignment expression. This would resolve many ambiguities, and indeed parentheses will frequently be needed to extract the desired subexpression. But in the following cases the extra parentheses feel redundant:

Frequently Raised Objections

C and its derivatives define the = operator as an expression, rather than a statement as is Python’s way. This allows assignments in more contexts, including contexts where comparisons are more common. The syntactic similarity between if (x == y) and if (x = y) belies their drastically different semantics. Thus this proposal uses := to clarify the distinction.

The two forms have different flexibilities. The := operator can be used inside a larger expression; the = statement can be augmented to += and its friends, can be chained, and can assign to attributes and subscripts.

Previous revisions of this proposal involved sublocal scope (restricted to a single statement), preventing name leakage and namespace pollution. While a definite advantage in a number of situations, this increases complexity in many others, and the costs are not justified by the benefits. In the interests of language simplicity, the name bindings created here are exactly equivalent to any other name bindings, including that usage at class or module scope will create externally-visible names. This is no different from for loops or other constructs, and can be solved the same way: del the name once it is no longer needed, or prefix it with an underscore.

(The author wishes to thank Guido van Rossum and Christoph Groth for their suggestions to move the proposal in this direction. [2] )

As expression assignments can sometimes be used equivalently to statement assignments, the question of which should be preferred will arise. For the benefit of style guides such as PEP 8 , two recommendations are suggested.

If either assignment statements or assignment expressions can be used, prefer statements; they are a clear declaration of intent.
If using assignment expressions would lead to ambiguity about execution order, restructure it to use statements instead.

The authors wish to thank Alyssa Coghlan and Steven D’Aprano for their considerable contributions to this proposal, and members of the core-mentorship mailing list for assistance with implementation.

Appendix A: Tim Peters’s findings

Here’s a brief essay Tim Peters wrote on the topic.

I dislike “busy” lines of code, and also dislike putting conceptually unrelated logic on a single line. So, for example, instead of:

instead. So I suspected I’d find few places I’d want to use assignment expressions. I didn’t even consider them for lines already stretching halfway across the screen. In other cases, “unrelated” ruled:

is a vast improvement over the briefer:

The original two statements are doing entirely different conceptual things, and slamming them together is conceptually insane.

In other cases, combining related logic made it harder to understand, such as rewriting:

as the briefer:

The while test there is too subtle, crucially relying on strict left-to-right evaluation in a non-short-circuiting or method-chaining context. My brain isn’t wired that way.

But cases like that were rare. Name binding is very frequent, and “sparse is better than dense” does not mean “almost empty is better than sparse”. For example, I have many functions that return None or 0 to communicate “I have nothing useful to return in this case, but since that’s expected often I’m not going to annoy you with an exception”. This is essentially the same as regular expression search functions returning None when there is no match. So there was lots of code of the form:

I find that clearer, and certainly a bit less typing and pattern-matching reading, as:

It’s also nice to trade away a small amount of horizontal whitespace to get another _line_ of surrounding code on screen. I didn’t give much weight to this at first, but it was so very frequent it added up, and I soon enough became annoyed that I couldn’t actually run the briefer code. That surprised me!

There are other cases where assignment expressions really shine. Rather than pick another from my code, Kirill Balunov gave a lovely example from the standard library’s copy() function in copy.py :

The ever-increasing indentation is semantically misleading: the logic is conceptually flat, “the first test that succeeds wins”:

Using easy assignment expressions allows the visual structure of the code to emphasize the conceptual flatness of the logic; ever-increasing indentation obscured it.

A smaller example from my code delighted me, both allowing to put inherently related logic in a single line, and allowing to remove an annoying “artificial” indentation level:

That if is about as long as I want my lines to get, but remains easy to follow.

So, in all, in most lines binding a name, I wouldn’t use assignment expressions, but because that construct is so very frequent, that leaves many places I would. In most of the latter, I found a small win that adds up due to how often it occurs, and in the rest I found a moderate to major win. I’d certainly use it more often than ternary if , but significantly less often than augmented assignment.

I have another example that quite impressed me at the time.

Where all variables are positive integers, and a is at least as large as the n’th root of x, this algorithm returns the floor of the n’th root of x (and roughly doubling the number of accurate bits per iteration):

It’s not obvious why that works, but is no more obvious in the “loop and a half” form. It’s hard to prove correctness without building on the right insight (the “arithmetic mean - geometric mean inequality”), and knowing some non-trivial things about how nested floor functions behave. That is, the challenges are in the math, not really in the coding.

If you do know all that, then the assignment-expression form is easily read as “while the current guess is too large, get a smaller guess”, where the “too large?” test and the new guess share an expensive sub-expression.

To my eyes, the original form is harder to understand:

This appendix attempts to clarify (though not specify) the rules when a target occurs in a comprehension or in a generator expression. For a number of illustrative examples we show the original code, containing a comprehension, and the translation, where the comprehension has been replaced by an equivalent generator function plus some scaffolding.

Since [x for ...] is equivalent to list(x for ...) these examples all use list comprehensions without loss of generality. And since these examples are meant to clarify edge cases of the rules, they aren’t trying to look like real code.

Note: comprehensions are already implemented via synthesizing nested generator functions like those in this appendix. The new part is adding appropriate declarations to establish the intended scope of assignment expression targets (the same scope they resolve to as if the assignment were performed in the block containing the outermost comprehension). For type inference purposes, these illustrative expansions do not imply that assignment expression targets are always Optional (but they do indicate the target binding scope).

Let’s start with a reminder of what code is generated for a generator expression without assignment expression.

Original code (EXPR usually references VAR): def f (): a = [ EXPR for VAR in ITERABLE ]
Translation (let’s not worry about name conflicts): def f (): def genexpr ( iterator ): for VAR in iterator : yield EXPR a = list ( genexpr ( iter ( ITERABLE )))

Let’s add a simple assignment expression.

Original code: def f (): a = [ TARGET := EXPR for VAR in ITERABLE ]
Translation: def f (): if False : TARGET = None # Dead code to ensure TARGET is a local variable def genexpr ( iterator ): nonlocal TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Let’s add a global TARGET declaration in f() .

Original code: def f (): global TARGET a = [ TARGET := EXPR for VAR in ITERABLE ]
Translation: def f (): global TARGET def genexpr ( iterator ): global TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Or instead let’s add a nonlocal TARGET declaration in f() .

Original code: def g (): TARGET = ... def f (): nonlocal TARGET a = [ TARGET := EXPR for VAR in ITERABLE ]
Translation: def g (): TARGET = ... def f (): nonlocal TARGET def genexpr ( iterator ): nonlocal TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Finally, let’s nest two comprehensions.

Original code: def f (): a = [[ TARGET := i for i in range ( 3 )] for j in range ( 2 )] # I.e., a = [[0, 1, 2], [0, 1, 2]] print ( TARGET ) # prints 2
Translation: def f (): if False : TARGET = None def outer_genexpr ( outer_iterator ): nonlocal TARGET def inner_generator ( inner_iterator ): nonlocal TARGET for i in inner_iterator : TARGET = i yield i for j in outer_iterator : yield list ( inner_generator ( range ( 3 ))) a = list ( outer_genexpr ( range ( 2 ))) print ( TARGET )

Because it has been a point of confusion, note that nothing about Python’s scoping semantics is changed. Function-local scopes continue to be resolved at compile time, and to have indefinite temporal extent at run time (“full closures”). Example:

This document has been placed in the public domain.

Source: https://github.com/python/peps/blob/main/peps/pep-0572.rst

Last modified: 2023-10-11 12:05:51 GMT

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 operators.

Operators are used to perform operations on variables and values.

In the example below, we use the + operator to add together two values:

Python divides the operators in the following groups:

Arithmetic operators
Assignment operators
Comparison operators
Logical operators
Identity operators
Membership operators
Bitwise operators

Python Arithmetic Operators

Arithmetic operators are used with numeric values to perform common mathematical operations:

Python Assignment Operators

Assignment operators are used to assign values to variables:

Python Comparison Operators

Comparison operators are used to compare two values:

Python Logical Operators

Logical operators are used to combine conditional statements:

Python Identity Operators

Identity operators are used to compare the objects, not if they are equal, but if they are actually the same object, with the same memory location:

Python Membership Operators

Membership operators are used to test if a sequence is presented in an object:

Python Bitwise Operators

Bitwise operators are used to compare (binary) numbers:

Operator Precedence

Operator precedence describes the order in which operations are performed.

Parentheses has the highest precedence, meaning that expressions inside parentheses must be evaluated first:

Multiplication * has higher precedence than addition + , and therefor multiplications are evaluated before additions:

The precedence order is described in the table below, starting with the highest precedence at the top:

If two operators have the same precedence, the expression is evaluated from left to right.

Addition + and subtraction - has the same precedence, and therefor we evaluate the expression from left to right:

Test Yourself With Exercises

Multiply 10 with 5 , and print the result.

Start the Exercise

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]

A Comprehensive Guide to Augmented Assignment Operators in Python

Augmented assignment operators are a vital part of the Python programming language. These operators provide a shortcut for assigning the result of an operation back to a variable in an expressive and efficient manner.

In this comprehensive guide, we will cover the following topics related to augmented assignment operators in Python:

What are augmented assignment operators, arithmetic augmented assignments, bitwise augmented assignments, sequence augmented assignments, advantages of augmented assignment operators, augmented assignment with mutable types, operator precedence and order of evaluation, updating multiple references, augmented assignment vs normal assignment, comparisons to other languages, best practices and style guide.

Augmented assignment operators are a shorthand technique that combines an arithmetic or bitwise operation with an assignment.

The augmented assignment operator performs the operation on the current value of the variable and assigns the result back to the same variable in a compact syntax.

For example:

Here x += 3 is equivalent to x = x + 3 . The += augmented assignment operator adds the right operand 3 to the current value of x , which is 2 . It then assigns the result 5 back to x .

This shorthand allows you to reduce multiple lines of code into a concise single line expression.

Some key properties of augmented assignment operators in Python:

Operators act inplace directly modifying the variable’s value
Work on mutable types like lists, sets, dicts unlike normal operators
Generally have equivalent compound statement forms using standard operators
Have right-associative evaluation order unlike arithmetic operators
Available for arithmetic, bitwise, and sequence operations

Now let’s look at the various augmented assignment operators available in Python.

Augmented Assignment Operators List

Python supports augmented versions of all the arithmetic, bitwise, and sequence assignment operators.

These perform the standard arithmetic operations like addition or exponentiation and assign the result back to the variable.

These allow you to perform bitwise AND, OR, XOR, right shift, and left shift operations combined with assignment.

The += operator can also be used to concatenate sequences like lists, tuples, and strings.

These operators provide a shorthand for sequence concatenation.

Some key advantages of using augmented assignment operators:

Conciseness : Performs an operation and assignment in one concise expression rather than multiple lines or steps.

Readability : The operator itself makes the code’s intention very clear. x += 3 is more readable than x = x + 3 .

Efficiency : Saves executing multiple operations and creates less intermediate objects compared to chaining or sequencing the operations. The variable is modified in-place.

For these reasons, augmented assignments should be preferred over explicit expansion into longer compound statements in most cases.

Some examples of effective usage:

Incrementing/decrementing variables: index += 1
Accumulating sums: total += price
Appending to sequences: names += ["Sarah", "John"]
Bit masking tasks: bits |= 0b100

So whenever you need to assign the result of some operation back into a variable, consider using the augmented version.

Common Mistakes to Avoid

While augmented assignment operators are very handy, some common mistakes can occur:

Augmented assignments act inplace and modify the existing object. This can be problematic with mutable types like lists:

In contrast, normal operators with immutable types create a new object:

So be careful when using augmented assignments with mutable types, as they modify the object in-place rather than creating a new object.

Augmented assignment operators have right-associativity. This can cause unexpected results:

The right-most operation y += 1 is evaluated first updating y. Then x += y uses the new value of y.

To avoid this, use parenthesis to control order of evaluation:

When you augmented assign to a variable, it updates all references to that object:

y also reflects the change since it points to the same mutable list as x .

To avoid this, reassign the variable rather than using augmented assignment:

While the augmented assignment operators provide a shorthand, they differ from standard assignment in some key ways:

Inplace modification : Augmented assignment acts inplace and modifies the existing variable rather than creating a new object.

Mutable types : Works directly on mutable types like lists, sets, and dicts unlike normal assignment.

Order of evaluation : Has right-associativity unlike left-associativity of normal assignment.

Multiple references : Affects all references to a mutable object unlike normal assignment.

In summary, augmented assignment operators combine both an operation and assignment but evaluate differently than standard operators.

Augmented assignments exist in many other languages like C/C++, Java, JavaScript, Go, Rust, etc. Some key differences to Python:

In C/C++ augmented assignments return the assigned value allowing usage in expressions unlike Python which returns None .

Java and JavaScript don’t allow augmented assignment with strings unlike Python which supports += for concatenation.

Go doesn’t have an increment/decrement operator like ++ and -- . Python’s += 1 and -= 1 serves a similar purpose.

Rust doesn’t allow built-in types like integers to be reassigned with augmented assignment and requires mutable variables be defined with mut .

So while augmented assignment is common across languages, Python provides some unique behaviors to be aware of.

Here are some best practices when using augmented assignments in Python:

Use whitespace around the operators: x += 1 rather than x+=1 for readability.

Limit chaining augmented assignments like x = y = 0 . Use temporary variables if needed for clarity.

Don’t overuse augmented assignment especially with mutable types. Reassignment may be better if the original object shouldn’t be changed.

Watch the order of evaluation with multiple augmented assignments on one line due to right-associativity.

Consider parentheses for explicit order of evaluation: x += (y + z) rather than relying on precedence.

For increments/decrements, prefer += 1 and -= 1 rather than x = x + 1 and x = x - 1 .

Use normal assignment for updating multiple references to avoid accidental mutation.

Following PEP 8 style, augmented assignments should have the same spacing and syntax as normal assignment operators. Just be mindful of potential pitfalls.

Augmented assignment operators provide a compact yet expressive shorthand for modifying variables in Python. They combine an operation and assignment into one atomic expression.

Key takeaways:

Augmented operators perform inplace modification and behave differently than standard operators in some cases.

Know the full list of arithmetic, bitwise, and sequence augmented assignment operators.

Use augmented assignment to write concise and efficient updates to variables and sequences.

Be mindful of right-associativity order of evaluation and behavior with mutable types to avoid bugs.

I hope this guide gives you a comprehensive understanding of augmented assignment in Python. Use these operators appropriately to write clean, idiomatic Python code.

python
variables-and-operators

School Guide
Class 11 Syllabus
Class 11 Revision Notes
Maths Notes Class 11
Physics Notes Class 11
Chemistry Notes Class 11
Biology Notes Class 11
NCERT Solutions Class 11 Maths
RD Sharma Solutions Class 11
Math Formulas Class 11
NCERT Notes for Class 11 Biology Chapter 19: Chemical Coordination and Integration
NCERT Solutions Class 10 Social Science Civics Chapter 2 : Federalism
Political Parties Class 10 Notes Civics Chapter 6
Challenges to Democracy Class 10 Notes Civics Chapter 8
Gender, Religion and Caste Class 10 Notes Chapter 4 Civics
Normal Goods and Inferior Goods
Types of Demand
Difference between Returns to Factor and Returns to Scale
Coefficient of Variation: Meaning, Formula and Examples
Methods of Constructing Consumer Price Index (CPI)
Paasche's Method of calculating Weighted Index Number
Factors Affecting the Choice of the Source of Funds
International Business : Meaning, Scope and Benefits
Steps in the Formation of a Company
Business : Characteristics, Objectives and Classification
Some Systems executing Simple Harmonic Motion
Relation and Function
Operations on Sets

Definition, Types & Methods to Promote Equality Class 11 Polity Notes

Equality means treating everyone fairly. It is about giving everyone the same rights, chances, and opportunities, no matter who they are. Being fair and making sure everyone has what they need to be happy is what equality is all about. It is the belief that everyone should be treated with kindness and respect. Equality means giving everyone a fair chance and not being unfair to them.

In this article, we will discuss Definitions, Types & Methods to Promote Equality in detail.

Definition Of Equality

Equality is the state of being equal. Equality means everyone has the same rights, chances, and opportunities, no matter who they are. It is about being fair and making sure everyone gets what they need to live well.

Making sure everyone is treated fairly and equally is important. This means being nice to everyone is important, no matter where they come from. It’s about appreciating and including every culture and religion. We should give everyone the same chances to do well and achieve their dreams.

Different Types Of Promoting Equality

Equality or treating everyone fairly is crucial in many aspects of life, such as society, politics, and money. While different areas might see equality differently, the main idea is always fairness for all.

Here are the Different Types of Equality as mentioned below.

Methods to Promote Equality

Making sure things are fair and equal for everyone is important. This means treating everyone nicely, no matter where they come from. It’s about making sure we appreciate and include all cultures and religions. We should give everyone an equal opportunity to do well and achieve what they want. When we do this, we help people develop and be their best. It’s also important to teach people why equality is important so they see how it helps make society better.

1. Implementing Inclusive Policies

To make things fair for everyone, it’s important to have inclusive rules. These rules help stop unfair treatment and give everyone a fair chance, whether it’s at work, school, or getting help from services. This means people won’t miss out on opportunities because of where they come from or who they are.

Key Aspects of Inclusive Policies:

Affirmative Action: Steps are taken to make sure everyone, especially those from groups who don’t often get chances, have the same opportunities. Equal Pay: Making sure people get paid the same for doing the same job, no matter if they’re a man, woman, or from a different background. Non-discrimination Policies: These are rules made to stop treating people unfairly because of things like their race, gender, age, religion, who they like, or if they have a disability.

2. Educating and Raising Awareness

Education is important for making things fair for everyone. It’s not just about learning in school but also teaching people why fairness matters, why discrimination is bad, and why a fair society is good. Doing workshops, talks, and using the media can help people understand and start treating each other better.

Key Aspects of Education and Awareness:

Understanding Different Cultures: Teaching about different cultures helps people respect each other and brings different groups together. Learning About Rights: Knowing about rights and what we should do helps everyone feel like they’re part of society and treated fairly. Respecting All Genders: By questioning stereotypes and promoting respect for everyone, this training helps make sure men and women are treated equally.

3. Legal Frameworks and Enforcement

Making strong laws is important for making sure everyone is treated fairly. These laws should protect people from being treated unfairly, give everyone the same chances, and help those who are treated unfairly. But just having laws isn’t good enough. We need to make sure these rules are followed properly.

Anti-discrimination Laws: These laws stop unfair treatment because of differences like race, gender, age, disability, or religion. Equal Opportunity Laws: These laws make sure everyone can have the same chances for jobs, education, and social benefits. Strong Law Enforcement: Good enforcement of laws is important to make sure people follow the rules about fairness and equality.

4. Encouraging Participation and Representation

Encouraging everyone to join in helps make things fairer, especially for those who are often left out. When everyone gets to share their thoughts, decisions can be made that think about everyone’s needs. Having people from different backgrounds in charge, in politics, and on TV can also help make things fairer by showing different kinds of people and giving them a say.

Political Participation: Encouraging people from all backgrounds to join politics and have a say in decisions ensures everyone’s needs are heard. Diverse Leadership: Having different kinds of people in charge can fight unfair beliefs and make things fairer for everyone. Representation in Media: Showing different people in media can stop unfair ideas and help everyone see each other as equals.

FAQs – Definition, Types & Methods to Promote Equality 11 Polity Notes

What is the meaning definition and types of equality.

Equality means ensuring that everyone has an equal chance to make the most of their life and abilities. It also means that no one should be denied opportunities in life regardless of their sex, belief, thought, or religion.

What is the best definition for equality?

Equality refers to providing equal opportunities to everyone and protecting people from being discriminated against. Diversity refers to recognising and respecting and valuing differences in people.

What does promoting equality mean?

Equality means ensuring everyone in your setting has equal opportunities, regardless of their abilities, their background or their lifestyle. Diversity means appreciating the differences between people and treating people’s values, beliefs, cultures and lifestyles with respect.

What are main features of equality?

No discrimination is made with anybody on the basis of his caste, religion, colour, creed etc. 2. Prohibition of Discriminations-The main characteristic of the social equality is not to make any discrimination on the basis of caste, religion, colour, race etc.

Why do we promote equality?

The fundamental goal when promoting equality is to raise awareness and make sure that all individuals are treated equally and fairly. This is regardless of their age, gender, religion, disability, sexual orientation, or race.

How is equality promoted in India?

Equality, as guaranteed in our Constitution not only provides formal equality but also substantive equality by making special provisions for disadvantaged sections of society to bring them to an equal plane.

What are the various types of equality?

While identifying different kinds of inequalities that exist in society, various thinkers and ideologies have highlighted three main dimensions of equality namely, political, social and economic.

What is a good example of equality?

For example, equality would be giving everyone the same type of ladder to pick mangoes at the top of a tree. Equity would be realising that not everyone can use the same type of ladder and providing another way for them to reach the mangoes at the top of the tree.

What is the significance of equality in society?

Equality is fundamental to a just and fair society. It ensures that everyone gets a fair chance to succeed and is not discriminated against based on their race, religion, gender, or economic status. It promotes social cohesion and stability, contributing to peace and harmony in society.

How does political equality impact in democracy?

Political equality is a cornerstone of democracy. It ensures that every citizen has the right to vote, voice their opinion, and participate in the decision-making process. This fosters a more participatory and representative government, thereby strengthening the democratic system.

How is social equality different from economic equality?

While social equality focuses on ensuring equal status and rights for all individuals in society, economic equality emphasizes a fair distribution of wealth and resources. Although they are different, both forms of equality often intersect in many ways as economic disparities can often lead to social inequalities.

Please Login to comment...

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

IMAGES

Python Tutorials: Assignment Operators In python
Python Operator
Operators and Types of Operators
Python For Beginners
7 Types of Python Operators that will ease your programming
Assignment Operator in Python

VIDEO

Assignment
Class 21
Python Assignment Operator: Beginner's Guide by ByteAdmin
Augmented assignment Operator
Assignment Operators In Python With Example
Python Membership operators# Part-3 #learnpython #python3#pythonoperators#pythonforbeginners

COMMENTS

Assignment Operators in Python
Operators are used to perform operations on values and variables. These are the special symbols that carry out arithmetic, logical, bitwise computations. The value the operator operates on is known as Operand. Here, we will cover Assignment Operators in Python. So, Assignment Operators are used to assigning values to variables.
Python's Assignment Operator: Write Robust Assignments
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.
Python Assignment Operators
Python Assignment Operators. Assignment operators are used to assign values to variables: Operator. Example. Same As. Try it. =. x = 5. x = 5.
What is Assignment Operator in Python?
The assignment operator in Python is used as the "=" symbol. Let's see a very basic example of the assignment operator. Table Of Assignment Operators. Here we will see different assignment operators in Python with their names, descriptions, and syntax. Let's take them one by one. Operator Name
Operators and Expressions in Python
The assignment operator is one of the most frequently used operators in Python. The operator consists of a single equal sign ( = ), and it operates on two operands. The left-hand operand is typically a variable , while the right-hand operand is an expression.
Python Assignment Operators: Explained With Examples
Python assignment operators facilitate the storage of a value in a variable by assigning the value on the right side of the operator to the variable on the left. This process is vital in programming because it enables developers to save data in variables for later use within their programs. Operator Operation
Python Assignment Operators
print(num) Run. The above code is useful when we want to update the same number. We can also use two different numbers and use the assignment operators to apply them on two different values. num_one = 6. num_two = 3. print(num_one) num_one += num_two. print(num_one)
Assignment Expressions: The Walrus Operator
In this lesson, you'll learn about the biggest change in Python 3.8: the introduction of assignment expressions.Assignment expression are written with a new notation (:=).This operator is often called the walrus operator as it resembles the eyes and tusks of a walrus on its side.. Assignment expressions allow you to assign and return a value in the same expression.
Assignment Operator in Python
The simple assignment operator is the most commonly used operator in Python. It is used to assign a value to a variable. The syntax for the simple assignment operator is: variable = value. Here, the value on the right-hand side of the equals sign is assigned to the variable on the left-hand side. For example.
Python Assignment Operators
In Python, an assignment operator is used to assign a value to a variable. The assignment operator is a single equals sign (=). Here is an example of using the assignment operator to assign a value to a variable: x = 5. In this example, the variable x is assigned the value 5. There are also several compound assignment operators in Python, which ...
Python Assignment Operator
Python comes with a couple of shorthand assignment operators. Some of the most common ones include the following: Operator. Meaning. +=. Add the value on the right to the variable on the left. -=. Subtract the value on the right from the variable on the left. *=.
Different Assignment operators in Python
The Simple assignment operator in Python is denoted by = and is used to assign values from the right side of the operator to the value on the left side. Input: a = b + c. Add and equal operator. This operator adds the value on the right side to the value on the left side and stores the result in the operand on the left side. Input: a = 5. a += 10.
The Python assignment operator, function definitions, and variable
0. As you've discovered, the = operator in Python doesn't make a copy of an object like it does in C++ for example. If you want to make a copy to store in another variable you have to be explicit about it. board[1] = deck1[:] # the slicing operator copies a subset or the whole list. A more general method is to use the copy module.
Assignment Operators in Python
The primary assignment operator is the simple assignment operator ("="). We then learned that Python supports more complex assignment operators that can be used to calculate values in place. The assignment operators can be used to calculate mathematical, logical, and bitwise operations.
PEP 572
Unparenthesized assignment expressions are prohibited for the value of a keyword argument in a call. Example: foo(x = y := f(x)) # INVALID foo(x=(y := f(x))) # Valid, though probably confusing. This rule is included to disallow excessively confusing code, and because parsing keyword arguments is complex enough already.
Python Operators
Python Identity Operators. Identity operators are used to compare the objects, not if they are equal, but if they are actually the same object, with the same memory location: Operator. Description. Example. Try it. is. Returns True if both variables are the same object. x is y.
A Comprehensive Guide to Augmented Assignment Operators in Python
The augmented assignment operator performs the operation on the current value of the variable and assigns the result back to the same variable in a compact syntax. For example: Here x += 3 is equivalent to x = x + 3. The += augmented assignment operator adds the right operand 3 to the current value of x, which is 2.
Is assignment an operator in Python?
6. No. An assignment is always a statement in Python. That's why things like assignment within if statements, which is acceptable in some other languages, is forbidden in Python. It may be worth noting that you can chain assignments, which makes it look sort of like assignment is an operator, but that's not what's actually happening there.
Definition of "operator", and by extension "operand", in Python terminology
In Python += is called one of the augmented assignment operators and in my mind, if something is an operator, whatever it operates on is an operand. I.e. fot and [duk] above are operands of the += operator. However, it's been 15 years since I took a course on programming languages from a more formal point of view, so I might have forgotten a ...
Definition, Types & Methods to Promote Equality Class ...
Here are the Different Types of Equality as mentioned below. Aspect. Social Equality. Political Equality. Civil Equality. Economic Equality. Definition. A state where everyone has the same basic rights, protections, opportunities, and social benefits, regardless of their background. Equal distribution of political power among citizens.
Is it possible to override the assignment ('=') operator in Python?
I think this would violate Python's object model or variable/naming scheme. A name does not represent one object only, but just points to an object under the hood. Using the assignment operator just changes the object a name points to. -

What is Assignment Operator in Python?

Table Of Assignment Operators

Assignment Operator :

Addition Assignment Operator :

Subtraction Assignment Operator :

Multiplication Assignment Operator:

Division Assignment Operator :

Modulus Assignment Operator :

Exponentiation Assignment Operator :

Floor Division Assignment Operator :

Bitwise AND Assignment Operator :

Bitwise OR Assignment Operator:

Bitwise XOR Assignment Operator:

Bitwise Right Shift Assignment Operator :

Bitwise Left Shift Assignment Operator:

Learn More:

Assignment Operators

Sign in to your account

Login via OTP

Register with PrepBytes

What is an Assignment Operator in Python?

Types of Assignment Operator in Python

1. Simple Assignment Operator (=)

2. Addition Assignment Operator (+=)

3. Subtraction Assignment Operator (-=)

4. Multiplication Assignment Operator (*=)

5. Division Assignment Operator (/=)

6. Modulus Assignment Operator (%=)

7. Floor Division Assignment Operator (//=)

8. Exponentiation Assignment Operator (**=)

9. Bitwise AND Assignment Operator (&=)

10. Bitwise OR Assignment Operator (|=)

11. Bitwise XOR Assignment Operator (^=)

12. Bitwise Right Shift Assignment Operator (>>=)

13. Bitwise Left Shift Assignment Operator (<<=)

Leave a Reply Cancel reply

Related Post

Python Assignment Operators

Python Assignment Operator

Chained Assignment

Different Assignment Methods

Summary: Python Assignment Operator

Assignment Operators in Python

What Are Operators and Operands?

What Are the Basics of Assignments?

The simple assignment operator “=”

Updating values

Multiple and parallel assignments

Augmented assignment operators in Python

Add assignment operator “+=”

Subtract assignment operator

Multiplication assignment operator

Division assignment operator

Floor assignment operator

Modulus assignment operator

Exponentiation assignment operator

Bitwise AND assignment operator

Bitwise OR assignment operator

Bitwise XOR assignment operator

Bitwise Left Shift assignment operator

Bitwise Right Shift assignment operator

Sounetra Ghosal

Programming Help Expertise

Important Links

Python Enhancement Proposals

PEP 572 – Assignment Expressions

Syntax and semantics

Examples from the Python standard library

Rejected alternative proposals

Frequently Raised Objections

Appendix A: Tim Peters’s findings

Python Tutorial

Python Arithmetic Operators

Python Assignment Operators

Python Comparison Operators

Python Logical Operators

Python Identity Operators

Python Membership Operators

Python Bitwise Operators

Operator Precedence