Python Tutorial

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:

# Declaring two variables a and b
a = 5
b = 3

# Standard addition operator
c = a + b

# Printing result
print("The result, c =", c)
print("a remains unchanged, a =", a)
print("b remains unchanged, b =", b)

Output:

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

Explanation:

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:

# Declaring two variables
a = 5
b = 3

# Standard operations
sub = a - b
mul = a * b
div = a / b

# Printing results
print("a =", a)
print("b =", b)
print("Standard Subtraction, sub = a-b =", sub)
print("Standard Multiplication, mul = a*b =", mul)
print("Standard Division, div = a/b =", div)

Output:

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

Explanation:

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:

# Declaring two variables a and b
a = 5
b = 3

print("The original value of a =", a)
print("The original value of b =", b)

# In-place addition operator
a += b
# The above operation is equal to - import operator
# a = operator.iadd(a, b)

print("a is modified, a =", a)

Output:

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

Explanation:

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:

# Declaring variables
a = 5
b = 3
c = 4
d = 7
x = 8
y = 2

# Original Values
print("a =", a)
print("c =", c)
print("x =", x)

# In-place operations
a -= b
c *= d
x /= y

# The above operations are equal to - import operator
# a = operator.isub(a, b)
# a = operator.imul(a, b)
# a = operator.itruediv(a, b)

# Printing results
print("In-place Subtraction a -= b, a =", a)
print("In-place Multiplication c *= d, c =", c)
print("In-place Division x /= y, x =", x)

Output:

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

Explanation:

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:

# A list of integers
numbers = [1, 2, 3, 4, 5]

# Standard operator
squared_numbers = [num ** 2 for num in numbers]
print("squared_numbers =", squared_numbers)

# numbers remain unchanged
print("Standard Operation:")
print("numbers =", numbers, "# numbers list remains unchanged\n")

# In-place operator
for i in range(len(numbers)):
    numbers[i] **= 2
    # It is equivalent to - import operator
    # numbers[i] = operator.ipow(numbers[i], 2)

# numbers are modified
print("In-place Operation:")
print("numbers =", numbers, "# numbers list is modified")

Output:

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

Explanation:

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.

CONCLUSION:

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.

Next TopicPredicting Rideshare Fares using Python

← prev next →