Numbers, Text, and True/False (Data Types)

Think about your kitchen for a second. You've got a mug for coffee, a bowl for soup, a wine glass for... well. The point is: different containers are built for different things. You could pour coffee into a bowl, but it'd be weird and messy. You wouldn't store olive oil in a paper bag.

Data works the same way. A phone number and a person's name are both "information" — but they're fundamentally different kinds of information. You do math with one; you display the other. If you try to add a name to a number without being explicit about what you're doing, things break.

That's why programming languages have data types: categories that tell the computer what kind of information something is, and therefore what you can do with it.

Python's Four Basic Data Types

Notice that "42" (with quotes) is a string — the text that looks like a number. And 42 (without quotes) is an integer — the actual number. They look similar but are completely different things. You can do math with 42. You cannot do math with "42".

Integers: Whole Numbers

Integers are the counting numbers — no decimals, no fractions. They can be positive, negative, or zero.

apples = 5
temperature = -3
year = 2024
population = 8000000000

Arithmetic Operators

Python supports every math operation you'd expect, plus a couple of useful extras:

Regular division vs integer division:

print(10 / 3)    # 3.3333333333333335 — always returns a float
print(10 // 3)   # 3 — drops the decimal, keeps only the whole number
print(10 % 3)    # 1 — the remainder after dividing (10 = 3×3 + 1)

The modulo operator (%) sounds obscure but is incredibly useful. Want to know if a number is even or odd? number % 2 — if the result is 0, it's even; if 1, it's odd. Want to wrap around a list? Modulo does it. You'll use it more than you expect.

Floats: Decimal Numbers

Floats represent numbers with decimal points — prices, measurements, percentages.

price = 19.99
temperature = 36.6
pi = 3.14159
discount = 0.15

The Floating Point Surprise

Here's something that trips up nearly every new programmer:

print(0.1 + 0.2)

You'd expect 0.3. You actually get:

0.30000000000000004

This isn't a Python bug — it's a fundamental limitation of how all computers store decimal numbers in binary. Floats are stored as approximations. For most purposes this doesn't matter, but for money calculations (where precision is critical), be aware of it.

The fix: use round()

result = round(0.1 + 0.2, 2)
print(result)    # 0.3

round(value, decimal_places) rounds a float to the number of decimal places you specify.

price = 19.987654
print(round(price, 2))    # 19.99

Strings: Text in Python

Any time you're working with text — names, messages, sentences, symbols — you're working with strings. In Python, strings are created by wrapping text in quotes.

first_name = "Alice"
last_name = 'Wonderland'     # Single quotes work too
greeting = "Hello, World!"
empty = ""                   # Empty string is valid

Both single quotes ' and double quotes " create strings. The only rule: start and end with the same type.

String Operations

Concatenation (joining strings with +):

first = "Hello"
second = "World"
message = first + ", " + second + "!"
print(message)    # Hello, World!

Finding the length with len():

name = "Anastasia"
print(len(name))    # 9

len() counts every character, including spaces:

print(len("hello world"))    # 11

Repetition with *:

print("ha" * 3)       # hahaha
print("-" * 20)       # --------------------

This is why we could do "=" * 30 in the first lesson — Python just repeats the string that many times.

Booleans: True and False

Booleans are the simplest data type: they can only ever be one of two values — True or False. (Note the capital T and F — Python is case-sensitive.)

is_raining = True
has_umbrella = False
is_logged_in = True

On their own, they seem almost too simple to be useful. But booleans become powerful when you combine them with comparison operators — the way your program asks questions and makes decisions.

Comparison Operators

age = 18
print(age >= 18)     # True
print(age == 21)     # False
print(age != 21)     # True

score = 75
print(score > 50)    # True
print(score < 50)    # False

Notice == (double equals) checks equality. A single = is assignment (storing a value). This is a very common source of bugs for beginners — using = when you meant ==. Python will catch it with an error, so don't worry too much; just remember the distinction.

The type() Function

Not sure what type a variable is? Ask Python directly:

x = 42
y = 3.14
z = "hello"
w = True

print(type(x))    # <class 'int'>
print(type(y))    # <class 'float'>
print(type(z))    # <class 'str'>
print(type(w))    # <class 'bool'>

The type() function is your inspector — use it whenever you're not sure what you're dealing with. You'll find it especially useful when debugging.

Real Example: A Simple Bank Balance Program

Let's use all four types together in something realistic:

# Simple bank account summary
account_holder = "Marcus Obi"        # str  — name is text
account_number = 10042867            # int  — whole number, no decimals
balance = 1247.83                    # float — money has decimal places
is_active = True                     # bool — account status

# Calculations
deposit = 200.00
new_balance = balance + deposit

# Display summary
print("=" * 35)
print("  ACCOUNT SUMMARY")
print("=" * 35)
print(f"Account Holder : {account_holder}")
print(f"Account Number : {account_number}")
print(f"Current Balance: ${balance:.2f}")
print(f"After Deposit  : ${new_balance:.2f}")
print(f"Account Active : {is_active}")
print("=" * 35)

Output:

===================================
  ACCOUNT SUMMARY
===================================
Account Holder : Marcus Obi
Account Number : 10042867
Current Balance: $1247.83
After Deposit  : $1447.83
Account Active : True
===================================

What each type is doing:

• str — holding the account holder's name, displayed as text
• int — holding the account number (whole number, never a decimal)
• float — holding the balance (money always has cents)
• bool — flagging whether the account is active (yes/no question)

Each type was chosen because it matches the nature of the data it holds. You wouldn't store a bank balance as a string, or a person's name as an integer.

Quick Reference: Operations by Type

Key Takeaways

• Python has four basic data types: int, float, str, and bool
• int — whole numbers; supports all standard math operations including // and %
• float — decimal numbers; watch out for floating point precision; use round() when needed
• str — text wrapped in quotes; use + to join, * to repeat, len() to measure
• bool — only True or False; created by comparison operators (==, !=, >, etc.)
• Use type() to check what type a variable is at any time
• Choosing the right type for your data is a fundamental programming skill