Float division

Division by zero raises ZeroDivisionError

#### Floor Division Operator (//) Floor division returns the largest integer less than or equal to the division result.

`python

Positive numbers

With floats

Negative numbers (important behavior)

result4 = 17 // -5 print(result4) # Output: -4 `

#### Modulus Operator (%) The modulus operator returns the remainder after division.

`python

Basic modulus

Even/odd checking

Cycling through values

#### Exponentiation Operator () The exponentiation operator raises the left operand to the power of the right operand.

`python

Basic exponentiation

Square root (using fractional exponent)

Large numbers

Negative exponents

Mathematical Functions

Built-in Math Functions

Python provides several built-in mathematical functions that don't require importing any modules:

| Function | Description | Example | Result | |----------|-------------|---------|--------| | abs(x) | Absolute value | abs(-5) | 5 | | round(x, n) | Round to n decimal places | round(3.14159, 2) | 3.14 | | min(x, y, ...) | Minimum value | min(3, 7, 1, 9) | 1 | | max(x, y, ...) | Maximum value | max(3, 7, 1, 9) | 9 | | sum(iterable) | Sum of all elements | sum([1, 2, 3, 4]) | 10 | | pow(x, y) | x raised to power y | pow(2, 3) | 8 | | divmod(x, y) | Quotient and remainder | divmod(17, 5) | (3, 2) |

Detailed Function Explanations

#### Absolute Value Function The abs() function returns the absolute value of a number, which is its distance from zero.

`python

Integer absolute value

result2 = abs(10) print(result2) # Output: 10

Float absolute value

Complex number absolute value (magnitude)

#### Rounding Function The round() function rounds a number to a specified number of decimal places.

`python

Default rounding (to nearest integer)

result2 = round(3.2) print(result2) # Output: 3

Rounding to specific decimal places

result4 = round(3.14159, 4) print(result4) # Output: 3.1416

Rounding to tens, hundreds, etc.

result6 = round(1234.5678, -2) print(result6) # Output: 1200.0 `

#### Min and Max Functions These functions find the minimum and maximum values from a collection of numbers.

`python

Multiple arguments

max_val = max(5, 2, 8, 1, 9) print(max_val) # Output: 9

With iterables

With strings (lexicographic order)

The Math Module

The math module provides access to mathematical functions and constants beyond the built-in functions. To use it, you must import it first.

`python import math `

Mathematical Constants

| Constant | Description | Value | |----------|-------------|-------| | math.pi | Pi (π) | 3.141592653589793 | | math.e | Euler's number (e) | 2.718281828459045 | | math.tau | Tau (2π) | 6.283185307179586 | | math.inf | Positive infinity | inf | | math.nan | Not a Number | nan |

Trigonometric Functions

| Function | Description | Example | |----------|-------------|---------| | math.sin(x) | Sine of x (in radians) | math.sin(math.pi/2) → 1.0 | | math.cos(x) | Cosine of x (in radians) | math.cos(0) → 1.0 | | math.tan(x) | Tangent of x (in radians) | math.tan(math.pi/4) → 1.0 | | math.asin(x) | Arc sine of x | math.asin(1) → 1.5707963267948966 | | math.acos(x) | Arc cosine of x | math.acos(1) → 0.0 | | math.atan(x) | Arc tangent of x | math.atan(1) → 0.7853981633974483 |

`python import math

Converting degrees to radians

Trigonometric calculations

print(f"sin(45°) = {sin_45:.4f}") print(f"cos(45°) = {cos_45:.4f}") print(f"tan(45°) = {tan_45:.4f}")

Converting radians back to degrees

Logarithmic and Exponential Functions

| Function | Description | Example | |----------|-------------|---------| | math.log(x) | Natural logarithm | math.log(math.e) → 1.0 | | math.log10(x) | Base-10 logarithm | math.log10(100) → 2.0 | | math.log2(x) | Base-2 logarithm | math.log2(8) → 3.0 | | math.exp(x) | e raised to power x | math.exp(1) → 2.718281828459045 | | math.pow(x, y) | x raised to power y | math.pow(2, 3) → 8.0 |

`python import math

Natural logarithm

Logarithm with custom base

result2 = log_base(8, 2) print(f"log₂(8) = {result2}")

Exponential function

Power function

Other Useful Math Functions

| Function | Description | Example | |----------|-------------|---------| | math.sqrt(x) | Square root | math.sqrt(16) → 4.0 | | math.ceil(x) | Ceiling (round up) | math.ceil(3.2) → 4 | | math.floor(x) | Floor (round down) | math.floor(3.8) → 3 | | math.factorial(x) | Factorial | math.factorial(5) → 120 | | math.gcd(a, b) | Greatest common divisor | math.gcd(12, 18) → 6 | | math.fabs(x) | Absolute value (float) | math.fabs(-3.5) → 3.5 |

`python import math

Square root

Ceiling and floor

Factorial

Greatest common divisor

Least common multiple (using gcd)

lcm_result = lcm(12, 18) print(f"lcm(12, 18) = {lcm_result}") `

Order of Operations

Python follows the standard mathematical order of operations, often remembered by the acronym PEMDAS:

1. Parentheses - () 2. Exponents - 3. Multiplication and Division - *, /, //, % (left to right) 4. Addition and Subtraction - +, - (left to right)

Order of Operations Examples

`python

Without parentheses

With parentheses

Complex expression

Step by step breakdown

Step 1: 4 2 = 16

Step 2: 3 * 16 = 48

Step 3: 2 + 48 = 50

Step 4: 50 - 1 = 49

Using parentheses to change order

Working with Different Number Types

Integer Operations

Python 3 integers have unlimited precision, meaning they can be arbitrarily large.

`python

Large integer calculations

Integer division behavior

Binary, octal, and hexadecimal

Floating-Point Operations

Floating-point numbers in Python are implemented using the IEEE 754 double precision format.

`python

Floating-point precision

Comparing floats (problematic)

Better way to compare floats

Scientific notation

Float special values

print(f"Positive infinity: {positive_inf}") print(f"Negative infinity: {negative_inf}") print(f"Not a number: {not_a_number}")

Checking for special values

Complex Number Operations

Python has built-in support for complex numbers using the j suffix for the imaginary part.

`python

Creating complex numbers

print(f"Complex1: {complex1}") print(f"Complex2: {complex2}") print(f"Complex3: {complex3}")

Complex number operations

print(f"Addition: {addition}") print(f"Multiplication: {multiplication}") print(f"Division: {division}")

Accessing real and imaginary parts

Complex conjugate

Magnitude (absolute value)

Advanced Mathematical Operations

Statistical Operations

`python import math import statistics

Dataset for examples

Mean (average)

Median

Mode (most common value)

Standard deviation

Variance

Number Base Conversions

`python

Converting between number bases

Convert to binary, octal, and hexadecimal

print(f"Decimal {decimal_num}:") print(f"Binary: {binary_str}") print(f"Octal: {octal_str}") print(f"Hexadecimal: {hex_str}")

Convert back to decimal

print(f"\nConverting back to decimal:") print(f"Binary 11111111 = {binary_to_decimal}") print(f"Octal 377 = {octal_to_decimal}") print(f"Hex ff = {hex_to_decimal}")

Custom base conversion

Example: Convert binary 1010 to base 5

Practical Examples

Financial Calculations

`python import math

def compound_interest(principal, rate, time, n=1): """ Calculate compound interest principal: initial amount rate: annual interest rate (as decimal) time: time in years n: number of times interest is compounded per year """ amount = principal (1 + rate/n) (n time) return amount

def simple_interest(principal, rate, time): """Calculate simple interest""" return principal (1 + rate time)

def loan_payment(principal, rate, periods): """Calculate monthly loan payment""" if rate == 0: return principal / periods monthly_rate = rate / 12 payment = principal (monthly_rate (1 + monthly_rate) periods) / \ ((1 + monthly_rate) periods - 1) return payment

Examples

compound_amount = compound_interest(principal, annual_rate, years, 12) simple_amount = simple_interest(principal, annual_rate, years)

print(f"Principal: ${principal:,.2f}") print(f"Compound interest (monthly): ${compound_amount:,.2f}") print(f"Simple interest: ${simple_amount:,.2f}") print(f"Difference: ${compound_amount - simple_amount:,.2f}")

Loan payment calculation

Geometric Calculations

`python import math

def circle_area(radius): """Calculate area of a circle""" return math.pi radius * 2

def circle_circumference(radius): """Calculate circumference of a circle""" return 2 math.pi radius

def triangle_area(base, height): """Calculate area of a triangle""" return 0.5 base height

def triangle_area_heron(a, b, c): """Calculate triangle area using Heron's formula""" s = (a + b + c) / 2 # semi-perimeter return math.sqrt(s (s - a) (s - b) * (s - c))

def distance_2d(x1, y1, x2, y2): """Calculate distance between two points in 2D""" return math.sqrt((x2 - x1) 2 + (y2 - y1) 2)

def sphere_volume(radius): """Calculate volume of a sphere""" return (4/3) math.pi radius 3

def cylinder_volume(radius, height): """Calculate volume of a cylinder""" return math.pi radius 2 height

Examples

Triangle with sides 3, 4, 5

Distance between points

3D shapes

Number Theory Operations

`python import math

def is_prime(n): """Check if a number is prime""" if n < 2: return False if n == 2: return True if n % 2 == 0: return False for i in range(3, int(math.sqrt(n)) + 1, 2): if n % i == 0: return False return True

def prime_factors(n): """Find prime factors of a number""" factors = [] d = 2 while d * d <= n: while n % d == 0: factors.append(d) n //= d d += 1 if n > 1: factors.append(n) return factors

def fibonacci(n): """Generate first n Fibonacci numbers""" if n <= 0: return [] elif n == 1: return [0] elif n == 2: return [0, 1] fib = [0, 1] for i in range(2, n): fib.append(fib[i-1] + fib[i-2]) return fib

def gcd_extended(a, b): """Extended Euclidean algorithm""" if a == 0: return b, 0, 1 gcd, x1, y1 = gcd_extended(b % a, a) x = y1 - (b // a) * x1 y = x1 return gcd, x, y

Examples

print(f"\nPrime factors of 60: {prime_factors(60)}") print(f"Prime factors of 100: {prime_factors(100)}")

print(f"\nFirst 10 Fibonacci numbers: {fibonacci(10)}")

Extended GCD

Best Practices and Common Pitfalls

Floating-Point Precision Issues

`python import math from decimal import Decimal, getcontext

Problem: Floating-point precision

Solution 1: Using math.isclose()

Solution 2: Using decimal module for exact arithmetic

Solution 3: Rounding for display

Division by Zero Handling

`python def safe_division(dividend, divisor): """Safely perform division with error handling""" try: result = dividend / divisor return result except ZeroDivisionError: print(f"Error: Cannot divide {dividend} by zero") return None

def safe_modulus(dividend, divisor): """Safely perform modulus operation""" try: result = dividend % divisor return result except ZeroDivisionError: print(f"Error: Cannot find remainder of {dividend} divided by zero") return None

Examples

Performance Considerations

`python import time import math

def timing_comparison(): """Compare performance of different mathematical operations""" n = 1000000 # Test 1: vs math.pow vs pow start_time = time.time() for i in range(n): result = 2 3 time_operator = time.time() - start_time start_time = time.time() for i in range(n): result = math.pow(2, 3) time_math_pow = time.time() - start_time start_time = time.time() for i in range(n): result = pow(2, 3) time_builtin_pow = time.time() - start_time print("Power operation performance:") print(f" operator: {time_operator:.4f} seconds") print(f"math.pow(): {time_math_pow:.4f} seconds") print(f"pow() builtin: {time_builtin_pow:.4f} seconds") # Test 2: Square root comparison start_time = time.time() for i in range(n): result = math.sqrt(16) time_sqrt = time.time() - start_time start_time = time.time() for i in range(n): result = 16 0.5 time_power = time.time() - start_time print("\nSquare root performance:") print(f"math.sqrt(): {time_sqrt:.4f} seconds") print(f" 0.5: {time_power:.4f} seconds")

Run timing comparison

Input Validation for Mathematical Functions

`python import math

def validated_sqrt(x): """Square root with input validation""" if not isinstance(x, (int, float)): raise TypeError("Input must be a number") if x < 0: raise ValueError("Cannot compute square root of negative number") return math.sqrt(x)

def validated_log(x, base=math.e): """Logarithm with input validation""" if not isinstance(x, (int, float)) or not isinstance(base, (int, float)): raise TypeError("Inputs must be numbers") if x <= 0: raise ValueError("Logarithm input must be positive") if base <= 0 or base == 1: raise ValueError("Logarithm base must be positive and not equal to 1") if base == math.e: return math.log(x) else: return math.log(x) / math.log(base)

def validated_factorial(n): """Factorial with input validation""" if not isinstance(n, int): raise TypeError("Factorial input must be an integer") if n < 0: raise ValueError("Factorial is not defined for negative numbers") return math.factorial(n)

Examples with error handling

for func, test_values in test_cases: print(f"\nTesting {func.__name__}:") for value in test_values: try: result = func(value) print(f" {func.__name__}({value}) = {result}") except (TypeError, ValueError) as e: print(f" {func.__name__}({value}) -> Error: {e}") `

This comprehensive guide covers the fundamental mathematical operations in Python, from basic arithmetic to advanced mathematical functions. Understanding these concepts and their proper implementation is crucial for any Python programmer working with numerical data or mathematical computations. The examples and best practices provided should help you avoid common pitfalls and write more robust mathematical code.