Python — beyond the basics

From 'does it work?' to 'can you read it?'

Basics let a script run. Advanced lets you live inside a real project — the skill this deck builds.

A file is a module

Big programs don't fit in one file. Modules are how Python splits work into named boxes.

Imports in a real file

Three shapes: whole module, specific pieces, and your own project's modules.

import json                  # standard library — ships with Python
import requests              # installed with pip (see requirements.txt)

from utils import clean_name # a module in YOUR project
from models import User

print(json.__file__)         # proof: every module is just a .py file

Standard library, pip packages, and your own files — all enter through the same door.

venv — one project, one Python

Your laptop has a Python. Your project gets its own copy — isolated, versioned, disposable.

venv in practice

The four commands every Python project starts with.

pip & requirements.txt

pip installs packages; requirements.txt is the shopping list that makes it repeatable.

The world is unreliable

Every one of these will happen in production. The question is what your app does when it does.

try / except / finally

One shape, three jobs: attempt the risky part, recover from known failure, always tidy up.

def load(path):
    try:
        with open(path) as f:      # the risky part
            return f.read()
    except FileNotFoundError:      # one known failure
        print("no such file:", path)
        return ""                  # graceful fallback
    finally:
        print("done")              # ALWAYS runs

try = the attempt · except = the plan B for a named error · finally = cleanup that can't be skipped.

raise — stop with a reason

Sometimes the right move is to refuse: raise an exception that names the problem.

def set_age(user, value):
    if not isinstance(value, int):
        raise TypeError("age must be an int")   # stop, with a reason

try:
    set_age(user, "thirty")        # boom: TypeError
except TypeError as e:             # e carries the message
    logging.warning("bad input: %s", e)

raise = a structured 'no, and here's why'. Catching it far away keeps the crash message useful.

Specific catches; deliberate crashes

Two habits that separate careful code from lucky code — and red flags to spot in AI output.

List comprehension — a loop in one line

The most common 'advanced' idiom. It builds a list from a collection — filter + transform.

prices = [1200, 45, 999, 12]

# the plain loop
over_100 = []
for p in prices:
    if p > 100:
        over_100.append(p)

# the same thing, one lineover_100 = [p for p in prices if p > 100]   # [1200, 999]

Read right-to-left: take each p in prices, keep it if p > 100, collect the results.

Dict comprehension — building lookups

Same idea with braces: build a dict from a loop — the go-to move for lookups by id.

users = [{"id": 1, "name": "An"},
         {"id": 2, "name": "Minh"},
         {"id": 3, "name": "Linh"}]

# build a dict from a loop: id -> name
by_id = {u["id"]: u["name"] for u in users}
# {1: "An", 2: "Minh", 3: "Linh"}

One line turns a list of records into an instant lookup table — you'll see this everywhere.

JSON — the wire format of the web

Browsers, APIs, databases, and your Flask app all speak it. In Python it's almost free.

json.loads / json.dumps

Two functions, two directions — the only JSON you'll ever need.

import json

text = '{"name": "An", "score": 9}'      # JSON in (e.g. from an API)
data = json.loads(text)                   # text -> dict
print(data["score"])                     # 9

out = json.dumps(data, indent=2)          # dict -> text
print(out)                                # back to JSON, for the wire

loads = load (text in), dumps = dump (text out). The names describe the direction.

Calling other people's APIs

Your app rarely does everything alone. The requests library turns HTTP into two lines.

An API call, end to end

The exact shape you'll find in half of any backend's code.

import requests

r = requests.get("https://api.example.com/users",
                 headers={"Authorization": "Bearer " + TOKEN})

if r.status_code == 200:          # 2xx = success
    users = r.json()              # response text -> list of dicts
else:
    logging.error("API error: %s", r.status_code)

Call → check the verdict → parse the payload. That's the whole dance.

Environment variables — secrets out of the code

The same code must run on your laptop, staging and production — with different values.

Reading config from the environment

Optional with a default, or required with a loud failure — never a silent secret.

import os

DB_URL  = os.environ.get("DB_URL", "sqlite:///dev.db")  # optional
SECRET  = os.environ.get("SECRET")                       # required

if SECRET is None:                # fail loudly, at startup
    raise RuntimeError("SECRET not set")

The app refuses to boot without what it needs — a crash on start beats a mystery at 3 a.m.

with — guaranteed cleanup

Resources (files, database connections) are borrowed. with promises they'll be returned.

File I/O with with

Read and write, two lines of ceremony, zero cleanup on your mind.

# 'with' = the file closes for you, even on error
with open("data.csv") as f:        # read (default mode)
    for line in f:                  # a file is a list of lines
        print(line.strip())

with open("out.txt", "w") as f:    # 'w' = write (erase first)
    f.write("hello\n")
# <- already closed; no f.close() needed

w erases first, a appends, r reads. with makes the closing automatic.

print is for you; logging is for the app

The single most common 'works on my machine' habit — and the fix for it.

logging in five lines

Set the level once; then the app narrates its life.

import logging

logging.basicConfig(level=logging.INFO)

logging.info("server starting on port 9151")
logging.warning("low disk space")
logging.error("failed to reach API")
# 2026-10-27 00:36:59,123 INFO __main__: server starting...

Every line carries a timestamp and a severity — searchable, sortable, filterable. print never could.

A class bundles data + behavior

The one 'big' concept — and really just a named shape for a kind of thing.

The smallest useful class

Ten lines: data in __init__, one behavior, one instance. That's the whole pattern.

class User:
    def __init__(self, name, email):   # runs on User(...)
        self.name = name               # data on THIS user
        self.email = email

    def is_admin(self):               # a method: behavior
        return self.email.endswith("@corp.com")

me = User("An", "an@corp.com")
print(me.name, me.is_admin())         # An  True

class = blueprint · User(...) = one concrete thing · me.name / me.is_admin() = its data and behavior.

How to read a model in 30 seconds

You won't design frameworks — but you will open models.py daily. Here's the skim.

This is how a real Flask app stays alive

Open the course's own app and every pattern from this deck is in it.

Where each piece shows up

A cheat-sheet for reading any backend project.

Reading & extending code with AI

The daily loop, now with a bigger vocabulary.

1. 1

   Spot the pattern

   Scan the AI's code before asking anything: import? try/except? with open? a class? You now know what each shape is for.

2. 2

   Ask what it's doing

   Paste the block: 'explain this in simple words.' Compare the AI's answer with your own read — the gap is where learning happens.

3. 3

   Change one thing at a time

   Target a specific line or behavior. Small diffs stay verifiable; big asks hide mistakes.

4. 4

   Run it, read the output

   Output and the logs are the truth. Something broke? Paste the traceback — you now know where the real error lives.