Python Essentials

basics beginner

Interpreter

Python code is run by an interpreter, which reads and executes your program.

basics beginner

Variables & Types

Python is dynamically typed: you don’t declare types, but they exist at runtime.

details / example

name = "Felipe"          # str
age = 30                 # int
ratio = 0.5              # float
active = True            # bool
items = None             # NoneType

type(age)                # <class 'int'>

Type hints (age: int = 30) are optional but increasingly standard; they help with editor autocomplete and tools like mypy.

basics beginner

f-strings

The modern way to interpolate values into strings.

details / example

name = "Felipe"
count = 42

print(f"Hello, {name}!")
print(f"Found {count} items")
print(f"Ratio: {count / 100:.2f}")    # formatting
print(f"{name=}")                      # → name='Felipe'

Always prefer f-strings over .format() or % formatting. The = debug syntax is great for quick logging.

basics beginner

REPL

The REPL is an interactive Python session for trying code one line at a time.

details / example

REPL means read, evaluate, print, loop.

Example:

>>> 2 + 2
4

Real-world example: use the REPL to quickly test string methods, math, imports, or small expressions before putting them in a script.

basics beginner

Control Flow

Conditional execution with if/elif/else. Indentation defines blocks; there are no braces.

details / example

status = response.status_code

if status == 200:
    print("OK")
elif status < 500:
    print("Client error")
else:
    print("Server error")

# ternary
msg = "OK" if status == 200 else "Error"

Standard indent is 4 spaces, never tabs. Most editors (and tools like ruff/black) enforce this automatically.

basics beginner

Loops

Iterate over sequences with for, repeat conditions with while.

details / example

for item in items:
    print(item)

for i, item in enumerate(items):
    print(f"{i}: {item}")

for key, value in config.items():
    print(f"{key} = {value}")

while queue:
    process(queue.pop())

enumerate for index+value, .items() for dict pairs, zip for parallel iteration. Avoid for i in range(len(items)); it’s a code smell.

basics beginner

Functions

Reusable blocks of logic with arguments and an optional return value.

details / example

def greet(name: str, greeting: str = "Hello") -> str:
    return f"{greeting}, {name}!"

greet("Felipe")                  # uses default
greet("Felipe", greeting="Hey")  # keyword arg

# *args and **kwargs
def log(*args, **kwargs):
    print(args, kwargs)

Use type hints in any code others will read. Default arguments must be immutable: never def f(x=[]) (it’s shared across calls).

data beginner

Types

A type describes what kind of value something is and what operations it supports.

basics beginner

None & Truthiness

Empty containers, 0, and None all evaluate as False in conditions.

details / example

items = []
if not items:
    print("empty")

value = config.get("key")     # returns None if missing
if value is None:
    value = "default"

# short version
value = config.get("key") or "default"

Always use is None / is not None to compare with None; == works but is non-idiomatic.

data beginner

Strings

A string, or str, stores text.

data-structures beginner

Lists

Ordered, mutable sequence: your default choice for collections.

details / example

items = [1, 2, 3]
items.append(4)              # [1, 2, 3, 4]
items[0]                     # 1
items[-1]                    # 4 (last)
items[1:3]                   # [2, 3] (slice)
len(items)                   # 4
[x * 2 for x in items]       # comprehension

Slicing is one of Python’s superpowers: [start:end:step]. Negative indices count from the end.

data-structures beginner

Dictionaries

Key-value mapping with O(1) lookup.

details / example

user = {"name": "Felipe", "role": "admin"}
user["name"]                  # "Felipe"
user.get("email", "N/A")      # safe lookup with default
user["email"] = "f@x.com"     # add/update

for key, value in user.items():
    print(key, value)

Use .get() to avoid KeyError when a key might be missing. Dicts preserve insertion order since 3.7.

data-structures beginner

Tuples & Sets

Tuples are immutable lists; sets are unordered collections of unique items.

details / example

# tuples: fixed structure
point = (10, 20)
x, y = point                 # unpacking

# sets: uniqueness, fast membership tests
seen = {1, 2, 3}
seen.add(4)
2 in seen                    # True (O(1))
list(set(items))             # dedupe a list

Tuples for fixed records (coordinates, multiple return values). Sets when you need uniqueness or fast in checks.

data-structures beginner

Comprehensions

Concise way to build a list, dict, or set from an iterable.

details / example

# list comprehension
evens = [x for x in range(10) if x % 2 == 0]

# dict comprehension
squares = {x: x**2 for x in range(5)}

# filter + transform
names = [u["name"].upper() for u in users if u["active"]]

Readable for simple cases. If a comprehension grows past one line or has nested loops, use a regular for-loop instead.

data-structures beginner

Iterating Patterns

enumerate, zip, and dict.items() cover most iteration needs.

details / example

names = ["Ana", "Bob", "Cy"]
ages = [30, 25, 28]

for i, name in enumerate(names):
    print(i, name)

for name, age in zip(names, ages):
    print(name, age)

for k, v in config.items():
    print(k, v)

These three handle 90% of iteration patterns. zip stops at the shortest iterable.

data beginner

Sets

A set stores unique values with no guaranteed order.

details / example

Example:

tags = {"python", "git", "python"}
print(tags)  # {'python', 'git'}

Real-world example: use a set to remove duplicates or quickly test whether an item has already been seen.

modules-env beginner

Imports

Bring code from other files or installed packages into your script.

details / example

import os                            # whole module
from pathlib import Path             # specific name
from datetime import datetime as dt  # alias

# your own modules
from utils.auth import validate

Group imports: stdlib first, then third-party, then your own, separated by blank lines. Tools like ruff enforce this automatically.

modules-env beginner

uv Project Setup

uv handles your project’s virtual environment, dependencies, lockfile, and Python version automatically.

details / example

uv init my-project          # new project scaffold
cd my-project

uv add requests              # adds to pyproject.toml + installs
uv add --dev pytest ruff     # dev-only deps
uv remove requests
uv sync                      # install everything from pyproject.toml

uv init creates .venv/ (auto-gitignored), pyproject.toml, and uv.lock. No need to activate the venv manually; uv run handles it.

modules-env beginner

uv run

Run a Python command inside the project’s environment without activating it.

details / example

uv run python script.py
uv run pytest
uv run python -m mypackage.cli

# one-off scripts with inline deps
uv run --with requests script.py

Replaces the old source .venv/bin/activate && python ... ritual. uv run auto-syncs deps if pyproject.toml has changed since the last run.

modules-env beginner

Python Versions

uv installs and switches between Python versions per project.

details / example

uv python install 3.12
uv python install 3.11
uv python list             # available + installed

# pin the project to a version
uv python pin 3.12         # writes .python-version

# one-off run with a different version
uv run --python 3.11 script.py

No more pyenv, brew install python@3.x, or fighting system Python. uv installs versions side-by-side and picks the right one based on .python-version.

functions beginner

return vs print

return sends a value back to the caller; print displays text in the terminal.

details / example

Example:

def add(a, b):
    return a + b

result = add(2, 3)
print(result)

Real-world example: use return when other code needs the result. Use print for humans reading terminal output.

modules-env beginner

pyproject.toml

The project config file: declares dependencies, Python version, scripts, and tool settings.

details / example

[project]
name = "my-tool"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
    "requests>=2.31",
    "pydantic>=2.0",
]

[tool.uv]
dev-dependencies = [
    "pytest>=8.0",
    "ruff>=0.1",
]

One file replaces requirements.txt, setup.py, and various tool configs. Tools like ruff and pytest can also be configured here under [tool.*] sections.

functions intermediate

Scope

Scope determines where a name can be used.

details / example

Variables created inside a function are local to that function.

Example:

def greet():
    message = "hello"
    return message

Real-world example: local scope helps functions avoid accidentally changing unrelated parts of a program.

modules-env beginner

uv tool (uvx)

Install Python CLIs globally without polluting any project’s environment.

details / example

uv tool install ruff
uv tool install httpie
uv tool list

# run without installing
uv tool run black file.py
uvx black file.py            # short form

For tools you want available everywhere (linters, formatters, CLIs). Each gets its own isolated env. uvx is shorthand for uv tool run, handy for one-offs.

organization intermediate

name guard

The if __name__ == "__main__" guard runs code only when a file is executed directly.

details / example

Example:

def main():
    print("running")

if __name__ == "__main__":
    main()

Real-world example: this lets a file be both importable as a module and runnable as a script without accidentally executing script behavior during import.

modules-env beginner

Standard Library

Modules you’ll reach for constantly: pathlib, json, os, datetime, re.

details / example

from pathlib import Path
import json, os, re
from datetime import datetime, timedelta

Path("config.json").read_text()
json.loads(raw)
os.environ.get("API_KEY")
datetime.now() - timedelta(days=7)
re.match(r"^\d+$", "123")

Prefer pathlib over the older os.path. os.environ for env vars. json for parsing API responses and config files.

utilities beginner

File I/O

Read and write files with the with statement to auto-close.

details / example

# read
with open("data.txt") as f:
    content = f.read()

# read line by line
with open("log.txt") as f:
    for line in f:
        process(line.strip())

# write
with open("out.txt", "w") as f:
    f.write("hello\n")

Always use with; it closes the file even on errors. For JSON, use json.load(f) / json.dump(data, f).

tooling beginner

Virtual environments

A virtual environment isolates a project’s Python packages from the rest of your machine.

details / example

Example:

python -m venv .venv
source .venv/bin/activate

Real-world example: one project can use Django 5 while another older project still uses Django 3, without package conflicts.

utilities beginner

Error Handling

try/except catches exceptions; handle specific ones, not bare except.

details / example

try:
    data = json.loads(raw)
except json.JSONDecodeError as e:
    print(f"Bad JSON: {e}")
    data = {}
except Exception as e:
    logger.exception("Unexpected error")
    raise
finally:
    cleanup()

Catch specific exceptions when you can recover. Bare except: hides bugs. Use logger.exception to capture the full traceback.

tooling beginner

pip

pip installs Python packages from package indexes like PyPI.

details / example

Examples:

pip install requests
pip freeze > requirements.txt

Real-world example: use requirements.txt or another dependency file so another developer can install the same packages your project needs.

utilities beginner

pathlib

Object-oriented file paths: the modern replacement for os.path.

details / example

from pathlib import Path

p = Path("data") / "users.json"     # joining
p.exists()
p.parent                            # Path("data")
p.suffix                            # ".json"
p.read_text()
p.write_text("hello")

for f in Path(".").glob("*.py"):
    print(f)

The / operator for joining paths is way cleaner than os.path.join. Works on all platforms and handles Windows backslashes for you.

utilities beginner

subprocess

Run shell commands from Python and capture output.

details / example

import subprocess

result = subprocess.run(
    ["git", "status", "--short"],
    capture_output=True,
    text=True,
    check=True,
)
print(result.stdout)

Always pass arguments as a list (not a string) to avoid shell injection. check=True raises on non-zero exit codes, saving you from silent failures.

utilities beginner

argparse

Build CLI tools with parsed flags and positional arguments.

details / example

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("filename")
parser.add_argument("--verbose", "-v", action="store_true")
parser.add_argument("--limit", type=int, default=10)

args = parser.parse_args()
print(args.filename, args.verbose, args.limit)

Auto-generates --help text. For richer CLIs (subcommands, colored output), libraries like click or typer are popular alternatives.

files intermediate

Context managers

A context manager sets something up and reliably cleans it up afterward.

details / example

The with statement uses context managers.

Example:

with open("notes.txt") as file:
    text = file.read()

Real-world example: files opened with with are closed automatically, even if an error happens while reading.

workflows intermediate

Set Up a New Project

Bootstrap a new Python project with uv. One tool handles the venv, dependencies, Python version, and lockfile.

details / example

# 1. Create the project scaffold
uv init my-tool
cd my-tool

# 2. Pin a Python version
uv python pin 3.12

# 3. Add runtime + dev deps
uv add requests pydantic
uv add --dev pytest ruff

# 4. Initialize git
git init
# uv has already created a .gitignore covering .venv/ etc.
git add . && git commit -m "Initial commit"

uv init scaffolds a working project in seconds: pyproject.toml, .gitignore, .python-version, README. uv add updates pyproject.toml and the lockfile in one step. The lockfile (uv.lock) should be committed.

workflows intermediate

Run Scripts & Modules

Two main ways to run Python code with uv, plus the __main__ guard for files meant to be both run and imported.

details / example

# 1. Run a script or module
uv run python script.py
uv run python -m mypackage.cli      # for packages

# 2. Run an entry point defined in pyproject.toml
uv run mytool                       # if [project.scripts] defines it

# 3. The "main" guard (only runs when executed directly)
def main():
    ...

if __name__ == "__main__":
    main()

Use python -m form when running anything inside a package; direct execution breaks relative imports. The __main__ guard prevents code from running when the file is imported elsewhere.

data beginner

None

None represents the absence of a value.

details / example

Use is None instead of == None. None is a singleton (only one None object exists in a Python program), so identity (is) is the canonical and override-proof check.

Example:

if result is None:
    print("nothing found")

Real-world example: a lookup function might return None when it cannot find a matching user.

workflows intermediate

Read JSON Config

A common pattern: parse a JSON config file with sensible error handling and fallback to defaults.

details / example

import json
from pathlib import Path

CONFIG_PATH = Path.home() / ".myapp" / "config.json"
DEFAULTS = {"theme": "dark", "port": 8080}

def load_config() -> dict:
    if not CONFIG_PATH.exists():
        return DEFAULTS
    try:
        user = json.loads(CONFIG_PATH.read_text())
        return {**DEFAULTS, **user}
    except json.JSONDecodeError as e:
        print(f"Invalid config: {e}")
        return DEFAULTS

Merge defaults with user config so missing keys fall back gracefully. For richer validation (types, required fields), reach for pydantic.

object-oriented intermediate

Classes and objects

A class defines a type of object with data and behavior.

details / example

Example:

class User:
    def __init__(self, name):
        self.name = name

user = User("Felipe")

Real-world example: use classes to model concepts like users, posts, invoices, or game characters.

workflows intermediate

Debug

Three escalating tools: print, breakpoint, and logging. Each is appropriate at different times.

details / example

# 1. print debugging (quick and dirty)
print(f"{user=} {response.status=}")

# 2. drop into pdb at any line
breakpoint()                # then: n, s, c, p var, q

# 3. logging (for real apps)
import logging
logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger(__name__)
log.debug("payload: %s", payload)

breakpoint() is built into Python 3.7+; it pauses execution so you can inspect state interactively. For production code use logging, never print, so output can be configured per environment.

object-oriented intermediate

self

self refers to the current object inside a class method.

details / example

Example:

class Counter:
    def __init__(self):
        self.count = 0

    def increment(self):
        self.count += 1

Real-world example: self.count belongs to one specific counter object, not every counter at once.

workflows intermediate

Test with pytest

The standard Python testing framework. Tests are functions starting with test_ in files named test_*.py.

details / example

# test_auth.py
from auth import validate_email

def test_valid_email():
    assert validate_email("a@b.com")

def test_rejects_missing_at():
    assert not validate_email("invalid")

# parametrize for many cases
import pytest

@pytest.mark.parametrize("email", ["a@b.com", "x@y.io"])
def test_various_valid(email):
    assert validate_email(email)

# run
uv run pytest -v
uv run pytest tests/test_auth.py::test_valid_email

Test what’s likely to break, not implementation details. Run with -v for verbose output, -k name to filter by test name, -x to stop at first failure.

patterns intermediate

Generators

A generator produces values lazily, one at a time, instead of building a whole list.

details / example

Example:

def countdown(n):
    while n > 0:
        yield n
        n -= 1

Real-world example: generators are useful for processing large files or streams because they do not need to keep every value in memory.

tooling intermediate

Type hints

Type hints document expected value types and help tools catch mistakes.

details / example

Example:

def greet(name: str) -> str:
    return f"hello, {name}"

Python usually does not enforce type hints at runtime, but editors and checkers can use them to find bugs earlier.

Interpreter

Variables & Types

f-strings

REPL

Control Flow

Loops

Functions

Types

None & Truthiness

Strings

Lists

Dictionaries

Tuples & Sets

Comprehensions

Iterating Patterns

Sets

Imports

uv Project Setup

uv run

Python Versions

return vs print

pyproject.toml

Scope

uv tool (uvx)

__name__ guard

Standard Library

File I/O

Virtual environments

Error Handling

pip

pathlib

subprocess

argparse

Context managers

Set Up a New Project

Run Scripts & Modules

None

Read JSON Config

Classes and objects

Debug

self

Test with pytest

Generators

Type hints

name guard