# Inplace vs Standard Operators in Python

## Inplace Operator in Python

Inplace operation is an operation which directly changes the content of a given linear algebra or vector or metrices without making a copy. Now the operators, which helps to do this kind of operation is called in-place operator.

Let’s understand it with an a simple example -

a=9
a += 2
print(a)

## output

11

Above the += tie input operator. Here first, a add 2 with that a value is updated the previous value.

Above principle applies to other operators also. Common in place operators are -

• +=
• -=
• *=
• /=
• %=

Above principle applies to other types apart from numbers, for example -

language = "Python"
language +="3"
print(language)

## Output

Python3

Above example of x+=y is equivalent to x = operator.iadd(x,y)

There are multiple operators which are used for inplace operations.

This function is used to assign the current value and add them. This operator does x+=y operation.

x =operator.iadd(9,18)
print(x)

## Result

Result after adding: 27

## isub()

This function is used to assign the current value and subtract them. Isub() function does x-=y operation.

x =operator.isub(9,18)
print("Result after subtraction: ", end="")
print(x)

## Result

Result after subtraction: -9

## imul()

This function is used to assign the current value and multiply them. This operator does x*=y operation.

x =operator.imul(9,18)
print("Result after multiplying: ", end="")
print(x)

## Result

Result after multiplying: 162

## itruediv()

This function is used to assign the current value and divide them. This operator does x/=y operation.

x =operator.itruediv(9,18)
print("Result after dividing: ", end="")
print(x)

## Result

Result after dividing: 0.5

## imod()

this function is used to assign the current value and divide them. This operator does x %=y operation.

x =operator.imod(9,18)
print("Result after moduls: ", end="")
print(x)

## Result

Result after moduls: 9

## iconcat()

This function is used to concatenate two strings.

x = "Tutorials"
y = "Point"

str1 = operator.iconcat(x,y)
print(" After concatenation : ", end="")
print(str1)

## Result

After concatenation : TutorialsPoint

## ipow()

This function is equivalent to x **=y.

x =operator.ipow(2,6)
print("Result after exponent: ", end="")
print(x)

## Result

Result after exponent: 64

## Standard Operators

Operators are the constructs which can manipulate the value of operands.

For example in the expression- 9+18 = 27, here 9 and 18 are operands and + is called operator.

Types of Operator

Python language supports the following types of operators -

• Arithmetic Operators: (for example: +, -, *, /, %, **, //)

• Comparision Operators: (for example: “==”, “!=”, “<>”, “>”, “<”, “>=”, “<=”)

• Assignment Operators: (for example: “=”, “+=”, “-=”, “*=”, “/=”, “%=”, “**=”, “//=”)

• Logical Operators: (for example: “Logical AND”, “Logical OR”, “Logical NOT”)

• Bitwise Operators: (for example: “|”, “&”, “^”, “~”, “<<”, “>>”)
• Membership Operators: (for example: in, not in)

• Identity Operators: (for example: is, is not)

## Mapping Operators to Functions

Below is a table showing how abstract operations correspond to operator symbols in the Python syntax and the functions in the operator module.

Operation
Syntax
Function
x + y
Concatenation
Seq1 + seq2
Concat(seq1, seq2)
Containment Test
Obj in seq
Contains(seq, obj)
Division
x / y
Truediv(x, y)
Division
x // y
Floordiv(x, y)
Bitwise And
x & y
And_(x, y)
Bitwise Exclusive Or
x ^ y
Xor(x, y)
Bitwise Inversion
~x
Invert(x)
Bitwise Or
x|y
or_(x,y)
Exponentiation
x ** y
pow(x, y)
Identity
x is y
is_(x, y)
Identity
x is not y
is_not(x, y)
Indexed Assignment
obj[k] = v
setitem(obj, k, v)
Indexed deletion
del obj[k]
delitem(obj, k)
Indexing
Obj[k]
Getitem(obj,k)
Left shift
a << b
Lshift(a,b)
Modulo
a % b
Mod(a, b)
Multiplication
x*y
mul(x*y)
Matrix multiplication
x@b
Matmul(x, y)
Negation(Arithmetic)
-a
Neg(a)
Negation(Logical)
not a
not_(a)
Positive
+a
pos(a)
Right shift
a>>b
Rshift(a,b)
Slice Assignment
Seq[i:j] =values
Setitem(seq, slice(i,j), values)
Slice deletion
Del seq[i:j]
Delitem(seq, slice(i,j))
Slicing
Seq[i:j]
Getitem(seq, slice(I, j))
String formatting
S % obj
Mod(s, obj)
Subtraction
a-b
Sub(a,b)
Truth Test
obj
truth(obj)
Ordering
a<b
lt(a,b)
Ordering
a<=b
le(a,b)
Equality
a == b
eq(a,b)
Difference
a != b
ne(a,b)
Ordering
a >= b
ge(a, b)
Ordering
a > b
gt(a, b)