June 16, 2025
POSTS

What Are Numbers, Really? A Gentle Dive into Number Theory, Mathematics with Python

Editor017 mins
Mathematics with Python

Numbers are everywhere. From managing finances to analyzing data, we constantly interact with them. But what exactly are numbers?

In this post, we’ll explore the beautiful journey of numbers through number theory, and bring it all together with a Python program that showcases each type of number in action.

The Evolution of Numbers

Natural Numbers

Natural numbers are the first we learn: 1, 2, 3…

Python
1
2
3
4
 
 
natural_numbers = list(range(1, 6))
print("Natural Numbers:", natural_numbers)

0️⃣ Whole Numbers

Add zero to natural numbers and you get whole numbers.

1
2
3
4
 
 
whole_numbers = list(range(0, 6))
print("Whole Numbers:", whole_numbers)

➕➖ Integers

Integers include negative numbers, zero, and positive numbers.

1
2
3
4
 
 
integers = list(range(-3, 4))
print("Integers:", integers)

Rational and Irrational Numbers

➗ Rational Numbers

Rational numbers can be expressed as fractions or finite decimals.

1
2
3
4
5
6
 
 
from fractions import Fraction
 
rational_numbers = [Fraction(1, 2), Fraction(3, 4), 1.25, 2]
print("Rational Numbers:", rational_numbers)

Irrational Numbers

These cannot be expressed exactly as fractions.

1
2
3
4
5
6
 
 
import math
 
irrational_numbers = [math.pi, math.e, math.sqrt(2)]
print("Irrational Numbers (approx):", irrational_numbers)

Real, Complex, and Imaginary Numbers

Real Numbers

Real numbers include both rational and irrational numbers.

1
2
3
4
 
 
real_numbers = rational_numbers + irrational_numbers
print("Real Numbers:", real_numbers)

Complex and Imaginary Numbers

Python can handle imaginary numbers using j as the imaginary unit.

1
2
3
4
5
6
 
 
complex_number = complex(2, 3)  # 2 + 3j
imaginary_number = complex(0, 4)  # 4j
print("Complex Number:", complex_number)
print("Imaginary Number:", imaginary_number.imag, "i")

Full Code Summary

Here’s the entire code block you can run in any Python environment:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
import math
from fractions import Fraction
 
natural_numbers = list(range(1, 6))
whole_numbers = list(range(0, 6))
integers = list(range(-3, 4))
rational_numbers = [Fraction(1, 2), Fraction(3, 4), 1.25, 2]
irrational_numbers = [math.pi, math.e, math.sqrt(2)]
real_numbers = rational_numbers + irrational_numbers
complex_number = complex(2, 3)
imaginary_number = complex(0, 4)
 
print("Natural Numbers:", natural_numbers)
print("Whole Numbers:", whole_numbers)
print("Integers:", integers)
print("Rational Numbers:", rational_numbers)
print("Irrational Numbers (approx):", irrational_numbers)
print("Real Numbers:", real_numbers)
print("Complex Number:", complex_number)
print("Imaginary Number:", imaginary_number.imag, "i")

Understanding Order of Operations and Variables in Python

When working with math or code, knowing how expressions are evaluated and how to use variables is crucial. In this post, we’ll walk through these two foundational ideas with real examples in Python. Whether you’re a beginner or brushing up, you’ll walk away with a clearer understanding.

Order of Operations (PEMDAS)

Remember PEMDAS?

Parentheses → Exponents → Multiplication → Division → Addition → Subtraction

This is the standard way to evaluate mathematical expressions. Python follows this order too!

Example:

Let’s evaluate this expression step-by-step:

1
2
3
 
 
2 * (3 + 2)**2 / 5 - 4

Step-by-step breakdown:

  1. Parentheses: (3 + 2) → 5

  2. Exponents: 5**2 → 25

  3. Multiplication: 2 * 25 → 50

  4. Division: 50 / 5 → 10.0

  5. Subtraction: 10.0 - 4 → 6.0

✅ Python Code Example 1:

1
2
3
4
 
 
my_value = 2 * (3 + 2)**2 / 5 - 4
print(my_value)  # Output: 6.0

Use Parentheses for Clarity

Even if Python follows PEMDAS, using extra parentheses makes your code easier to read and maintain.

✅ Python Code Example 2 (clearer):

1
2
3
4
 
 
my_value = 2 * ((3 + 2)**2 / 5) - 4
print(my_value)  # Output: 6.0

Pro Tip: When in doubt, use parentheses to group parts of your expression clearly!

What Are Variables?

A variable is a name that stores a value. It could be a number, a word, or even a list. In math, we often use letters like x, y, or z. In Python, you can name your variables almost anything—just follow the rules!

✅ Example: Getting user input and using a variable

1
2
3
4
5
 
 
x = int(input("Please input a number: "))
product = 3 * x
print("3 times your number is:", product)

If you input 5, Python multiplies it by 3 and prints:

1
2
3
 
 
3 times your number is: 15

Naming Variables in Python

Some math variables have Greek names like θ (theta) or β (beta). Since Python doesn’t support Greek characters easily, we name them like this:

✅ Example:

1
2
3
4
5
6
 
 
theta = 30.0
beta = 1.75
print("Theta is:", theta)
print("Beta is:", beta)

Subscripted Variables (x₁, x₂, x₃)

In math, you might see variables with subscripts (e.g. x₁, x₂, x₃). In Python, you can use underscores for that:

✅ Example:

1
2
3
4
5
6
7
 
 
x1 = 3   # or x_1
x2 = 10  # or x_2
x3 = 44  # or x_3
 
print("x1 + x2 + x3 =", x1 + x2 + x3)

Output:

1
2
3
 
 
x1 + x2 + x3 = 57

Wrapping Up

Understanding order of operations and how to use variables are foundational in both math and Python. Here’s the combined final example with everything we discussed:

✅ Final All-in-One Python Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
import math
 
# Order of operations
value = 2 * ((3 + 2)**2 / 5) - 4
print("Final value (PEMDAS example):", value)
 
# Variables from input
x = int(input("Please input a number: "))
product = 3 * x
print("3 times your number is:", product)
 
# Greek-style variables
beta = 1.75
theta = 30.0
print("Beta:", beta)
print("Theta:", theta)
 
# Subscripted variables
x1, x2, x3 = 3, 10, 44
print("x1 + x2 + x3 =", x1 + x2 + x3)

What is a Function?

A function defines a relationship between input variables (independent variables) and an output variable (dependent variable).
Mathematically, this is often written as:

Working with Functions in Python

✅ Linear Function Example

1
2
3
4
5
6
7
8
 
 
def f(x):
    return 2 * x + 1
 
x_values = [0, 1, 2, 3]
for x in x_values:
    print(f(x))

This prints:

1
2
3
4
5
6
 
 
1  
3  
5  
7  

Continuous Functions

Unlike using only whole numbers (0, 1, 2, …), real functions allow infinitely many inputs (e.g., 0.1, 0.01, 0.001), making the function continuous.
For example:

x y = 2x + 1
0.0 1
0.5 2
1.0 3
1.5 4
2.0 5

️ Visualizing Functions (Graphing)

We can use SymPy, a symbolic math library in Python, to plot functions.

Linear Function

1
2
3
4
5
6
 
 
from sympy import *
x = symbols('x')
f = 2*x + 1
plot(f)

Exponential Function (Parabola)

1
2
3
4
5
6
 
 
from sympy import *
x = symbols('x')
f = x**2 + 1
plot(f)

This creates a curve, not a straight line. Curves like these are called curvilinear functions.

Functions with Two Variables

You can define functions of two independent variables, like:

This requires 3D plotting:

1
2
3
4
5
6
7
8
 
 
from sympy import *
from sympy.plotting import plot3d
 
x, y = symbols('x y')
f = 2*x + 3*y
plot3d(f)

Key Concepts

Concept Meaning
Function A rule that maps input(s) to a single output.
Independent variable Input variable (like `x`)
Dependent variable Output (like `y` or `f(x)`)
Continuous function A function where you can plug in infinitely small steps.
Curvilinear function A continuous but non-linear function (e.g., parabolas)
SymPy A Python library for symbolic math and graphing.

What Is a Summation?

A summation is a mathematical operation represented by the Greek letter sigma (Σ). It tells you to add a bunch of terms together.

Basic Summation Using a Loop in Python

Let’s say you want to multiply each number from 1 to 5 by 2, and add all the results:

1
2
3
4
 
 
summation = sum(2 * i for i in range(1, 6))
print(summation)  # Output: 30

  • range(1, 6) gives numbers 1 through 5 (6 is not included).

  • Each number i is multiplied by 2.

  • sum() adds them all together.

Summing List Values After Multiplying Each by 10

Suppose you have a list of numbers:

1
2
3
 
 
x = [1, 4, 6, 2]

You want to multiply each number by 10, then sum the result:

1
2
3
4
 
 
summation = sum(10 * value for value in x)
print(summation)  # Output: 130

  • Loop through each value in the list x.

  • Multiply it by 10.

  • Add all results using sum().

Using Indexes (0-based like Python usually does)

If you need to use indexes explicitly:

1
2
3
4
5
6
7
 
 
x = [1, 4, 6, 2]
n = len(x)
 
summation = sum(10 * x[i] for i in range(n))
print(summation)  # Output: 130

Using SymPy for Symbolic Summation

Install SymPy if you don’t have it:

1
2
3
 
 
pip install sympy

Now use it in Python:

1
2
3
4
5
6
7
8
 
 
from sympy import symbols, Sum
 
i, n = symbols('i n')
expression = Sum(2 * i, (i, 1, n))
evaluated = expression.subs(n, 5).doit()
print(evaluated)  # Output: 30

  • Sum() creates a symbolic summation.

  • .subs(n, 5) sets the upper limit.

  • .doit() evaluates the result.

Mastering Exponents in Algebra with Python

Exponents are a fundamental concept in mathematics, especially in algebra. They represent repeated multiplication and are essential for working with polynomials, equations, and even in advanced topics like calculus and machine learning.

In this post, we’ll explore the core rules of exponents, simplify expressions using Python’s SymPy library, and even deal with fractional and irrational exponents.

What Are Exponents?

An exponent tells you how many times to multiply the base number by itself.

For example:

1
2
3
4
5
6
7
8
9
10
11
 
 
# Multiply 2 × 2 × 2
product = 2 * 2 * 2
 
# Power 2^3
power = 2 ** 3
 
# Print results
print("2 × 2 × 2 =", product)
print("2^3 =", power)

Output:

1
2
3
4
 
 
2 × 2 × 2 = 8
2^3 = 8

 

  • Base: 2

  • Exponent: 3

  • Result: 8

Key Properties of Exponents

Let’s explore the most important exponent rules with both algebraic explanation and Python code.

1. Product Rule:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 
# Define base and exponents
x = 2
a = 3
b = 4
 
# Compute both sides of the rule
left_side = (x ** a) * (x ** b)
right_side = x ** (a + b)
 
# Print the results
print(f"x = {x}, a = {a}, b = {b}")
print(f"x^a * x^b = {left_side}")
print(f"x^(a + b) = {right_side}")
print("Rule holds:", left_side == right_side)

Algebra:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
# Define base and exponents
x = 2
a = 2
b = 3
 
# Compute left side: x^2 * x^3
left_side = (x ** a) * (x ** b)
 
# Compute right side: x^(2+3)
right_side = x ** (a + b)
 
# Print the algebraic expression and the results
print(f"x^{a} * x^{b} = x^{a}+{b} = x^{a + b}")
print(f"Evaluated: {left_side} = {right_side}")
print("Verification:", left_side == right_side)

1
2
3
4
5
6
7
 
 
from sympy import symbols, simplify
 
x = symbols('x')
expr = x**2 * x**3
print(simplify(expr))  # Output: x**5

2. Quotient Rule:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
# Define base and exponents
x = 2
a = 2
b = 5
 
# Compute quotient using power rule
quotient = (x ** a) / (x ** b)        # x^2 / x^5
power_rule = x ** (a - b)             # x^(2-5)
 
# Calculate reciprocal form for negative exponent
reciprocal_form = 1 / (x ** (b - a))  # 1 / x^3
 
# Print everything
print(f"x^{a} / x^{b} = x^({a} - {b}) = x^{a - b}")
print(f"Evaluated quotient: {quotient}")
print(f"Using power rule: {power_rule}")
print(f"Reciprocal form for negative exponent: 1 / x^{b - a} = {reciprocal_form}")
 
# Verify equality
print("Verification:", quotient == power_rule == reciprocal_form)

Output:
1
2
3
4
5
6
7
 
 
x^2 / x^5 = x^(2 - 5) = x^-3
Evaluated quotient: 0.125
Using power rule: 0.125
Reciprocal form for negative exponent: 1 / x^3 = 0.125
Verification: True

3. Zero Exponent Rule:
1
2
3
4
5
6
7
8
9
10
11
12
 
 
def zero_power(x):
    if x == 0:
        return "Undefined (0^0 is undefined)"
    else:
        return x ** 0
 
# Test values
print("2^0 =", zero_power(2))
print("10^0 =", zero_power(10))
print("0^0 =", zero_power(0))  # special case

Output:
1
2
3
4
5
 
 
2^0 = 1
10^0 = 1
0^0 = Undefined (0^0 is undefined)

Explanation:

Any non-zero number raised to the power of 0 is 1.

Python Code:

1
2
3
4
 
 
expr = x**0
print(simplify(expr))  # Output: 1

4. Negative Exponent Rule:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
# Define base and exponent
x = 2
a = 3
 
# Calculate using negative exponent rule
negative_exponent = x ** (-a)
reciprocal = 1 / (x ** a)
 
# Print results
print(f"x^(-{a}) = {negative_exponent}")
print(f"1 / x^{a} = {reciprocal}")
print("Verification:", negative_exponent == reciprocal)

Output:

1
2
3
4
5
 
 
x^(-3) = 0.125
1 / x^3 = 0.125
Verification: True

Python Code:

1
2
3
4
 
 
expr = x**-3
print(simplify(expr))  # Output: 1/x**3

5. Power of a Power Rule:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 
# Define base and exponents
x = 8
a = 3
b = 2
 
# Calculate both sides
left_side = (x ** a) ** b
right_side = x ** (a * b)
 
# Print the algebraic expression and evaluation
print(f"(x^{a})^{b} = x^({a} * {b}) = x^{a * b}")
print(f"Evaluated left side: {left_side}")
print(f"Evaluated right side: {right_side}")
print("Verification:", left_side == right_side)

Output:

1
2
3
4
5
6
 
 
(x^3)^2 = x^(3 * 2) = x^6
Evaluated left side: 262144
Evaluated right side: 262144
Verification: True

Python Code:

1
2
3
4
5
 
 
base = symbols('a')
expr = (base**3)**2
print(simplify(expr))  # Output: a**6

Fractional Exponents = Roots

Fractional exponents represent roots.

Square Root:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
# Base
x = 4
 
# Fractional exponent
exponent = 1/2
 
# Calculate power and square root
power_result = x ** exponent
sqrt_result = x ** 0.5  # same as 1/2
 
print(f"{x}^(1/2) = {power_result}")
print(f"Square root of {x} = {sqrt_result}")

Output:

1
2
3
4
 
 
4^(1/2) = 2.0
Square root of 4 = 2.0

Cube Root:

1
2
3
4
5
6
7
8
9
10
11
12
 
 
# Base
x = 8
 
# Fractional exponent 1/3
exponent = 1/3
 
# Calculate power (cube root)
power_result = x ** exponent
 
print(f"{x}^(1/3) = {power_result}")

Output:

1
2
3
 
 
8^(1/3) = 2.0

Python Code:

1
2
3
4
5
6
7
8
9
 
 
from sympy import Rational
 
expr = 4**Rational(1, 2)
print(simplify(expr))  # Output: 2
 
expr = 8**Rational(1, 3)
print(simplify(expr))  # Output: 2

Multiplying Roots:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
# Base and fractional exponent
x = 8
fraction = 1/3
 
# Multiply three times
product = (x ** fraction) * (x ** fraction) * (x ** fraction)
 
# Add exponents manually for verification
combined_exponent = x ** (fraction + fraction + fraction)
 
print(f"8^(1/3) * 8^(1/3) * 8^(1/3) = {product}")
print(f"8^(1/3 + 1/3 + 1/3) = 8^1 = {combined_exponent}")
print("Verification:", product == combined_exponent == 8)

Output:

1
2
3
4
5
 
 
8^(1/3) * 8^(1/3) * 8^(1/3) = 8.0
8^(1/3 + 1/3 + 1/3) = 8^1 = 8
Verification: True

What About Irrational Exponents?

Even irrational numbers like π can be used as exponents:

1
2
3
4
5
6
7
8
9
10
11
12
 
 
import math
 
# Base and exponent
x = 8
pi = math.pi
 
# Compute 8^π
result = x ** pi
 
print(f"8^π ≈ {result:.4f}")

Output:

1
2
3
4
5
6
 
 
from sympy import pi, N
 
expr = 8**pi
print(N(expr))  # Output: ~687.2913

Computers handle irrational numbers like π by approximating them using many decimal places.

Recap of Exponent Rules

Product Rule   $x^a \cdot x^b = x^{a+b}$   $x^2 \cdot x^3 = x^5$
Quotient Rule   $\frac{x^a}{x^b} = x^{a-b}$   $\frac{x^2}{x^5} = x^{-3}$
Zero Exponent   $x^0 = 1$   $5^0 = 1$
Negative Exponent   $x^{-a} = \frac{1}{x^a}$   $x^{-2} = \frac{1}{x^2}$
Power Rule   $(x^a)^b = x^{ab}$   $(2^3)^2 = 2^6$
Fractional Exponent  $x^{1/n} = \sqrt[n]{x}$   $27^{1/3} = 3$

Understanding Logarithms in Python: A Powerful Math Function for Data and Beyond

Logarithms may sound like a topic reserved for dusty math books, but they are incredibly useful—especially in fields like data science, machine learning, cryptography, and even audio processing.

Let’s explore logarithms step by step, including how to use them in Python, and how they relate to exponents.

What Is a Logarithm?

A logarithm answers the question:

“To what power must we raise a number (base) to get another number?”

For example:

What power of 2 gives us 8?

Mathematically:

1
2
3
 
 
2^x = 8

To solve for x, we rewrite this using logarithm notation:

1
2
3
 
 
log₂(8) = x

Since 2³ = 8, the answer is:

1
2
3
 
 
x = 3

General Form of a Logarithm

1
2
3
 
 
If a^x = b, then logₐ(b) = x

Where:

  • a is the base

  • b is the result

  • x is the exponent

Calculating Logarithms in Python

Let’s see how to compute logs in Python:

✅ Example 1: Base 2 Logarithm

1
2
3
4
5
6
7
 
 
from math import log
 
# What power of 2 gives 8?
x = log(8, 2)
print(x)  # Output: 3.0

✅ Example 2: Natural Logarithm (base e)

1
2
3
4
5
6
 
 
from math import log
 
# Natural logarithm (base e ≈ 2.718)
print(log(10))  # Output: 2.302585092994046

If no base is provided, Python defaults to base e, known as Euler’s number, common in scientific and statistical calculations.

Key Properties of Logarithms

Understanding how logarithms behave is important for simplifying expressions.

Multiplication (Product Rule)  $x^m \cdot x^n = x^{m+n}$  $\log_b(ab) = \log_b(a) + \log_b(b)$
Division (Quotient Rule) $\frac{x^m}{x^n} = x^{m-n}$  $\log_b\left(\frac{a}{b}\right) = \log_b(a) – \log_b(b)$
Power of Power Rule $(x^m)^n = x^{mn}$  $\log_b(a^n) = n \cdot \log_b(a)$
Zero Power Rule  $x^0 = 1$  $\log_b(1) = 0$
Negative Exponent (Inverse)  $x^{-1} = \frac{1}{x}$  $\log_b\left(\frac{1}{x}\right) = -\log_b(x)$

Using SymPy for Log Simplification

The sympy library is great for algebraic manipulations.

✅ Example: Algebraic simplification

1
2
3
4
5
6
7
8
 
 
from sympy import symbols, log, simplify
 
x, y = symbols('x y')
expr = log(x * y)
simplified = simplify(expr)
print(simplified)  # Output: log(x) + log(y)

Bonus: Logarithms with Irrational Exponents

What if you wanted to compute something like 8^\pi \approx 687.2913?

1
2
3
4
5
6
7
8
9
 
 
import math
 
# Approximate value of pi
pi = math.pi
 
result = 8 ** pi
print(result)  # Output: ≈ 687.2913

Internally, Python uses rational approximations for irrational numbers to compute results like this.

Logarithms Undo Exponents

Logarithms are the inverse of exponentiation.

For example:

1
2
3
4
5
6
 
 
# If 2^x = 8
# Then x = log2(8)
 
print(log(8, 2))  # 3.0

Summary

  • Logarithms answer the question: “What power of a base gives a number?”

  • Python uses math.log() for both base-e and base-n logs.

  • The sympy library can symbolically simplify log expressions.

  • Logarithms obey similar rules as exponents: they simplify multiplication, division, and powers.

Real-Life Applications of Logarithms

  • Earthquake magnitude (Richter scale)

  • Sound decibel levels

  • Machine learning models like logistic regression

  • Data transformation (log-normal distributions)

  • Finance for calculating compound interest

Coming Up Next

In the next post, we’ll explore Euler’s number (e) and how it’s used in natural logarithms and exponential growth in machine learning and data science.

Leave a Reply

Your email address will not be published. Required fields are marked *

Related Posts

Home
Courses
Services
Search