Arithmetic Operators

Creating variables just to hold values is quiet boring, we need some way to manipulate them. This is where operators shine, they let us perform well.. operations. Arithmetic operators deal mostly with numeric values. The four basic operators are:

• + which adds two numbers
• - which subtracts the first number from the second
• * computes the product of two values
• / division which divides the first number by the second

1
x = 1 + 2
2
y = 3 * 4
3
z = y / x - 1
4
print(x, y, z)

Note

The division operator always yields a float. Dividing by zero is not allowed and will raise a ZeroDivisionError.

We are left with:

• ** which raises the first number to the power of the second
• % which returns the remainder after division of the first number by the second
• // which performs floor division, i.e. it goes down to the nearest integer

The ** operator raises the first number to the power of the second.

1
print(2 ** 3) #8
2
print(3 ** 2) #9
3
print(10 ** 0) #1
4
print(10 ** -1) #0.1

Next in line is the // floor division. We can think of it as an elevator down-stairs. This behaves like the division, but if the result has a decimal part (wasn’t divisible), it goes down to the nearest integer.

1
print(5 // 2) #2
2
print(4 // 2) #2
3
print(8 // 3) #2
4
print(4 // 5) #0
5
print(1.2 // 1) #1
6
print(-0.5 // 1) #-1
7
print(-1.5 // 1) #-2

The yielded type may not always be an integer. This is something that few people know about, if any of the numbers is a float, the result would be a float (integer with a .0 at the end of it).

1
print(4 // 2) #2
2
print(4.0 // 2) #2.0
3
print(4 // 2.0) #2.0
4
print(4.0 // 2.0) #2.0

We also have the modulo operator %, which takes two numbers a and b and returns the remainder after division of a by b.

1
print(5 % 2) #1
2
print(14 % 4) #2
3
print(28 % -5) #-2

The modulo operator always yields a negative value, if the second number is negative.

1
print(5 % 3) #2
2
print(-5 % 3) #1
3
print(5 % -3) #-1
4
print(-5 % -3) #-2

Common Type Conversion

When we say that an arithmetic operation uses the phrase: “The numeric arguments are converted into a common type”, this means that the built-in operators work as follows:

• If either arguments is a complex, the other is converted to complex.
• If either is a floating number, the other is converted to a floating number.
• If either is a integer, the other is converted to a integer.
• Otherwise, both must be integers and conversion is not necessary.

Addition, subtraction, multiplication, division, floor division, modulo and power obey the previous rule. While the floor division yields an integer, the value is converted to the common type.

Assignment Operators

An assignment operator = is used to bind (or rebind) a value to a variable. This is done by evaluating the right-hand side of the assignment operator and then binding the value to the left-hand side.

1
x = 10
2
y = 20
3
z = 30
4
print(x) #10
5
print(y) #20
6
print(z) #30
7
x = 40 #rebind
8
print(x) #40

We can also use the assignment operator to bind multiple variables to a single value.

1
x = y = z = 10
2
print(x) #10
3
print(y) #10
4
print(z) #10

1
x = 10
2
x += 10
3
print(x) #20

1
x = 10
2
x -= 2 #x = x - 2
3
print(x) #8
4
x *= 10 #x = x * 10
5
print(x) #80
6
x /= 3 #x = x / 3
7
print(x) #26.666666666666668
8
x //= 2 #x = x // 2
9
print(x) #13.0
10
x %= 10 #x = x % 10
11
print(x) #3.0

Comparison Operators

Python supports the usually comparison operators:

• == Equal
• != Not equal
• > Greater than
• < Less than
• >= Greater than or equal
• <= Less than or equal

All of these operations have the same precedence level. Comparison operators always return a boolean value True or False.

1
x = 10
2
y = 20
3
z = 30
4
print(x == y) #False
5
print(x != y) #True
6
print(x > y) #False
7
print(x >= y) #False
8
print(x <= y) #True
9
print(x < z) #True
10
print(x > z) #False
11
print(x >= z) #False
12
print(x <= z) #True

The equality comparison (== and !=) checks if two values have the same identity.

Note

One can get the identity of an object using the id function.

By default, an order comparison (<, >, <=, and >=) is not provided on all types, so writing something like None < 2 will raise a TypeError.

If we were using a mix of booleans, integers, or floats, then they are converted to a common type, and then the comparison is performed. If we have two strings, then the comparison is performed lexicographically.

Info

Lexicographical comparison is the comparison of strings based on the dictionary order of the characters. It is performed by comparing the Unicode code points of the characters in the strings.

1
x = 10
2
y = 20
3
z = 30
4
print(x < z > y) #True
5
print(x < y != z) #True
6
print(x == y == z) #False
7
print(x != y < z) #True

1
print(1 != print("Hello") != 2) #True, prints Hello once
2
print(1 != print("Hello") && print("Hello") != 2) #True, prints Hello twice
3
print(1 == 2 == print("Hello")) #False, since we have short-circuiting, print("Hello") is not evaluated

Logical Operators

Python supports the following logical operators:

• not
• and
• or

The operator not yields True if its argument is False, False otherwise.

The expression x and y first evaluates x; if x is False, its value is returned; otherwise, y is evaluated and the resulting value is returned.

The expression x or y first evaluates x; if x is True, its value is returned; otherwise, y is evaluated and the resulting value is returned.

1
print(not True) #False
2
print(not False) #True
3
print(True and False) #False
4
print(True and True) #True
5
print(True or False) #True
6
print(False or False) #False

1
print(True and 1) #1
2
print(False and 1) #False
3
print(True or 1) #True
4
print(False or 1) #1
5
print(not 1) #False
6
print(not 0) #True

1
name = ""
2
print(name or "Guest") #Guest
3
name = "Ali"
4
print(name or "Guest") #Ali

1
print(0 and True) #0 (since 0 is Falsy)
2
print(3 or False) #3 (since 3 is Truthy)

Precedence and Associativity

Operators have a precedence and associativity. The precedence is the order in which the operators are evaluated. The associativity is the order in which the operators are grouped.

The following table shows the precedence of the operators in Python.

The first row in the table is the highest precedence, the last row is the lowest precedence. As we can see there are some columns with multiple operators, these operators have the same precedence. But in an expression with multiple operators having the same precedence, the associativity is used to determine the order of evaluation.

Note

We have added all the operators here, even the ones that we didn’t mention in this section, nor the previous ones. This is to give you a complete picture of the operators in Python.

Exercises

1
x = 10
2
y = 20
3
z = 30
4
print(x, y, z)

1
x = 10
2
y = 3
3
print(x + y * 2)

1
a = 7
2
a += 3
3
a *= 2
4
print(a)

1
print(True and False or True)
2
print(True and (False or True))