Core Concepts of Python

The Big Picture

Every Python program is built from these six building blocks. Master them and you can build anything.

Variables & Types

Variables are names that point to values. Python has four basic types you'll use constantly: int (integers), float (decimals), str (text), and bool (True/False). Python is dynamically typed, so you never declare a type — Python figures it out at runtime.

name = "Alice"        # str
age = 30              # int
pi = 3.14             # float
active = True         # bool
print(f"{name} is {age}")  # f-string

Since Python 3.5, you can add type hints — optional annotations that document what types a function expects. They don't enforce anything at runtime, but they make your code easier to read and help IDEs catch bugs.

Control Flow

Control flow is how you tell Python to make decisions and repeat actions. The three workhorses: if/elif/else for branching, for loops for iterating, and while loops for repeating until a condition changes.

The crucial thing to understand: indentation IS syntax in Python. Other languages use curly braces {} to group code — Python uses 4 spaces. This isn't optional; it's how the interpreter knows which code belongs to which block.

for item in items:
    if item.price > 100:
        print(f"Expensive: {item.name}")
    else:
        print(f"Budget: {item.name}")

Python also has break (exit a loop early), continue (skip to the next iteration), and pass (do nothing — placeholder for empty blocks).

Functions

Functions let you write a block of code once and reuse it everywhere. Define with def, pass in parameters, get back a result with return. Python supports default arguments, *args (variable positional args), and **kwargs (variable keyword args).

def calculate_tax(amount, rate=0.1):
    """Calculate tax for a given amount."""
    return amount * rate

tax = calculate_tax(1000)        # 100.0 (uses default rate)
tax = calculate_tax(1000, 0.2)   # 200.0 (custom rate)

Functions are first-class objects in Python — you can assign them to variables, pass them as arguments, and return them from other functions. This makes patterns like decorators and callbacks natural.

Data Structures

Python has four built-in data structures. Knowing when to use each one is just as important as knowing how.

names = ["Alice", "Bob", "Charlie"]          # list
scores = {"Alice": 95, "Bob": 87}            # dict
unique = {1, 2, 3, 2, 1}                     # set → {1, 2, 3}
point = (10, 20)                              # tuple (immutable)
evens = [x for x in range(10) if x % 2 == 0] # comprehension

Modules & Packages

A module is any .py file. A package is a folder of modules. Python's import system lets you use code from the standard library, third-party packages (installed via pip), or your own files.

import pandas as pd              # import entire module with alias
from datetime import datetime    # import specific class
from pathlib import Path         # modern file path handling

Third-party packages live on PyPI (Python Package Index). Install with pip install pandas. Always use a virtual environment (python -m venv .venv) to keep project dependencies isolated.

Classes (OOP)

Classes let you create your own data types that bundle data (attributes) and behavior (methods) together. The __init__ method runs when you create an instance. The self parameter refers to the current instance.

class Patient:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        return f"Patient: {self.name}, Age: {self.age}"

p = Patient("Alice", 30)
print(p.greet())  # Patient: Alice, Age: 30

Python supports inheritance (create specialized versions of a class), encapsulation (prefix attributes with _ to signal "private"), and polymorphism (different classes responding to the same method name). But Python's philosophy is practical: use classes when they make sense, not just because you can.

Python vs Other Languages

How does Python compare to the other languages you'll encounter?