Numbers, Operators and the Math Module

1. Numeric Computing in Python

Numerical computation is at the heart of computer programming, powering everything from web application logic and financial calculations to graphics rendering and machine learning models.

Python provides robust built-in support for numerical processing across integer (int), floating-point (float), and complex (complex) data types. In this lesson, we will explore Python's full set of arithmetic and comparison operators, master operator precedence, evaluate built-in numerical functions, and leverage Python's standard math module for advanced mathematical algorithms.

2. Complete Analysis of Python Operators

1. Arithmetic Operators

Arithmetic operators perform standard mathematical operations on numeric operands.

2. Comparison (Relational) Operators

Comparison operators evaluate the relationship between two operands and always return a Boolean result (True or False).

3. Logical Operators (`and`, `or`, `not`)

Logical operators combine conditional statements and evaluate based on truth values:

• and: Returns True only if both operands evaluate to True. (Uses short-circuiting: if the left operand is False, the right operand is not evaluated).
• or: Returns True if at least one operand evaluates to True. (Short-circuits if the left operand is True).
• not: Unary logical operator that inverts the truth value of its operand.

3. Code Demonstration: Arithmetic and Modulus Logic

# Converting total seconds into hours, minutes, and remaining seconds
total_seconds = 3675

hours = total_seconds // 3600
remaining_seconds = total_seconds % 3600
minutes = remaining_seconds // 60
seconds = remaining_seconds % 60

print(f"Total Seconds: {total_seconds}")
print(f"Time: {hours} Hour(s), {minutes} Minute(s), {seconds} Second(s)")

Total Seconds: 3675
Time: 1 Hour(s), 1 Minute(s), 15 Second(s)

4. Operator Precedence and Associativity Rules

When an expression contains multiple operators, Python follows strict rules of operator precedence and associativity to determine the order in which operations are evaluated.

Precedence Order Hierarchy (Highest to Lowest)

1. Parentheses () (Grouped sub-expressions evaluate first)
2. Exponentiation **
3. Unary operators +x, -x, ~x
4. Multiplication *, Division /, Floor Division //, Modulus %
5. Addition +, Subtraction -
6. Comparison operators (==, !=, >, <, >=, <=, is, in)
7. Logical not
8. Logical and
9. Logical or

# Expression without explicit parentheses
result_a = 10 + 5 * 2 ** 3 / 4
# Step-by-step evaluation:
# 1. Exponentiation: 2 ** 3 = 8
# 2. Multiplication: 5 * 8 = 40
# 3. Division: 40 / 4 = 10.0
# 4. Addition: 10 + 10.0 = 20.0

# Expression with explicit grouping parentheses
result_b = ((10 + 5) * 2) ** (3 / 4)

print("Result A (Natural Precedence):", result_a)
print("Result B (Grouped Precedence):", round(result_b, 4))

Result A (Natural Precedence): 20.0
Result B (Grouped Precedence): 8.409

5. Built-in Numerical Functions

Python provides several built-in functions for numerical calculations that do not require importing external modules:

• abs(x): Returns the absolute value (magnitude) of a number $x$.
• round(number, ndigits): Rounds a number to a specified number of decimal places. Uses banker's rounding (round-to-even) logic to minimize statistical bias.
• pow(base, exp, mod): Raises base to exp ($base^{exp}$). If optional 3rd argument mod is supplied, efficiently computes $(base^{exp}) \pmod{mod}$.
• divmod(a, b): Returns a tuple containing the quotient and remainder simultaneously: (a // b, a % b).
• min(arg1, arg2, ...) / max(arg1, arg2, ...): Returns the smallest or largest value among inputs.

# divmod demonstration
quotient, remainder = divmod(29, 5)
print(f"29 / 5 -> Quotient: {quotient}, Remainder: {remainder}")

# Banker's Rounding check (rounds to nearest even integer for exact .5 cases)
print("round(2.5):", round(2.5))  # Outputs 2
print("round(3.5):", round(3.5))  # Outputs 4

# pow with modulus parameter (used in cryptography)
cipher_calc = pow(7, 3, 13)  # (7^3) % 13 = 343 % 13 = 5
print("pow(7, 3, 13):", cipher_calc)

29 / 5 -> Quotient: 5, Remainder: 4
round(2.5): 2
round(3.5): 4
pow(7, 3, 13): 5

6. Deep Dive: The Python `math` Module

For advanced mathematical computation, trigonometry, logarithms, and scientific calculations, Python includes the built-in math module. To use its functions, import it at the beginning of your script using import math.

1. Essential Mathematical Constants

• math.pi: Mathematical constant $\pi = 3.141592653589793...$
• math.e: Euler's number $e = 2.718281828459045...$
• math.tau: Circle constant $\tau = 2\pi = 6.283185307179586...$
• math.inf: Floating-point positive infinity (-math.inf for negative infinity).
• math.nan: Floating-point "Not a Number" (used for undefined numeric representations).

2. Rounding and Truncation Functions

3. Power, Exponential, and Logarithmic Functions

• math.sqrt(x): Returns the square root of $x$ ($\sqrt{x}$). $x$ must be $\ge 0$.
• math.isqrt(n): Returns the integer square root of non-negative integer $n$ (rounded down).
• math.log(x, [base]): Computes logarithm of $x$. If base is omitted, calculates natural logarithm ($\ln(x) = \log_e(x)$).
• math.log10(x): Computes base-10 logarithm ($\log_{10}(x)$).
• math.log2(x): Computes base-2 logarithm ($\log_2(x)$).

4. Trigonometric and Angle Functions

Note: Trigonometric functions in the math module expect angles in radians, not degrees.

• math.sin(x), math.cos(x), math.tan(x): Sine, cosine, and tangent of $x$ radians.
• math.radians(degrees): Converts angle from degrees to radians.
• math.degrees(radians): Converts angle from radians to degrees.

import math

# Calculating hypotenuse of a right-angled triangle (a^2 + b^2 = c^2)
side_a = 3.0
side_b = 4.0
hypotenuse = math.hypot(side_a, side_b)
print(f"Hypotenuse (3, 4): {hypotenuse}")

# Trigonometry conversion
angle_degrees = 45.0
angle_radians = math.radians(angle_degrees)
sin_val = math.sin(angle_radians)
print(f"sin(45 degrees): {sin_val:.4f}")

# Factorials and GCD
print("Factorial of 5 (5!):", math.factorial(5))  # 5 * 4 * 3 * 2 * 1 = 120
print("GCD of 48 and 18:", math.gcd(48, 18))       # Greatest Common Divisor = 6

Hypotenuse (3, 4): 5.0
sin(45 degrees): 0.7071
Factorial of 5 (5!): 120
GCD of 48 and 18: 6

7. Floating-Point Precision Issues and Solutions

Because computers represent floating-point numbers in base-2 (binary) fractions according to IEEE 754 standards, certain base-10 decimals cannot be represented exactly in binary.

# Surprising floating-point representation quirk
val = 0.1 + 0.2
print("0.1 + 0.2 =", val)
print("0.1 + 0.2 == 0.3 ->", val == 0.3)

0.1 + 0.2 = 0.30000000000000004
0.1 + 0.2 == 0.3 -> False

How to Handle Float Comparisons Safely

1. Use `math.isclose()` for Approximate Comparison:

import math
# Safe comparison with a small tolerance threshold
print(math.isclose(0.1 + 0.2, 0.3))  # Returns True

2. Use the `decimal` Module for Financial Exactness:

When computing monetary totals where floating-point inaccuracy cannot be tolerated, use Python's built-in decimal module:

from decimal import Decimal
price1 = Decimal('0.1')
price2 = Decimal('0.2')
total = price1 + price2
print(total)  # Outputs exactly Decimal('0.3')

8. Frequently Asked Interview Questions with Answers

9. Homework & Practical Assignment

10. File & Workspace Directory Structure

python_mastery_course/
│
├── lesson_01/
├── lesson_02/
├── lesson_03/
├── lesson_04/
├── lesson_05/
├── lesson_06/
│
└── lesson_07/
    ├── arithmetic_ops.py
    ├── precedence_demo.py
    ├── builtin_numeric.py
    ├── math_module_demo.py
    ├── float_precision.py
    ├── precedence_check.py
    ├── geometry_calculator.py
    └── quadratic_solver.py

11. What We Will Learn Next

```