Chapter 4 — Variables & Core Types

The why

Every program works with data. Variables are how you name and store that data. In Python, variables are more flexible than in languages like Java or C — you don't declare types, and a variable can hold any kind of value. That flexibility is powerful, but it causes bugs if you don't understand what's happening under the hood.

This chapter teaches you the mental model: variables are names bound to objects. Once you internalize that, Python's behavior makes sense instead of feeling like magic.

Core concepts: The five types you'll use daily

Python has five core types. Click each type to see its properties and use cases:

int - Integers

age = 30
temperature = -5
population = 8_000_000  # Underscores for readability
 
print(type(age))  # <class 'int'>

Properties:

• Type name: int
• Examples: 42, -5, 0, 1_000_000
• Precision: Arbitrary (no overflow)
• Use when: Counting, indexing, IDs, whole numbers
• Common operations: +, -, *, //, %, **

Key facts:

• Integers have arbitrary precision — they can be as large as memory allows. No overflow.
• Use underscores (_) to separate thousands: 1_000_000 is the same as 1000000.

float - Floating-Point Numbers

price = 19.99
pi = 3.14159
scientific = 1.5e10  # 1.5 × 10^10
 
print(type(price))  # <class 'float'>

Properties:

• Type name: float
• Examples: 3.14, -0.5, 1.5e10
• Precision: ~15 decimal digits (IEEE 754)
• Use when: Decimals, measurements, calculations
• Common operations: +, -, *, /, **

Key facts:

• Floats are approximations. 0.1 + 0.2 is not exactly 0.3 (see Chapter 5).
• Use round() to control precision: round(3.14159, 2) → 3.14.

str - Strings

name = "Alice"
greeting = 'Hello'
multiline = """This is
a multiline
string."""
 
print(type(name))  # <class 'str'>

Properties:

• Type name: str
• Examples: "hello", 'world', """multiline"""
• Mutability: Immutable
• Use when: Text, names, messages, data
• Common operations: + (concatenation), * (repetition), [] (indexing)

Key facts:

• Strings are immutable — you can't change a character in place.
• Use single or double quotes — they're interchangeable.
• Strings support indexing and slicing (covered in Chapter 5).

bool - Booleans

is_active = True
has_permission = False
 
print(type(is_active))  # <class 'bool'>

Properties:

• Type name: bool
• Examples: True, False
• Subclass: int (True = 1, False = 0)
• Use when: Conditions, flags, yes/no values
• Common operations: and, or, not, ==, !=

Key facts:

• Booleans are a subclass of int. True is 1, False is 0.
• True + True → 2. (Yes, really.)
• Most values have "truthiness" — non-zero numbers and non-empty strings are "truthy".

None - The Absence of a Value

result = None
user = get_user()  # Might return None if user doesn't exist
 
print(type(result))  # <class 'NoneType'>
print(result is None)  # True

Properties:

• Type name: NoneType
• Example: None
• Singleton: Yes (only one exists)
• Use when: Missing data, default values, "nothing"
• Check with: is None (not == None)

Key facts:

• None is a singleton — there's only one None object in memory.
• Use is None to check for it, not == None.
• Functions that don't explicitly return a value return None by default.

Variables are names, not boxes

In C or Java, a variable is a box in memory that holds a value. In Python, a variable is a name that refers to an object. The object lives somewhere in memory; the name is just a label pointing to it.

x = 42

This doesn't mean "put 42 in a box called x." It means "create an object 42 in memory, and bind the name x to it."

Why this matters:

x = 42
y = x
x = 100
print(y)  # 42, not 100

If variables were boxes, y = x would copy the value, and changing x wouldn't affect y. That's exactly what happens — but not because values are copied. It's because y is bound to the same object as x initially, and x = 100 rebinds x to a new object. y still points to the original 42.

Mental model: Think of variables as sticky notes attached to objects. x = 42 puts a sticky note labeled "x" on the object 42. y = x puts another sticky note "y" on the same object. x = 100 moves the "x" note to a new object 100. The "y" note stays on 42.

The core types

Python has five core types you'll use constantly:

int — integers

Whole numbers, positive or negative. No decimal point.

age = 30
temperature = -5
population = 8_000_000  # Underscores for readability (Python 3.6+)
 
print(type(age))  # <class 'int'>

Key facts:

• Integers have arbitrary precision — they can be as large as memory allows. No overflow.
• Use underscores (_) to separate thousands: 1_000_000 is the same as 1000000.

float — floating-point numbers

Numbers with a decimal point. Used for fractions, measurements, and anything that isn't a whole number.

price = 19.99
pi = 3.14159
scientific = 1.5e10  # 1.5 × 10^10
 
print(type(price))  # <class 'float'>

Key facts:

• Floats are approximations. 0.1 + 0.2 is not exactly 0.3 (see Chapter 5 for the full story).
• Use round() to control precision: round(3.14159, 2) → 3.14.

str — strings

Text. Sequences of Unicode characters enclosed in quotes.

name = "Alice"
greeting = 'Hello'
multiline = """This is
a multiline
string."""
 
print(type(name))  # <class 'str'>

Key facts:

• Strings are immutable — you can't change a character in place. "hello"[0] = "H" raises an error.
• Use single or double quotes — they're interchangeable. Use triple quotes for multiline strings.
• Strings support indexing and slicing (covered in Chapter 5).

bool — booleans

Two values: True and False. Used for conditions and logic.

is_active = True
has_permission = False
 
print(type(is_active))  # <class 'bool'>

Key facts:

• Booleans are a subclass of int. True is 1, False is 0.
• True + True → 2. (Yes, really.)
• Most values have a "truthiness" — non-zero numbers and non-empty strings are "truthy"; zero, empty strings, and None are "falsy" (covered in Chapter 6).

None — the absence of a value

None is Python's "nothing" value. It's used to represent the absence of a value, like null in other languages.

result = None
user = get_user()  # Might return None if the user doesn't exist
 
print(type(result))  # <class 'NoneType'>
print(result is None)  # True

Key facts:

• None is a singleton — there's only one None object in memory.
• Use is None to check for it, not == None.
• Functions that don't explicitly return a value return None by default.

type() and isinstance() — checking types

type() returns the type of an object:

x = 42
print(type(x))  # <class 'int'>
 
y = "hello"
print(type(y))  # <class 'str'>

isinstance() checks if an object is an instance of a type (or a subclass):

x = 42
print(isinstance(x, int))  # True
print(isinstance(x, str))  # False
 
# isinstance() also checks subclasses
print(isinstance(True,

When to use which:

• Use type() for debugging and introspection.
• Use isinstance() for type checks in your code — it's more flexible and handles inheritance.

Type conversion

Python can convert between types explicitly using type constructors:

int() — convert to integer:

int("42")      # 42
int(3.99)      # 3 (truncates, doesn't round)
int(True)      # 1
int(False)     # 0

float() — convert to float:

float("3.14")  # 3.14
float(42)      # 42.0
float("inf")   # inf (infinity)

str() — convert to string:

str(42)        # "42"
str(3.14)      # "3.14"
str(True)      # "True"
str(None)      # "None"

bool() — convert to boolean:

bool(0)        # False
bool(1)        # True
bool("")       # False (empty string)
bool("hello")  # True (non-empty string)
bool(None)     #

Conversion failures:

int("hello")   # ValueError: invalid literal for int() with base 10: 'hello'
float("abc")   # ValueError: could not convert string to float: 'abc'

Always handle conversion errors with try/except (covered in L1) or validate input first.

Dynamic typing: the mental model

Python is dynamically typed — variables don't have types; objects do. A variable can refer to any type of object, and it can change types.

x = 42        # x refers to an int
x = "hello"   # x now refers to a str
x = [1, 2, 3] # x now refers to a list

This is legal in Python. In Java or C, you'd get a compile error.

Why this is powerful:

• You can write generic functions that work with any type.
• You don't need to declare types upfront.
• Code is more concise and flexible.

Why this is dangerous:

• Bugs hide until runtime. x + 1 works if x is an int, but fails if x is a string.
• Large codebases become hard to reason about — you don't know what type a variable holds.
• IDEs can't provide good autocomplete or error checking.

The pragmatic solution: Use type hints (covered in L2) to annotate types without enforcing them. This gives you the flexibility of dynamic typing with the safety of static typing.

Real-world usage

Data processing: Variables hold data from files, APIs, and databases:

user_id = 12345           # int
username = "alice"        # str
balance = 100.50          # float
is_verified = True        # bool
middle_name = None        # NoneType

Configuration: Variables store settings:

DEBUG = True
MAX_RETRIES = 3
API_URL = "https://api.example.com"
TIMEOUT = 30.0

State tracking: Variables track program state:

count = 0
is_running = True
last_error = None

Common mistakes

Production notes

Type hints: In production code, use type hints to annotate variables and function signatures:

def greet(name: str) -> str:
    return f"Hello, {name}"
 
user_id: int = 12345

Type hints are optional and not enforced at runtime, but tools like mypy can check them statically. We'll cover type hints in L2.

Constants: Python doesn't have true constants (values that can't be changed). By convention, constants are written in ALL_CAPS:

MAX_RETRIES = 3
API_URL = "https://api.example.com"

These can still be reassigned, but the convention signals intent.

Memory management: Python uses reference counting and garbage collection. You don't need to manually free memory — when no names refer to an object, it's automatically cleaned up.

Practice: Prove your Mastery

def get_length(value: str) -> int: return len(value)

</Solution>
 
---
 
## Interview Questions
 
<Callout type="tip" title="Interview Questions">
 
**Beginner:**
 
1. **"What's the difference between a variable in Python and a variable in C?"**
   
   > In C, a variable is a box in memory that holds a value of a specific type. In Python, a variable is a name that refers to an object. The object has a type, not the variable. A Python variable can refer to any type of object.
 
2. **"What are the five core types in Python?"**
   
   > `int` (integers), `float` (floating-point numbers), `str` (strings), `bool` (booleans: `True`/`False`), and `None` (the absence of a value).
 
**Senior:**
 
1. **"Why is `True + True` equal to `2` in Python?"**
   
   > `bool` is a subclass of `int`. `True` is equivalent to `1`, and `False` is equivalent to `0`. So `True + True` is `1 + 1`, which is `2`.
 
2. **"What's the difference between `type(x) == int` and `isinstance(x, int)`?"**
   
   > `type(x) == int` checks if `x` is exactly an `int`. `isinstance(x, int)` checks if `x` is an `int` or a subclass of `int`. Since `bool` is a subclass of `int`, `isinstance(True, int)` returns `True`, but `type(True) == int` returns `False`. Use `isinstance()` for type checks — it's more flexible and handles inheritance.
 
</Callout>
 
---
 
## Summary
 
- Variables are names bound to objects, not boxes that hold values.
- The five core types: `int`, `float`, `str`, `bool`, `None`.
- Use `type()` for debugging, `isinstance()` for type checks.
- Convert types explicitly with `int()`, `float()`, `str()`, `bool()`.

Self-Check Quiz