Machine Learning models are, at their core, just massive mathematical equations. Before you can build AI, you must absolutely master how Python handles arithmetic operations, floats, and logic order.
1The Foundational Operators
Python handles addition (+), subtraction (-), and multiplication (*) exactly as you would expect from basic algebra. However, division is where junior developers often stumble.
Standard division (/) ALWAYS returns a float (a decimal number), even if the numbers divide perfectly. If you want the integer result of a division—dropping the decimal completely—you must use Floor Division (//). We use Floor Division constantly in engineering when we need to calculate whole batches of data (e.g., how many full 32-image batches fit into 100 images). If you need the remainder of that division, use the Modulo operator (%).
# Standard Division ALWAYS yields a float
print(10 / 2) # 5.0
# Floor Division yields an integer
data_points = 100
batch_size = 32
full_batches = data_points // batch_size
# Modulo yields the remainder
leftover_points = data_points % batch_size
print(f"Batches: {full_batches}, Leftover: {leftover_points}")Batches: 3, Leftover: 4
2Exponents and PEMDAS
In machine learning, you will constantly calculate 'Mean Squared Error'. To square a number in Python, you do not use the caret (^); the caret is a bitwise XOR operator. You use the double asterisk (**) for exponentiation.
Furthermore, Python strictly follows PEMDAS (Parentheses, Exponents, Multiplication/Division, Addition/Subtraction). Even if you know the default order will evaluate correctly, ALWAYS use parentheses to group your logic. Code is read ten times more often than it is written. If another engineer has to pause to remember order of operations while reading your algorithm, your code is bad.
predicted = 10
actual = 7
# Bad: Hard to read
bad_error = predicted - actual ** 2
# Good: Explicit engineering
error_margin = (predicted - actual)
squared_error = error_margin ** 2
print(squared_error)3The Math Module
Python's core operators are fast but limited. For trigonometry, logarithms, or rounding algorithms, you must import the built-in math module.
Two incredibly common functions are math.ceil() and math.floor(). ceil() unconditionally forces a float up to the next highest integer (useful when determining how many server instances you need to boot up), while floor() unconditionally forces it down. Do not confuse these with Python's built-in round() function, which rounds to the *nearest* integer based on standard math rules.
import math
# Calculate square root
root = math.sqrt(81)
# ceil() always rounds UP
servers_needed = math.ceil(4.1)
# floor() always rounds DOWN
users_cutoff = math.floor(4.9)
print(f"Root: {root}, Servers: {servers_needed}, Users: {users_cutoff}")