Python Arithmetic Operators
Python arithmetic operators are the building blocks of any calculation you write in code. Whether you are totaling a shopping cart, splitting a bill, or computing a physics formula, these operators handle the math. Python makes this especially clean because it supports seven distinct arithmetic operators right out of the box, each designed for a specific kind of numeric operation.
This guide walks through every Python arithmetic operator one by one. For each one you will see what it does, why it exists, a self-contained code example you can run immediately, and a clear explanation of the output.
The Seven Python Arithmetic Operators
Python gives you these arithmetic operators:
| Operator | Symbol | Example |
|---|---|---|
| Addition | + | 5 + 3 |
| Subtraction | - | 5 - 3 |
| Multiplication | * | 5 * 3 |
| Division | / | 5 / 3 |
| Floor Division | // | 5 // 3 |
| Modulo | % | 5 % 3 |
| Exponentiation | ** | 5 ** 3 |
Each one returns a number, but the type — int or float — depends on the operator and the operands involved. Understanding that distinction is key to avoiding subtle bugs.
Addition Operator in Python
The addition operator combines two numbers together. It works with integers, floats, and even mixes of the two. When you add an integer to a float, Python automatically promotes the result to a float so no precision is lost.
# Python addition operator examples
whole_price = 45
discount = 5.50
tax = 3.25
subtotal = whole_price - discount
total = subtotal + tax
print("Subtotal:", subtotal)
print("Total after tax:", total)
print("Type of total:", type(total))
Subtotal: 39.5
Total after tax: 42.75
Type of total: <class 'float'>
Notice that even though the original price was a plain integer, mixing it with floats in the expression caused Python to return floats automatically. This is called implicit type promotion and it means you rarely need to cast types manually in arithmetic.
Subtraction Operator in Python
The subtraction operator removes one value from another. It behaves symmetrically with addition: integers stay integers unless a float is involved, and negative results are perfectly valid.
# Subtraction with positive and negative results
altitude_start = 3200
altitude_end = 890
descent = altitude_start - altitude_end
below_sea = 100 - 450 # goes negative
print("Descent in meters:", descent)
print("Below reference point:", below_sea)
Descent in meters: 2310
Below reference point: -350
Subtraction is used constantly in countdown timers, measuring differences between timestamps, tracking inventory, and computing deltas in data analysis.
Multiplication Operator in Python
The multiplication operator scales a value. In Python, the symbol is * rather than the traditional × to avoid conflict with variable names. Multiplying two integers gives an integer; multiplying with a float gives a float.
# Multiplication operator in Python
hourly_rate = 18.50
hours_worked = 40
overtime_hours = 6
overtime_multiplier = 1.5
regular_pay = hourly_rate * hours_worked
overtime_pay = hourly_rate * overtime_multiplier * overtime_hours
gross_pay = regular_pay + overtime_pay
print(f"Regular pay: ${regular_pay:.2f}")
print(f"Overtime pay: ${overtime_pay:.2f}")
print(f"Gross pay: ${gross_pay:.2f}")
Regular pay: $740.00
Overtime pay: $166.50
Gross pay: $906.50
The :.2f inside the f-string formats the float to two decimal places, which is exactly what you want when displaying currency.
Division Operator in Python
Division in Python always returns a float, even when both operands are integers and the division is exact. This changed in Python 3 — in Python 2, dividing two integers performed floor division by default. If you are reading older code, watch out for that difference.
# Python division always returns float
apples = 10
baskets = 5
per_basket = apples / baskets
half = 7 / 2
print("Apples per basket:", per_basket)
print("Type:", type(per_basket))
print("Half of 7:", half)
print("Type:", type(half))
Apples per basket: 2.0
Type: <class 'float'>
Half of 7: 3.5
Type: <class 'float'>
Even though 10 divided by 5 is a whole number, Python still gives you 2.0 as a float. This consistent behavior prevents a whole category of bugs where you expect a decimal result but get a truncated integer.
Floor Division in Python
Floor division uses the // operator and rounds the result down to the nearest integer — toward negative infinity, not toward zero. This distinction matters for negative numbers.
Floor division is essential when you need to know how many complete groups fit into something: how many full weeks in a given number of days, how many complete pages to print, how many whole boxes you can fill.
# Floor division examples including negative numbers
total_days = 100
days_per_week = 7
full_weeks = total_days // days_per_week
remaining_days = total_days % days_per_week # using modulo, explained next
print("Full weeks:", full_weeks)
print("Remaining days:", remaining_days)
# Floor division with negatives rounds toward negative infinity
print("\nFloor division with negatives:")
print(7 // 2) # 3
print(-7 // 2) # -4, not -3 — rounds DOWN
print(7 // -2) # -4
Full weeks: 14
Remaining days: 2
Floor division with negatives:
3
-4
-4
The negative number behavior surprises many beginners. -7 // 2 gives -4 instead of -3 because floor division always rounds toward negative infinity, not toward zero. If you need truncation toward zero, use int(-7 / 2) instead.
Modulo Operator in Python
The modulo operator % returns the remainder after division. It answers the question: after dividing as many whole times as possible, what is left over? This operator is far more useful than it might first appear.
Common uses include checking whether a number is even or odd, cycling through a list repeatedly, calculating time in hours and minutes, and implementing circular buffers.
# Python modulo operator practical examples
seconds_total = 7384
hours = seconds_total // 3600
remaining = seconds_total % 3600
minutes = remaining // 60
seconds = remaining % 60
print(f"Time: {hours}h {minutes}m {seconds}s")
# Check even/odd
for number in [14, 27, 100, 333]:
if number % 2 == 0:
print(f"{number} is even")
else:
print(f"{number} is odd")
Time: 2h 3m 4s
7384 seconds equals exactly 2 hours, 3 minutes, and 4 seconds.
14 is even
27 is odd
100 is even
333 is odd
The time conversion example shows how floor division and modulo work as a pair. Floor division extracts the whole part; modulo extracts the leftover. Together they let you break any quantity into components.
Exponentiation Operator in Python
The exponentiation operator ** raises the left operand to the power of the right operand. Python has this built into the language itself, so you do not need to import the math module just to compute powers.
This operator is right-associative, meaning 2 ** 3 ** 2 evaluates as 2 ** (3 ** 2), which is 2 ** 9 = 512, not (2 ** 3) ** 2 = 64. That is the standard mathematical convention, but it is worth knowing explicitly.
# Python exponentiation operator
# Compound interest formula: A = P(1 + r/n)^(nt)
principal = 1000.0
annual_rate = 0.06 # 6%
compounds_per_year = 12 # monthly
years = 5
amount = principal * (1 + annual_rate / compounds_per_year) ** (compounds_per_year * years)
interest_earned = amount - principal
print(f"Principal: ${principal:.2f}")
print(f"After {years} years: ${amount:.2f}")
print(f"Interest earned: ${interest_earned:.2f}")
# Powers of 2 (common in computing)
print("\nPowers of 2:")
for exp in range(8):
print(f"2 ** {exp} = {2 ** exp}")
Principal: $1000.00
After 5 years: $1348.85
Interest earned: $348.85
Powers of 2:
2 ** 0 = 1
2 ** 1 = 2
2 ** 2 = 4
2 ** 3 = 8
2 ** 4 = 16
2 ** 5 = 32
2 ** 6 = 64
2 ** 7 = 128
You can also use fractional exponents to compute roots. 16 ** 0.5 is the square root of 16 (which is 4.0), and 27 ** (1/3) is the cube root of 27 (which is 3.0).
Operator Precedence in Python
When multiple arithmetic operators appear in a single expression, Python follows a specific order of evaluation. This order is often remembered using the acronym PEMDAS: Parentheses, Exponentiation, Multiplication/Division/Floor Division/Modulo, then Addition/Subtraction.
Operators at the same precedence level are evaluated left to right, except for exponentiation which is right to left.
# Python operator precedence examples
result1 = 2 + 3 * 4 # multiplication first: 2 + 12 = 14
result2 = (2 + 3) * 4 # parentheses first: 5 * 4 = 20
result3 = 2 ** 3 ** 2 # right-to-left: 2 ** 9 = 512
result4 = 10 - 4 / 2 + 1 # division first: 10 - 2.0 + 1 = 9.0
result5 = 17 % 5 + 3 * 2 # 2 + 6 = 8
print("2 + 3 * 4 =", result1)
print("(2 + 3) * 4 =", result2)
print("2 ** 3 ** 2 =", result3)
print("10 - 4 / 2 + 1 =", result4)
print("17 % 5 + 3 * 2 =", result5)
2 + 3 * 4 = 14
(2 + 3) * 4 = 20
2 ** 3 ** 2 = 512
10 - 4 / 2 + 1 = 9.0
17 % 5 + 3 * 2 = 8
When in doubt, add parentheses. They cost nothing in performance but make your intent unmistakable to anyone reading the code, including your future self.
Augmented Assignment Operators
Python also provides shorthand forms that combine an arithmetic operator with assignment. These are called augmented assignment operators and they modify a variable in place without having to repeat the variable name.
# Augmented assignment operators in Python
score = 100
score += 50 # same as: score = score + 50
print("After += 50:", score)
score -= 30 # same as: score = score - 30
print("After -= 30:", score)
score *= 2 # same as: score = score * 2
print("After *= 2:", score)
score //= 3 # same as: score = score // 3
print("After //= 3:", score)
score **= 2 # same as: score = score ** 2
print("After **= 2:", score)
score %= 50 # same as: score = score % 50
print("After %= 50:", score)
After += 50: 150
After -= 30: 120
After *= 2: 240
After //= 3: 80
After **= 2: 6400
After %= 50: 0
These shorthands are especially common in loops where you accumulate a total, count items, or step through a range with a custom increment.
Working with Integers and Floats Together
Python's numeric type system does what you would expect: if any operand in an arithmetic expression is a float, the result is a float. The only exception is the floor division and modulo operators, which can return integers if both operands are integers.
# Integer vs float results
print(type(3 + 4)) # int
print(type(3 + 4.0)) # float
print(type(10 / 2)) # float — always
print(type(10 // 2)) # int — both operands are int
print(type(10.0 // 2)) # float — one operand is float
print(type(10 % 3)) # int
print(type(10.0 % 3)) # float
<class 'int'>
<class 'float'>
<class 'float'>
<class 'int'>
<class 'float'>
<class 'int'>
<class 'float'>
Knowing which type each operator returns matters when passing values to functions that expect a specific type, or when comparing results where 2 and 2.0 look the same but behave differently in type checks.
Full Working Example
This example builds a simple invoice calculator that uses every Python arithmetic operator in a realistic context.
# Invoice calculator using all Python arithmetic operators
def calculate_invoice(unit_price, quantity, discount_pct, tax_rate):
# Multiplication: line total
gross_total = unit_price * quantity
# Subtraction + multiplication: apply percentage discount
discount_amount = gross_total * (discount_pct / 100)
after_discount = gross_total - discount_amount
# Multiplication: compute tax
tax_amount = after_discount * (tax_rate / 100)
# Addition: final total
invoice_total = after_discount + tax_amount
# Floor division + modulo: split into dollars and cents
dollars = int(invoice_total)
cents = round((invoice_total - dollars) * 100)
# Exponentiation: show what this total grows to if invested at 5% for 3 years
future_value = invoice_total * (1 + 0.05) ** 3
return {
"gross_total": gross_total,
"discount_amount": discount_amount,
"after_discount": after_discount,
"tax_amount": tax_amount,
"invoice_total": invoice_total,
"dollars": dollars,
"cents": cents,
"future_value": future_value,
}
result = calculate_invoice(
unit_price=49.99,
quantity=7,
discount_pct=10,
tax_rate=8.5,
)
print("======= INVOICE SUMMARY =======")
print(f"Gross total: ${result['gross_total']:.2f}")
print(f"Discount (10%): -${result['discount_amount']:.2f}")
print(f"After discount: ${result['after_discount']:.2f}")
print(f"Tax (8.5%): +${result['tax_amount']:.2f}")
print(f"Invoice total: ${result['invoice_total']:.2f}")
print(f" = ${result['dollars']} and {result['cents']} cents")
print(f"\nIf invested at 5%/yr for 3 years: ${result['future_value']:.2f}")
======= INVOICE SUMMARY =======
Gross total: $349.93
Discount (10%): -$34.99
After discount: $314.94
Tax (8.5%): +$26.77
Invoice total: $341.71
= $341 and 71 cents
If invested at 5%/yr for 3 years: $395.44
Every operator in this example serves a clear purpose: multiplication for totals, subtraction and addition for adjusting the running amount, division inside the percentage calculations, floor division and modulo for splitting the total into whole dollars and cents, and exponentiation for the compound growth projection. That is exactly how Python arithmetic operators appear in real applications — not in isolation, but woven together to solve a practical problem.
For the official language reference on numeric types and operators, see the Python documentation on numeric types and the operator precedence table.