Python Operators

Learning the operators is an excellent place to start to learn Python. Operators are special symbols that perform specific operations on one or more operands (values) and then return a result. For example, you can calculate the sum of two numbers using an addition (+) operator.

The following image shows operator and operands

Also See:

Python has seven types of operators that we can use to perform different operation and produce a result.

Arithmetic operator
Relational operators
Assignment operators
Logical operators
Membership operators
Identity operators
Bitwise operators

Arithmetic operator
Relational (comparison) operators
Assignment operators
Logical operators
Membership operators
- In operator
- Not in operator
Identity operators
- is operator
- is not operator
Bitwise Operators
Python Operators Precedence

Arithmetic operator

Arithmetic operators are the most commonly used. The Python programming language provides arithmetic operators that perform addition, subtraction, multiplication, and division. It works the same as basic mathematics.

There are seven arithmetic operators we can use to perform different mathematical operations, such as:

+ (Addition)
- (Subtraction)
* (Multiplication)
/ (Division)
// Floor division)
℅ (Modulus)
** (Exponentiation)

Now, let’s see how to use each arithmetic operator in our program with the help of examples.

Addition operator `+`

It adds two or more operands and gives their sum as a result. It works the same as a unary plus. In simple terms, It performs the addition of two or more than two values and gives their sum as a result.

Example

x = 10
y = 40
print(x + y)
# Output 50

Also, we can use the addition operator with strings, and it will become string concatenation.

name = "Kelly"
surname = "Ault"
print(surname + " " + name)
# Output Ault Kelly

Subtraction `-`

Use to subtracts the second value from the first value and gives the difference between them. It works the same as a unary minus. The subtraction operator is denoted by - symbol.

Example

x = 10
y = 40
print(y - x)
# Output 30

Multiplication `*`

Multiply two operands. In simple terms, it is used to multiplies two or more values and gives their product as a result. The multiplication operator is denoted by a * symbol.

Example

x = 2
y = 4
z = 5
print(x * y)
# Output 8 (2*4)
print(x * y * z)
# Output 40 (2*4*5)

You can also use the multiplication operator with string. When used with string, it works as a repetition.

Example

name = "Jessa"
print(name * 3)
# Output JessaJessaJessa

Division `/`

Divide the left operand (dividend) by the right one (divisor) and provide the result (quotient ) in a float value. The division operator is denoted by a / symbol.

Note:

The division operator performs floating-point arithmetic. Hence it always returns a float value.
Don’t divide any number by zero. You will get a Zero Division Error: Division by zero

Example

x = 2
y = 4
z = 8
print(y / x)
# Output 2.0
print(z / y / x)
# Output 1.0
# print(z / 0)  # error

Floor division `//`

Floor division returns the quotient (the result of division) in which the digits after the decimal point are removed. In simple terms, It is used to divide one value by a second value and gives a quotient as a round figure value to the next smallest whole value.

It works the same as a division operator, except it returns a possible integer. The // symbol denotes a floor division operator.

Note:

Floor division can perform both floating-point and integer arithmetic.
If both operands are int type, then the result types. If at least one operand type, then the result is a float type.

Example

x = 2
y = 4
z = 2.2

# normal division
print(y / x)
# Output 2.0

# floor division to get result as integer
print(y // x)
# Output 2

# normal division
print(y / z)  # 1.81

# floor division.
# Result as float because one argument is float
print(y // z)  # 1.0

Modulus `℅`

The remainder of the division of left operand by the right. The modulus operator is denoted by a % symbol. In simple terms, the Modulus operator divides one value by a second and gives the remainder as a result.

Example

x = 15
y = 4

print(x % y)
# Output 3

Exponent `**`

Using exponent operator left operand raised to the power of right. The exponentiation operator is denoted by a double asterisk ** symbol. You can use it as a shortcut to calculate the exponential value.

For example, 2**3 Here 2 is multiplied by itself 3 times, i.e., 2*2*2. Here the 2 is the base, and 3 is an exponent.

Example

num = 2
# 2*2
print(num ** 2) 
# Output 4

# 2*2*2
print(num ** 3)
# Output 8

Relational (comparison) operators

Relational operators are also called comparison operators. It performs a comparison between two values. It returns a boolean True or False depending upon the result of the comparison.

Python has the following six relational operators.

Assume variable x holds 10 and variable y holds 5

Operator	Description	Example
`>` (Greater than)	It returns True if the left operand is greater than the right	`x > y` result is `True`
`<` (Less than)	It returns True if the left operand is less than the right	`x < y` result is `False`
`==` (Equal to)	It returns True if both operands are equal	`x == y` result is `False`
`!=` (Not equal to)	It returns True if both operands are equal	`x != y` result is `True`
`>=` (Greater than or equal to)	It returns True if the left operand is greater than or equal to the right	`x >= y` result is `False`
`<=` (Less than or equal to)	It returns True if the left operand is less than or equal to the right	`x <= y` result is `False`

Python Relational (comparison) operators

You can compare more than two values also. Assume variable x holds 10, variable y holds 5, and variable z holds 2.

So print(x > y > z) will return True because x is greater than y, and y is greater than z, so it makes x is greater than z.

Example

x = 10
y = 5
z = 2

# > Greater than
print(x > y)  # True
print(x > y > z)  # True

# < Less than
print(x < y)  # False
print(y < x)  # True

# Equal to 
print(x == y)  # False 
print(x == 10)  # True 

# != Not Equal to 
print(x != y)  # True 
print(10 != x)  # False 

# >= Greater than equal to
print(x >= y)  # True
print(10 >= x)  # True

# <= Less than equal to
print(x <= y)  # False
print(10 <= x)  # True

Assignment operators

In Python, Assignment operators are used to assigning value to the variable. Assign operator is denoted by = symbol. For example, name = "Jessa" here, we have assigned the string literal ‘Jessa’ to a variable name.

Also, there are shorthand assignment operators in Python. For example, a+=2 which is equivalent to a = a+2.

Operator	Meaning	Equivalent
`=` (Assign)	`a=5`Assign 5 to variable `a`	a = 5
`+=` (Add and assign)	`a+=5`Add 5 to a and assign it as a new value to `a`	a = a+5
`-=` (Subtract and assign)	`a-=5`Subtract 5 from variable `a` and assign it as a new value to `a`	a = a-5
`*=` (Multiply and assign)	`a*=5`Multiply variable `a` by 5 and assign it as a new value to `a`	a = a*5
`/=` (Divide and assign)	`a/=5`Divide variable `a` by 5 and assign a new value to `a`	a = a/5
`%=` (Modulus and assign)	`a%=5`Performs modulus on two values and assigns it as a new value to `a`	a = a%5
`**=` (Exponentiation and assign)	`a**=5`Multiply `a` five times and assigns the result to `a`	a = a**5
`//=` (Floor-divide and assign)	`a//=5`Floor-divide `a` by 5 and assigns the result to `a`	a = a//5

Python assignment operators

Example

a = 4
b = 2

a += b
print(a)  # 6

a = 4
a -= 2
print(a)  # 2

a = 4
a *= 2
print(a)  # 8

a = 4
a /= 2
print(a)  # 2.0

a = 4
a **= 2
print(a)  # 16

a = 5
a %= 2
print(a)  # 1

a = 4
a //= 2
print(a)  # 2

Logical operators

Logical operators are useful when checking a condition is true or not. Python has three logical operators. All logical operator returns a boolean value True or False depending on the condition in which it is used.

Operator	Description	Example
`and` (Logical and)	True if both the operands are True	a and b
`or` (Logical or)	True if either of the operands is True	a or b
`not` (Logical not)	True if the operand is False	not a

Python Logical Operators

and (Logical and)

The logical and operator returns True if both expressions are True. Otherwise, it will return. False.

Example

print(True and False)  # False
# both are True
print(True and True)  # True
print(False and False)  # False
print(False and True)  # false

# actual use in code
a = 2
b = 4

# Logical and
if a > 0 and b > 0:
    # both conditions are true
    print(a * b)
else:
    print("Do nothing")

Output

False
True
False
False
 8

In the case of arithmetic values, Logical and always returns the second value; as a result, see the following example.

Example

print(10 and 20) # 20
print(10 and 5)  # 5
print(100 and 300) # 300

or (Logical or)

The logical or the operator returns a boolean True if one expression is true, and it returns False if both values are false.

Example

print(True or False)  # True
print(True or True)  # True
print(False or False)  # false 
print(False or True)  # True

# actual use in code
a = 2
b = 4

# Logical and
if a > 0 or b < 0:
    # at least one expression is true so conditions is true
    print(a + b)  # 6
else:
    print("Do nothing")

Output
True
True
False
True
6

In the case of arithmetic values, Logical or it always returns the first value; as a result, see the following code.

Example

print(10 or 20) # 10
print(10 or 5) # 10
print(100 or 300) # 100

not (Logical not)

The logical not operator returns boolean True if the expression is false.

Example

print(not False)  # True return complements result
print(not True)  # True return complements result

# actual use in code
a = True

# Logical not
if not a:
    # a is True so expression is False
    print(a) 
else:
    print("Do nothing")

Output

Do nothing

In the case of arithmetic values, Logical not always return False for nonzero value.

Example

print(not 10) # False. Non-zero value
print(not 1)  # True. Non-zero value
print(not 5)  # False. Non-zero value
print(not 0)  # True. zero value

Membership operators

Python’s membership operators are used to check for membership of objects in sequence, such as string, list, tuple. It checks whether the given value or variable is present in a given sequence. If present, it will return True else False.

In Python, there are two membership operator in and not in

In operator

It returns a result as True if it finds a given object in the sequence. Otherwise, it returns False.

Let’s check if the number 15 present in a given list using the in operator.

Example

my_list = [11, 15, 21, 29, 50, 70]
number = 15
if number in my_list:
    print("number is present")
else:
    print("number is not present")

Output

number is present

Not in operator

It returns True if the object is not present in a given sequence. Otherwise, it returns False

Example

my_tuple = (11, 15, 21, 29, 50, 70)
number = 35
if number not in my_tuple:
    print("number is not present")
else:
    print("number is present")

Output

number not is present

Identity operators

Use the Identity operator to check whether the value of two variables is the same or not. This operator is known as a reference-quality operator because the identity operator compares values according to two variables’ memory addresses.

Python has 2 identity operators is and is not.

`is` operator

The is operator returns Boolean True or False. It Return True if the memory address first value is equal to the second value. Otherwise, it returns False.

Example

x = 10
y = 11 
z = 10
print(x is y) # it compare memory address of x and y 
print(x is z) # it compare memory address of x and z

Output

False
True

Here, we can use is() function to check whether both variables are pointing to the same object or not.

`is not` operator

The is not the operator returns boolean values either True or False. It Return True if the first value is not equal to the second value. Otherwise, it returns False.

Example

x = 10
y = 11 
z = 10
print(x is not y) # it campare memory address of x and y 
print(x is not z) # it campare memory address of x and z

Output

True
False

Bitwise Operators

In Python, bitwise operators are used to performing bitwise operations on integers. To perform bitwise, we first need to convert integer value to binary (0 and 1) value.

The bitwise operator operates on values bit by bit, so it’s called bitwise. It always returns the result in decimal format. Python has 6 bitwise operators listed below.

& Bitwise and
| Bitwise or
^ Bitwise xor
~ Bitwise 1’s complement
<< Bitwise left-shift
>> Bitwise right-shift

Bitwise and `&`

It performs logical AND operation on the integer value after converting an integer to a binary value and gives the result as a decimal value. It returns True only if both operands are True. Otherwise, it returns False.

Example

a = 7
b = 4
c = 5
print(a & b)
print(a & c)
print(b & c)

Output

4
5
4

Here, every integer value is converted into a binary value. For example, a =7, its binary value is 0111, and b=4, its binary value is 0100. Next we performed logical AND, and got 0100 as a result, similarly for a and c, b and c

Following diagram shows AND operator evaluation.

Bitwise or `|`

It performs logical OR operation on the integer value after converting integer value to binary value and gives the result a decimal value. It returns False only if both operands are True. Otherwise, it returns True.

Example

a = 7
b = 4
c = 5
print(a | b)
print(a | c)
print(b | c)

Output

7
7
5

Here, every integer value is converted into binary. For example, a =7 its binary value is 0111, and b=4, its binary value is 0100, after logical OR, we got 0111 as a result. Similarly for a and c, b and c.

Bitwise xor `^`

It performs Logical XOR ^ operation on the binary value of a integer and gives the result as a decimal value.

Example: –

a = 7
b = 4
c = 5
print(a ^ c)
print(b ^ c)

Output

3
2
1

Here, again every integer value is converted into binary. For example, a =7 its binary value is 0111 and b=4, and its binary value is 0100, after logical XOR we got 0011 as a result. Similarly for a and c, b and c.

Bitwise 1’s complement `~`

It performs 1’s complement operation. It invert each bit of binary value and returns the bitwise negation of a value as a result.

Example

a = 7
b = 4
c = 3
print(~a, ~b, ~c)
# Output -8 -5 -4

Bitwise left-shift `<<`

The left-shift << operator performs a shifting bit of value by a given number of the place and fills 0’s to new positions.

Example: –

print(4 << 2) 
# Output 16
print(5 << 3)
# Output 40

Bitwise right-shift `>>`

The left-shift >> operator performs shifting a bit of value to the right by a given number of places. Here some bits are lost.

print(4 >> 2)
# Output 
print(5 >> 2)
# Output