Javatpoint Logo
Javatpoint Logo

In-place vs. Standard Operators in Python


Python provides several operators to perform various operations on variables. These operators can be categorized into two types: in-place operators and standard operators.

Both operators do the same tasks but they differ in their behaviour and impact on underlying data.

In this article, we will explore how they are different from one another and how they behave on data.

1. Standard Operators

Standard operators are also known as non-in-place operators. They are the basic arithmetic and logical operators that most programmers are familiar with.

These operators include:

  • Addition (+)
  • Subtraction (-)
  • Multiplication (*)
  • Division (/)
  • Many more

In operations, where standard operators are used a new value is generated as a result, leaving the original variables unchanged.

Let's consider the following example:


The result, c = 8
a remains unchanged, a = 5
b remains unchanged, b = 3


In the above example of standard addition, the value of c is the sum of a and b, while the original values of a and b remain unchanged.

Let's consider another example to perform standard subtraction, multiplication, and division:


a = 5
b = 3
Standard Subtraction, sub = a-b = 2
Standard Multiplication, mul = a*b = 15
Standard Division, div = a/b = 1.6666666666666667


Here, the result of subtracting b from a is 2, the result of multiplying a and b is 15, and the result of dividing a by b is approximately 1.67. The original value of a and b remains unchanged.

2. In-place Operators

In-place operators perform the operation in place, modifying the original variable itself. These operators are denoted by combining the assignment operator (=) with another operator.

In-place operators include:

  • Addition (+=) - It is equal to the operator.iadd()
  • Subtraction (-=) - It is equal to the operator.isub()
  • Multiplication (*=) - It is equal to the operator.imul()
  • Division (/=) - It is equal to the operator.itruediv()
  • Many more

Let's consider the following example:


The original value of a = 5
The original value of b = 3
a is modified, a = 8


In this example of in-place addition, the value of a is modified by adding the value of b to it. The += operator performs the addition in place, updating the value of a directly.

Let's consider another example of in-place subtraction, multiplication, and division:


a = 5
c = 4
x = 8
In-place Subtraction a -= b, a = 2
In-place Multiplication c *= d, c = 28
In-place Division x /= y, x = 4.0


In this example of in-place operations, the value of a, c, and x is changed while the value of b, d, and y remains unchanged. The value of a is updated to 2 (the result of 5 - 3), c is updated to 28 (the result of 4 * 7), and x is updated to 4.0 (the result of 8 / 2).

Advantages of In-place operators:

The main advantages of in-place operators are as follows:

  • Efficient when working with large datasets - It modifies the original dataset instead of creating a new dataset saving memory and processing time.
  • Useful in dealing with mutable objects - It becomes useful when we require to update mutable objects such as lists and arrays.

Let's consider the following example:


squared_numbers = [1, 4, 9, 16, 25]
Standard Operation:
numbers = [1, 2, 3, 4, 5] # numbers list remains unchanged

In-place Operation:
numbers = [1, 4, 9, 16, 25] # numbers list is modified


In this example, the standard operator ** is used to create a new list squared_numbers. The squared_numbers contains the squared values of the elements in the numbers list. Meanwhile, the in-place operator **= is used to modify the original numbers list directly, squaring each element in place.

When dealing with mutable objects, we can easily modify the elements and improve applications' performance and memory.

Note: All operators have in-place counterparts. In the case when no in-place operators are available, the standard operators must be used.


In Python, there are two types of operators: in-place operators and standard operators.

  • Standard operators include arithmetic and logical operators such as addition, subtraction, multiplication, division, etc.
  • In-place operators combine the assignment operator (=) with another operator, such as +=, -=, *=, /=, and many more.

In-place operators are more efficient when working with large datasets and also useful when dealing with mutable objects like lists and arrays. It's important to choose the appropriate operator based on the requirements of the task and the desired behaviour on the data.

Youtube For Videos Join Our Youtube Channel: Join Now


Help Others, Please Share

facebook twitter pinterest

Learn Latest Tutorials


Trending Technologies

B.Tech / MCA