choose augmented assignment operators)

• Python Programming
• C Programming
• Numerical Methods
• Dart Language
• Computer Basics
• Deep Learning
• C Programming Examples
• Python Programming Examples

Augmented Assignment Operators in Python with Examples

Unlike normal assignment operator, Augmented Assignment Operators are used to replace those statements where binary operator takes two operands says var1 and var2 and then assigns a final result back to one of operands i.e. var1 or var2 .

For example: statement var1 = var1 + 5 is same as writing var1 += 5 in python and this is known as augmented assignment operator. Such type of operators are known as augmented because their functionality is extended or augmented to two operations at the same time i.e. we're adding as well as assigning.

List Of Augmented Assignment Operators in Python

Python has following list of augmented assignment operators:

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:

Table of Contents

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

Python Augmented Assignment: Streamlining Your Code

Python's augmented assignment operators provide a shortcut for assigning the result of an arithmetic or bitwise operation. They are a perfect example of Python's commitment to code readability and efficiency. This blog post delves into the concept of augmented assignment in Python, exploring how these operators can make your code more concise and expressive.

Introduction to Augmented Assignment in Python

Augmented assignment is a combination of a binary operation and an assignment operation. It offers a shorthand way of writing operations that update a variable.

What is Augmented Assignment?

• Simplified Syntax : Augmented assignment operators allow you to perform an operation on a variable and then assign the result back to that variable in one concise step.
• Supported Operations : Python supports augmented assignment for various operations, including arithmetic, bitwise, and more.

Common Augmented Assignment Operators

Here are some of the most commonly used augmented assignment operators in Python:

Arithmetic Operators

Addition ( += ) : Adds a value to a variable.

Subtraction ( -= ) : Subtracts a value from a variable.

Multiplication ( *= ) : Multiplies a variable by a value.

Division ( /= ) : Divides a variable by a value.

Bitwise Operators

Bitwise AND ( &= ) , OR ( |= ) , XOR ( ^= ) : Perform bitwise operations and assign the result.

Other Operators

Modulus ( %= ) , Floor Division ( //= ) , Exponentiation ( **= ) : Useful for more complex mathematical operations.

Advantages of Using Augmented Assignment

Augmented assignment operators not only reduce the amount of code but also improve readability. They indicate an operation that modifies the variable, rather than producing a new value.

Efficiency and Readability

• Less Code : Augmented assignments reduce the verbosity of expressions.
• Clarity : These operators make it clear that the value of the variable is being updated.

Best Practices and Considerations

When using augmented assignment operators, there are a few best practices to keep in mind:

Readability : Ensure the use of augmented assignment enhances the readability of your code.

Mutability : Be cautious with mutable types. Augmented assignments on objects like lists or dictionaries modify the object in place, which can affect other references to the object.

Augmented assignment in Python is a testament to the language's philosophy of simplicity and efficiency. By incorporating these operators into your coding practice, you can write more concise and readable code, reducing the potential for errors and enhancing overall code quality. Whether you are working on mathematical operations, manipulating strings, or performing bitwise operations, augmented assignment operators are valuable tools in the Python programmer’s toolkit.

Unit 1: Augmented Assignment Operators

Table of contents, augmented assignment operators.

A lot of times in programming you’ll need to update a value relative to itself. For instance, when you’re playing a video game and you collect a coin, your score might go up by 5 points relative to what it was before.

In Java, that would look like this (assume a variable score has already been delcared and initialized):

Augmented assignment operators allow us to do that with less typing:

There are augmented assignment operators for each of the arithmetic operators. In the table below, assume var is a variable that has been declared and initialized.

Adventures in Machine Learning

Python increment operations: from augmented assignment to optimizing code.

Python Increment Operations: Understanding

How to Increment a Variable in Python

If you’re new to programming in Python, you may be wondering how to increment a variable. While other programming languages have the “++” operator, Python does not.

This may seem like an inconvenience, but it’s actually a design decision based on the Pythonic way of doing things. In this article, we’ll explore how to increment a variable in Python and the reasoning behind the decision to not include the “++” operator.

In Python, you can increment a variable using the augmented assignment operator “+=”. This operator adds the value on the right side of the operator to the current value of the variable on the left side of the operator.

Let’s take a look at an example:

“`python

print(x) # outputs 6

In this example, we first set the variable x equal to 5. Then we use the “+=” operator to add 1 to the current value of x.

Finally, we print the value of x, which is now 6. It’s worth noting that you can use the augmented assignment operator with other arithmetic operators as well.

For example:

print(x) # outputs 10

In this example, we use the “*=” operator to multiply the current value of x by 2, effectively doubling its value. The Absence of the “++” Operator in Python

As mentioned earlier, Python does not have the “++” operator.

So why not? The answer lies in the Pythonic way of doing things.

Python is designed to be a simple, readable, and expressive language. The absence of the “++” operator is just one example of this philosophy.

When you write code in Python, you should strive to make it as clear and concise as possible. Using the “+=” operator to increment a variable is a simple and clear way to do this.

On the other hand, the “++” operator can be ambiguous and confusing, especially for newer programmers. Reasoning Behind the Decision to Not Include “++” Operator

The decision to not include the “++” operator in Python was a deliberate one.

Guido van Rossum, the creator of Python, has explained the reasoning behind this decision:

“I reject the ++ and — operators from C and C++. There is no good reason to use them, and they increase the risk of silly mistakes.”

This is a sentiment that many seasoned Python programmers echo.

By using the “+=” operator to increment a variable, you can avoid a lot of potential mistakes.

Examples of Python Incrementation

Now that we’ve covered the basics of incrementing a variable in Python, let’s take a look at some examples. Example 1: Incrementing an Integer Variable

In this example, we increment an integer variable named x by 1. The output will be 11.

Example 2: Appending to a String Using “+=”

name = “John”

name += ” Doe”

print(name)

In this example, we append the string “Doe” to the original string “John” using the “+=” operator. The output will be “John Doe”.

Example 3: Attempting to Use “++” Operator

In this example, we attempt to use the “++” operator to increment the variable x by 1. However, this will result in a syntax error.

If you try to run this code, you’ll get an error message that says:

“SyntaxError: invalid syntax”

This error occurs because Python does not recognize the “++” operator.

In summary, while Python does not have the “++” operator, you can still easily increment a variable using the augmented assignment operator “+=”. By using this operator instead of the “++” operator, you can write code that is clearer and less prone to errors.

Remember, in Python, it’s all about simplicity and readability. By following these principles, you can write code that is easy to understand and easy to maintain.

Evaluating Python Augmented Assignment Operator: Understanding its Difference from Regular Assignment and

Optimizing Code at Runtime

In Python, there are two ways to assign values to variables: regular assignment and augmented assignment. Regular assignment simply assigns a value to a variable, whereas augmented assignment combines an assignment operation with an arithmetic or bitwise operation.

In this article, we’ll explore the difference between these two types of assignment and the importance of understanding them in optimizing code at runtime.

Difference between Regular Assignment and Augmented Assignment

Regular assignment is the most basic form of assignment in Python. Here’s an example:

This assigns the integer value 5 to the variable x.

The value of x is now 5. Augmented assignment, on the other hand, combines an assignment operation with an arithmetic or bitwise operation.

Here are some examples:

In each of these examples, we are both assigning a value to a variable and performing an arithmetic or bitwise operation at the same time. Note that the augmented assignment operator (e.g. “+=”) always comes after the variable name.

Precedence of Left Side Evaluation Before Right Side

It’s important to understand the order in which Python evaluates augmented assignments. The left-hand side of an augmented assignment is evaluated before the right-hand side.

This means that if you reference the variable being incremented in the same expression, the old value will be used on the right-hand side. Here’s an example to illustrate this:

print(x) # outputs 12

In this example, we first set the value of x to 5. Then, we use the “+=” operator to increment x by the result of an expression.

The expression on the right-hand side is evaluated after the original value of x (i.e. 5) is used on the left-hand side. So, the expression on the right-hand side evaluates to 7, and the sum of that with the original value of x (5) is 12.

Augmented assignment can be useful for optimizing code at runtime. For example, consider the following code:

for i in range(10):

In this code, we initialize the variable x to 0, and then we use a loop to add the values of i (0 to 9) to x. This is a common pattern in Python, and it can be optimized using augmented assignment.

Here’s the optimized code:

# equivalent to x = x + i

This code is functionally the same as the previous example, but it’s more efficient. By using augmented assignment instead of regular assignment, we avoid creating a temporary variable to hold the result of the addition operation.

Alternative to the “++” Operator in Python

As we’ve seen, augmented assignment is a simple and clear way to increment a variable in Python. The absence of the “++” operator is a byproduct of the Pythonic way of doing things, which prioritizes simplicity, readability, and expressiveness.

By using augmented assignment, we can avoid ambiguity and potential errors in our code.

Importance of Understanding Python Increment Operation

Understanding how to increment a variable in Python is an important skill for any Python programmer. By using augmented assignment instead of the “++” operator, we can write code that is clearer, less prone to errors, and more efficient.

By understanding the difference between regular assignment and augmented assignment, as well as the order in which Python evaluates augmented assignments, we can optimize our code at runtime and make our programs more efficient. In conclusion, this article has explored the difference between regular assignment and augmented assignment in Python.

Augmented assignment is a simple and clear way to increment a variable and can be more efficient than regular assignment. By understanding how Python evaluates augmented assignments, we can optimize our code at runtime.

Additionally, the absence of the “++” operator in Python is a byproduct of the Pythonic way of doing things, which prioritizes simplicity and readability. The key takeaway from this article is the importance of understanding Python increment operation to write clear, efficient, and error-free code.

Popular Posts

Transforming data for optimal performance: normalizing numpy arrays for machine learning, mastering text file parsing in python, boost your python performance with mmap memory mapping.

• Terms & Conditions
• Privacy Policy

Python Essentials by Steven F. Lott

Get full access to Python Essentials and 60K+ other titles, with a free 10-day trial of O'Reilly.

There are also live events, courses curated by job role, and more.

Augmented assignment

The augmented assignment statement combines an operator with assignment. A common example is this:

This is equivalent to

When working with immutable objects (numbers, strings, and tuples) the idea of an augmented assignment is syntactic sugar. It allows us to write the updated variable just once. The statement a += 1 always creates a fresh new number object, and replaces the value of a with the new number object.

Any of the operators can be combined with assignment. The means that += , -= , *= , /= , //= , %= , **= , >>= , <<= , &= , ^= , and |= are all assignment operators. We can see obvious parallels between sums using += , and products using *= .

In the case of mutable objects, this augmented assignment can take on special ...

Get Python Essentials now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Don’t leave empty-handed

Get Mark Richards’s Software Architecture Patterns ebook to better understand how to design components—and how they should interact.

It’s yours, free.

Check it out now on O’Reilly

Dive in for free with a 10-day trial of the O’Reilly learning platform—then explore all the other resources our members count on to build skills and solve problems every day.

Python Enhancement Proposals

• Python »
• PEP Index »

PEP 203 – Augmented Assignments

Introduction, proposed semantics, new methods, implementation, open issues.

This PEP describes the augmented assignment proposal for Python 2.0. This PEP tracks the status and ownership of this feature, slated for introduction in Python 2.0. It contains a description of the feature and outlines changes necessary to support the feature. This PEP summarizes discussions held in mailing list forums [1] , and provides URLs for further information where appropriate. The CVS revision history of this file contains the definitive historical record.

The proposed patch that adds augmented assignment to Python introduces the following new operators:

They implement the same operator as their normal binary form, except that the operation is done in-place when the left-hand side object supports it, and that the left-hand side is only evaluated once.

They truly behave as augmented assignment, in that they perform all of the normal load and store operations, in addition to the binary operation they are intended to do. So, given the expression:

The object x is loaded, then y is added to it, and the resulting object is stored back in the original place. The precise action performed on the two arguments depends on the type of x , and possibly of y .

The idea behind augmented assignment in Python is that it isn’t just an easier way to write the common practice of storing the result of a binary operation in its left-hand operand, but also a way for the left-hand operand in question to know that it should operate on itself , rather than creating a modified copy of itself.

To make this possible, a number of new hooks are added to Python classes and C extension types, which are called when the object in question is used as the left hand side of an augmented assignment operation. If the class or type does not implement the in-place hooks, the normal hooks for the particular binary operation are used.

So, given an instance object x , the expression:

tries to call x.__iadd__(y) , which is the in-place variant of __add__ . If __iadd__ is not present, x.__add__(y) is attempted, and finally y.__radd__(x) if __add__ is missing too. There is no right-hand-side variant of __iadd__ , because that would require for y to know how to in-place modify x , which is unsafe to say the least. The __iadd__ hook should behave similar to __add__ , returning the result of the operation (which could be self ) which is to be assigned to the variable x .

For C extension types, the hooks are members of the PyNumberMethods and PySequenceMethods structures. Some special semantics apply to make the use of these methods, and the mixing of Python instance objects and C types, as unsurprising as possible.

In the generic case of x <augop> y (or a similar case using the PyNumber_InPlace API functions) the principal object being operated on is x . This differs from normal binary operations, where x and y could be considered co-operating , because unlike in binary operations, the operands in an in-place operation cannot be swapped. However, in-place operations do fall back to normal binary operations when in-place modification is not supported, resulting in the following rules:

If coercion does not yield a different object for x , or x does not define a __coerce__ method, and x has the appropriate __ihook__ for this operation, call that method with y as the argument, and the result of the operation is whatever that method returns.

Note that no coercion on either x or y is done in this case, and it’s perfectly valid for a C type to receive an instance object as the second argument; that is something that cannot happen with normal binary operations.

• Otherwise, process it exactly as a normal binary operation (not in-place), including argument coercion. In short, if either argument is an instance object, resolve the operation through __coerce__ , __hook__ and __rhook__ . Otherwise, both objects are C types, and they are coerced and passed to the appropriate function.
• If no way to process the operation can be found, raise a TypeError with an error message specific to the operation.
• Some special casing exists to account for the case of + and * , which have a special meaning for sequences: for + , sequence concatenation, no coercion what so ever is done if a C type defines sq_concat or sq_inplace_concat . For * , sequence repeating, y is converted to a C integer before calling either sq_inplace_repeat and sq_repeat . This is done even if y is an instance, though not if x is an instance.

The in-place function should always return a new reference, either to the old x object if the operation was indeed performed in-place, or to a new object.

There are two main reasons for adding this feature to Python: simplicity of expression, and support for in-place operations. The end result is a tradeoff between simplicity of syntax and simplicity of expression; like most new features, augmented assignment doesn’t add anything that was previously impossible. It merely makes these things easier to do.

Adding augmented assignment will make Python’s syntax more complex. Instead of a single assignment operation, there are now twelve assignment operations, eleven of which also perform a binary operation. However, these eleven new forms of assignment are easy to understand as the coupling between assignment and the binary operation, and they require no large conceptual leap to understand. Furthermore, languages that do have augmented assignment have shown that they are a popular, much used feature. Expressions of the form:

are common enough in those languages to make the extra syntax worthwhile, and Python does not have significantly fewer of those expressions. Quite the opposite, in fact, since in Python you can also concatenate lists with a binary operator, something that is done quite frequently. Writing the above expression as:

is both more readable and less error prone, because it is instantly obvious to the reader that it is <x> that is being changed, and not <x> that is being replaced by something almost, but not quite, entirely unlike <x> .

The new in-place operations are especially useful to matrix calculation and other applications that require large objects. In order to efficiently deal with the available program memory, such packages cannot blindly use the current binary operations. Because these operations always create a new object, adding a single item to an existing (large) object would result in copying the entire object (which may cause the application to run out of memory), add the single item, and then possibly delete the original object, depending on reference count.

To work around this problem, the packages currently have to use methods or functions to modify an object in-place, which is definitely less readable than an augmented assignment expression. Augmented assignment won’t solve all the problems for these packages, since some operations cannot be expressed in the limited set of binary operators to start with, but it is a start. PEP 211 is looking at adding new operators.

The proposed implementation adds the following 11 possible hooks which Python classes can implement to overload the augmented assignment operations:

The i in __iadd__ stands for in-place .

For C extension types, the following struct members are added.

To PyNumberMethods :

To PySequenceMethods :

In order to keep binary compatibility, the tp_flags TypeObject member is used to determine whether the TypeObject in question has allocated room for these slots. Until a clean break in binary compatibility is made (which may or may not happen before 2.0) code that wants to use one of the new struct members must first check that they are available with the PyType_HasFeature() macro:

This check must be made even before testing the method slots for NULL values! The macro only tests whether the slots are available, not whether they are filled with methods or not.

The current implementation of augmented assignment [2] adds, in addition to the methods and slots already covered, 13 new bytecodes and 13 new API functions.

The API functions are simply in-place versions of the current binary-operation API functions:

They call either the Python class hooks (if either of the objects is a Python class instance) or the C type’s number or sequence methods.

The new bytecodes are:

The INPLACE_* bytecodes mirror the BINARY_* bytecodes, except that they are implemented as calls to the InPlace API functions. The other two bytecodes are utility bytecodes: ROT_FOUR behaves like ROT_THREE except that the four topmost stack items are rotated.

DUP_TOPX is a bytecode that takes a single argument, which should be an integer between 1 and 5 (inclusive) which is the number of items to duplicate in one block. Given a stack like this (where the right side of the list is the top of the stack):

DUP_TOPX 3 would duplicate the top 3 items, resulting in this stack:

DUP_TOPX with an argument of 1 is the same as DUP_TOP . The limit of 5 is purely an implementation limit . The implementation of augmented assignment requires only DUP_TOPX with an argument of 2 and 3, and could do without this new opcode at the cost of a fair number of DUP_TOP and ROT_* .

The PyNumber_InPlace API is only a subset of the normal PyNumber API: only those functions that are required to support the augmented assignment syntax are included. If other in-place API functions are needed, they can be added later.

The DUP_TOPX bytecode is a conveniency bytecode, and is not actually necessary. It should be considered whether this bytecode is worth having. There seems to be no other possible use for this bytecode at this time.

This document has been placed in the public domain.

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

Last modified: 2023-09-09 17:39:29 GMT

4.2 Augmented Assignment Operators

Chapter table of contents, section table of contents, previous section, next section.

Clare Ivers

Augmented Assignment Operators

I’m writing the following code in the browser console in JavaScript, but the concept and syntax is applicable to a lot of programming languages .

In programming we have a number of mathematical operators that allow us to do the basic functions of maths such as addition, subtraction, multiplication and so forth. They look something like this:

If we bring a variable into the mix to allow for the storage of the result we can make calculations on the variable and assign the result back to itself. For example, if I want to do the above addition with a variable I could do this:

But that’s clunky and x is repeated. It doesn’t have to be like that if I use the augmented assignment operator. The augmented assignment operator sticks an operator to the left of an equals sign to perform the same function as above, but more elegantly:

In the above, the += is doing the same thing as x = x + 5; .

Also, we can do it with all the other arithmetic operators so, for subtraction:

For multiplication:

For division:

For modulus:

The featured Image for this post is a photo by Chris Liverani on Unsplash .

• ← Creating Custom Settings Tab on WooCommerce Settings Page – Product Addon by Category
• Custom WooCommerce Hooks in the Astra Theme →

Leave a Reply Cancel reply

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

• Free Python 3 Tutorial
• Control Flow
• Exception Handling
• Python Programs
• Python Projects
• Python Interview Questions
• Python Database
• Data Science With Python
• Machine Learning with Python
• Solve Coding Problems
• Python Bitwise Operators
• Relational Operators in Python
• Python - Star or Asterisk operator ( * )
• Difference between "__eq__" VS "is" VS "==" in Python
• How To Do Math in Python 3 with Operators?
• Python 3 - Logical Operators
• Understanding Boolean Logic in Python 3
• Logical Operators in Python with Examples
• Modulo operator (%) in Python
• Concatenate two strings using Operator Overloading in Python
• Python Operators
• A += B Assignment Riddle in Python
• Python | Operator.countOf
• Format a Number Width in Python
• New '=' Operator in Python3.8 f-string
• Operator Overloading in Python
• Python | a += b is not always a = a + b
• Python Object Comparison : "is" vs "=="
• Python Arithmetic Operators

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. 

Now Let’s see each Assignment Operator one by one.

1) Assign: This operator is used to assign the value of the right side of the expression to the left side operand.

2) Add and Assign: This operator is used to add the right side operand with the left side operand and then assigning the result to the left operand.

Syntax: 

3) Subtract and Assign: This operator is used to subtract the right operand from the left operand and then assigning the result to the left operand.

Example –

 4) Multiply and Assign: This operator is used to multiply the right operand with the left operand and then assigning the result to the left operand.

 5) Divide and Assign: This operator is used to divide the left operand with the right operand and then assigning the result to the left operand.

 6) Modulus and Assign: This operator is used to take the modulus using the left and the right operands and then assigning the result to the left operand.

7) Divide (floor) and Assign: This operator is used to divide the left operand with the right operand and then assigning the result(floor) to the left operand.

 8) Exponent and Assign: This operator is used to calculate the exponent(raise power) value using operands and then assigning the result to the left operand.

9) Bitwise AND and Assign: This operator is used to perform Bitwise AND on both operands and then assigning the result to the left operand.

10) Bitwise OR and Assign: This operator is used to perform Bitwise OR on the operands and then assigning result to the left operand.

11) Bitwise XOR and Assign:  This operator is used to perform Bitwise XOR on the operands and then assigning result to the left operand.

12) Bitwise Right Shift and Assign: This operator is used to perform Bitwise right shift on the operands and then assigning result to the left operand.

 13) Bitwise Left Shift and Assign:  This operator is used to perform Bitwise left shift on the operands and then assigning result to the left operand.

Please Login to comment...

• Python-Operators
• WhatsApp To Launch New App Lock Feature
• Top Design Resources for Icons
• Node.js 21 is here: What’s new
• Zoom: World’s Most Innovative Companies of 2024
• 30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

What kind of Experience do you want to share?