Arithmetic Operations
Python supports all standard arithmetic operations:
Addition
To add two numbers:
print(6 + 2) # Output: 8
Subtraction
To subtract one number from another:
print(6 - 2) # Output: 4
Multiplication
To multiply two numbers:
print(6 * 2) # Output: 12
Division
To divide one number by another:
print(6 / 2) # Output: 3.0
Floor Division
To get the integer division of two numbers:
print(7 / 2) # Output: 3.5
print(7 // 2) # Output: 3
This operation gives the integer result of the division, discarding the fractional part.
Exponentiation
To raise a number to the power of another:
print(6 ** 2) # Output: 36 (6 raised to the power of 2)
Modulus
To find the remainder of the division:
print(7 % 2) # Output: 1 (remainder of 7 divided by 2)
In this case, the nearest number to 7 that is divisible by 2 is 6. Thus, the remainder is 7 – 6 = 1.
When multiple arithmetic operations are used sequentially, they are executed according to their precedence. Higher precedence operations are executed first. The table below shows the order of precedence from lowest to highest:
Operation Precedence
| Operation | Direction |
|---|---|
| ** | Right to Left |
| / // % | Left to Right |
| + – | Left to Right |
Consider the following expression:
number = 3 + 4 * 5 ** 2 + 7
print(number) # Output: 110
Here, the exponentiation (5 ** 2) is executed first, followed by multiplication (25 * 4), then addition (3 + 100), and finally, another addition (103 + 7).
To override the order of operations, you can use parentheses:
number = (3 + 4) * (5 ** 2 + 7)
print(number) # Output: 224
It’s important to note that arithmetic operations can involve both integers and floating-point numbers. If an operation involves both an integer (int) and a floating-point (float) number, the integer is converted to a float.
Arithmetic Operations with Assignment
Several special operations allow you to assign the result of an operation to the first operand:
+=Assign the sum-=Assign the difference*=Assign the product/=Assign the quotient//=Assign the integer quotient**=Assign the exponentiation result%=Assign the remainder
Examples:
number = 10
number += 5
print(number) # Output: 15
number -= 3
print(number) # Output: 12
number *= 4
print(number) # Output: 48
Rounding and the round() Function
When working with floating-point numbers, keep in mind that the results of operations may not be perfectly accurate. For example:
first_number = 2.0001
second_number = 5
third_number = first_number / second_number
print(third_number) # Output: 0.40002000000000004
Here, we might expect 0.40002, but we get a slightly different result due to floating-point precision issues.
Or another example:
print(2.0001 + 0.1) # Output: 2.1001000000000003
In the cases above, you can use the round() function to round the result:
first_number = 2.0001
second_number = 0.1
third_number = first_number + second_number
print(round(third_number)) # Output: 2
The round() function takes the number to be rounded. If only the number is given, it is rounded to the nearest integer.
The round() function can also take a second argument, specifying the number of decimal places to include in the result:
first_number = 2.0001
second_number = 0.1
third_number = first_number + second_number
print(round(third_number, 4)) # Output: 2.1001
Here, the value of third_number is rounded to 4 decimal places.
If only one value is provided to the function – just the number to be rounded, it rounds to the nearest integer:
Examples of Rounding
# rounding to a whole number
print(round(2.49)) # Output: 2
print(round(2.51)) # Output: 3
However, if the fraction to be rounded is equidistant between two integers, the rounding goes to the nearest even number:
print(round(2.5)) # Output: 2 (nearest even)
print(round(3.5)) # Output: 4 (nearest even)
Rounding is performed to the nearest power of 10 minus the fraction to be rounded:
# rounding to two decimal places
print(round(2.554, 2)) # Output: 2.55
print(round(2.5551, 2)) # Output: 2.56
print(round(2.554999, 2)) # Output: 2.55
print(round(2.499, 2)) # Output: 2.5
However, it should be noted that the round() function is not a perfect tool. For example, when rounding to integers, the rule applied is that if the fraction to be rounded is equidistant from two values, the rounding goes to the nearest even value. In Python, due to the fact that the fractional part cannot be accurately represented as a floating-point number, some expected results may not be achieved. For example:
# round to two decimal places
print(round(2.545, 2)) # Output: 2.54
print(round(2.555, 2)) # Output: 2.56 (round to even)
print(round(2.565, 2)) # Output: 2.56
print(round(2.575, 2)) # Output: 2.58
print(round(2.655, 2)) # Output: 2.65 (not rounding to even)
print(round(2.665, 2)) # Output: 2.67
print(round(2.675, 2)) # Output: 2.67
