Variables & Data Types

Variables

A variable is a name that refers to a value stored in memory. You create one with the assignment operator =:

name = "Alice"
age = 30
pi = 3.14159
is_student = True

The left side is the name; the right side is the value. Python figures out the type automatically — you never need to declare it.

Multiple assignment

# Assign several variables at once
x, y, z = 1, 2, 3

# Same value to multiple names
a = b = c = 0

# Swap two variables (no temp needed!)
x, y = y, x

Naming Rules & Conventions

PEP 8 conventions

• Variables & functions: snake_case — all lowercase, words separated by underscores.
• Constants: UPPER_SNAKE_CASE — e.g. MAX_RETRIES = 5
• Classes: PascalCase — e.g. HttpClient (covered in Lesson 20)
• Avoid single-letter names except for simple loop counters (i, j).

Core Data Types

Every value in Python has a type. Use the built-in type() function to check:

print(type(42))          # <class 'int'>
print(type(3.14))        # <class 'float'>
print(type("hello"))     # <class 'str'>
print(type(True))        # <class 'bool'>
print(type(None))        # <class 'NoneType'>

int — Integers

Whole numbers with no decimal point. Python integers have unlimited precision — they can be as large as your memory allows.

count = 10
negative = -7
big = 1_000_000_000     # underscores for readability
hex_val = 0xFF          # 255 in hexadecimal
bin_val = 0b1010        # 10 in binary

float — Floating-Point Numbers

Numbers with a decimal point. Internally stored as 64-bit IEEE 754 doubles.

price = 9.99
temperature = -40.0
scientific = 6.022e23   # 6.022 × 10²³

str — Strings

Text data enclosed in single quotes, double quotes, or triple quotes:

greeting = "Hello, World!"
letter = 'A'
multiline = """This string
spans multiple
lines."""

# Strings are immutable — you can't change a character in place
# greeting[0] = 'h'  ← TypeError!

We'll explore strings in full depth in Lesson 03.

bool — Booleans

Two possible values: True or False (capitalised). Used for logic and conditions.

is_active = True
has_permission = False

# Booleans are actually integers under the hood
print(True + True)    # 2
print(False * 100)    # 0

None — The Absence of a Value

None is Python's null value. It represents "nothing" or "not yet assigned".

result = None

if result is None:
    print("No result yet")

Type Conversion (Casting)

Python provides built-in functions to convert between types:

# String → Integer
age = int("25")           # 25

# String → Float
price = float("9.99")    # 9.99

# Number → String
label = str(100)          # "100"

# Truthy / Falsy → Boolean
print(bool(0))            # False
print(bool(""))           # False
print(bool(42))           # True
print(bool("hello"))      # True

Truthy and falsy values

When converted to bool, these values are falsy (evaluate to False):

Everything else is truthy.

Dynamic vs Static Typing

Python is dynamically typed — a variable's type is determined at runtime by whatever value is assigned to it. Compare this with statically typed languages (Java, C, Rust) where you must declare types up front.

x = 10        # x is an int
x = "ten"     # now x is a str — no error, but be careful!

# Python 3.6+ supports TYPE HINTS (optional annotations)
age: int = 30
name: str = "Alice"
# These don't enforce anything at runtime — they're for
# documentation and tools like mypy (Lesson 30).

count = 42
rate = 3.14
name = "Python"
active = True
data = None

print(count, type(count))     # 42 <class 'int'>
print(rate, type(rate))       # 3.14 <class 'float'>
print(name, type(name))       # Python <class 'str'>
print(active, type(active))   # True <class 'bool'>
print(data, type(data))       # None <class 'NoneType'>

a = "left"
b = "right"

a, b = b, a

print(a)  # right
print(b)  # left

birth_year = input("Enter your birth year: ")
birth_year = int(birth_year)   # cast string → int
age = 2024 - birth_year
print("You are about " + str(age) + " years old.")