Numbers

Two types of numbers

Python has two ways to store numbers: Integers - Whole numbers without decimals

age = 25
score = -10

Floats - Numbers with decimal points

price = 19.99
temperature = -5.5
pi = 3.14159

Python uses a dot (.) for decimals, not a comma. Writing 3,14 creates a tuple, not the number 3.14!

Why two types?

Python separates integers and floats for efficiency - computers can work with whole numbers faster and more precisely. But here’s the reassuring part: in practice, you rarely need to think about this. Python handles the conversion automatically when needed, and most of the time you’ll just use whatever makes sense - whole numbers for counting things, decimals for measurements and calculations.

Basic math operations

Numbers work just like a calculator:

# Addition and subtraction
total = 10 + 5     # 15
change = 20 - 7    # 13

# Multiplication and division
area = 6 * 4       # 24
half = 10 / 2      # 5.0 (always returns float)

# Powers
squared = 5 ** 2   # 25
cubed = 2 ** 3     # 8

Integer vs float division

Division has two forms:

# Regular division (always float)
result = 10 / 3    # 3.333...

# Integer division (rounds down)
result = 10 // 3   # 3

These are just the basics! Python can solve complex math problems too. When you need square roots, trigonometry, or advanced calculations, ask AI to help with the specific syntax - no need to memorize every math symbol right now.

Memory & Floating-Point Precision

Python has unique ways of handling numbers under the hood. Let’s look at three important concepts:

1. Everything is an Object

In Python, even simple numbers like integers and floats are objects. This means they have built-in methods you can call.

# Check bit length of an integer
print((42).bit_length())  # 6 (needs 6 bits to represent 42)

# Check if a float represents a whole number
print((4.0).is_integer())  # True
print((4.5).is_integer())  # False

To save memory, Python pre-loads and caches small integers (typically from -5 to 256). When you assign these values, Python points both variables to the same object in memory instead of creating a new one. We can inspect memory locations using the id() function or the is comparison operator:

# Small integers share the same memory location
a = 10
b = 10
print(id(a) == id(b))  # True
print(a is b)          # True (points to the same object)

# Larger integers do not share memory locations (unless compiled together)
x = 500
y = 500
print(x is y)          # False (points to different objects in memory)

3. Floating-Point Precision Issues

Floating-point numbers (decimals) are represented in binary (base-2) fractions. Since computers cannot represent fractions like 0.1 or 0.2 exactly in binary (they become infinite repeating fractions, just like 1/3 is 0.3333... in decimal), small rounding errors can occur.

# Rounding error in action
print(0.1 + 0.2)          # 0.30000000000000004
print(0.1 + 0.2 == 0.3)   # False

# Exact representation in binary fractions (powers of 2)
# 0.5 (1/2) and 0.25 (1/4) can be stored exactly
print(0.25 + 0.5)         # 0.75
print(0.25 + 0.5 == 0.75) # True

Common mistakes

Division always returns float

# Even when dividing evenly
result = 10 / 2
print(result)       # 5.0 (not 5)
print(type(result)) # <class 'float'>

# Use // for integer result
result = 10 // 2    # 5

Can't use commas in numbers

# Wrong
million = 1,000,000  # Creates a tuple, not a number!

# Right
million = 1000000    # Hard to read
million = 1_000_000  # Python style

What’s next?

Now let’s learn about working with text in Python!

Strings

Text and characters

Getting started

Data types

Working with data

Control flow

Data structures

Packing & Unpacking

Two types of numbers

Why two types?

Basic math operations

Integer vs float division

Memory & Floating-Point Precision

1. Everything is an Object

3. Floating-Point Precision Issues

Common mistakes

What’s next?

Strings

​Two types of numbers

​Why two types?

​Basic math operations

​Integer vs float division

​Memory & Floating-Point Precision

​1. Everything is an Object

​2. Integer Caching (Object Sharing)

​3. Floating-Point Precision Issues

​Common mistakes

​What’s next?

Strings

Two types of numbers

Why two types?

Basic math operations

Integer vs float division

Memory & Floating-Point Precision

1. Everything is an Object

2. Integer Caching (Object Sharing)

3. Floating-Point Precision Issues

Common mistakes

What’s next?