Python - Arithmetic Operators

Arithmetic operators are special symbols used to perform mathematical operations such as addition, subtraction, multiplication, and division. The symbols that perform these operations are called operators, while the values or objects they act upon are called operands.

Let's look at the example above. In the expression $5 + 3$, the numbers 5 and 3 are the operands, while + is the operator. In this case, + is the arithmetic operator that performs addition.

All the Arithmetic Operators

Python provides seven primary arithmetic operators to handle everything from basic sums to complex powers:

1. Addition (+): Adds two operands together.
2. Subtraction (-): Subtracts the right operand from the left operand.
3. Multiplication (*): Multiplies two operands.
4. Division (/): Divides the left operand by the right operand (always returns a decimal/float).
5. Floor Division (//): Divides the left operand by the right operand and "chops off" the decimal, returning only the whole number.
6. Modulus (%): Divides the left operand by the right operand and returns only the remainder.
7. Exponentiation (**): Raises the left operand to the power of the right operand (e.g., 2 ** 3 is 2 cubed).

The Addition Operator (+)

To perform addition in Python, simply place the + operator between two numbers (the operands). For example, $5 + 10$ will calculate the sum, returning a new integer of 15

Mathematical Representation:

How it works in code:

# Adding two variables
score = 50
bonus = 10

final_score = score + bonus

print(final_score)  # Output: 60

The Subtraction Operator (-)

The subtraction operator calculates the difference between two numbers. It subtracts the right operand (the subtrahend) from the left operand (the minuend).

Mathematical Representation:

How it works in code:

# Subtracting values
total_items = 100
sold_items = 30

remaining_stock = total_items - sold_items

print(remaining_stock)  # Output: 70

The Multiplication Operator (*)

In Python, multiplication is represented by the asterisk (*). It calculates the product of two numbers, effectively performing repeated addition.

Mathematical Representation:

How it works in code:

# Multiplying values
price = 20
quantity = 3

total_cost = price * quantity

print(total_cost)  # Output: 60

The Division Operator (/)

The standard division operator calculates the quotient of two numbers. In Python, this operator always returns a decimal (a float), even if the result is a perfect whole number.

Mathematical Representation:

How it works in code:

print(10 / 2)  # Output: 5.0 (Note the .0)
print(10 / 3)  # Output: 3.3333333333333335

The Floor Division Operator (//)

Floor division divides two numbers but "chops off" the decimal part, rounding the result down to the nearest whole number. This is the go-to operator when you want to ensure your result remains an integer.

Mathematical Representation:

How it works in code:

print(10 // 3) # Output: 3
print(7 // 2)  # Output: 3

The Modulus Operator (%)

The modulus operator is the partner to floor division. Instead of giving you the quotient, it returns the remainder left over after the division is complete.

Mathematical Representation:

How it works in code:

# Useful for checking if a number is even or odd
print(10 % 3)  # Output: 1 (Because 3 goes into 10 three times, leaving 1)
print(10 % 2)  # Output: 0 (Because 10 is perfectly divisible by 2)

The Exponentiation Operator (**)

The exponentiation operator raises the left operand (the base) to the power of the right operand (the exponent). It is a clean and efficient way to calculate squares, cubes, or any higher power without needing to import a math library.

Mathematical Representation:

How it works in code:

# Squaring a number
print(5 ** 2)  # Output: 25 (5 * 5)

# Cubing a number
print(2 ** 3)  # Output: 8 (2 * 2 * 2)

# It can also be used for square roots
print(16 ** 0.5) # Output: 4.0

Operator Precedence

Operator precedence is simply the priority given to each operator, which determines the order in which they are executed. This rule is very important in order to output a consistent result for the same mathematical expression. Without these rules, a single calculation could be interpreted in multiple ways, leading to bugs and errors.

The Order of Operations

When an expression contains multiple arithmetic operators, Python does not evaluate them randomly. Instead, it follows a predefined order of operations to determine which calculations are performed first.

This order is commonly remembered using the acronyms PEMDAS (Parentheses, Exponents, Multiplication, Division, Addition, Subtraction) or BODMAS (Brackets, Orders, Division, Multiplication, Addition, Subtraction).

Python evaluates arithmetic expressions according to the following hierarchy:

1. Parentheses () – Expressions enclosed in parentheses are evaluated first.
2. Exponentiation ** – Powers and exponents are evaluated next.
3. Multiplication, Division, Floor Division, and Modulus *, /, //, % – These operators have the same precedence and are evaluated from left to right.
4. Addition and Subtraction +, - – These operators are evaluated last, also from left to right.

Summary

• Arithmetic Operators are symbols (like +, -, *) used to perform mathematical operations between values called operands.
• The Seven Operators: Python has seven primary arithmetic operators: Addition (+), Subtraction (-), Multiplication (*), Division (/), Floor Division (//), Modulus (%), and Exponentiation (**).
• Division Nuance: Standard division (/) always returns a decimal (float), while Floor Division (//) returns a whole number by "chopping off" the remainder.
• Operator Precedence: Python follows the PEMDAS / BODMAS rule to determine which part of a calculation to execute first.