Python or Flask First: What Beginners Should Learn

# python_fundamentals_1.py — the exact skills that make Flask easy later

# 1. Functions and dicts — the basis of every Flask view
def build_response(status="ok", message="hello"):
    return {"status": status, "message": message}


# 2. Functions as values — Flask relies on this everywhere
def make_greeting(name):
    def greet():
        return f"Hello, {name}!"
    return greet


say_hi = make_greeting("Aarav")
print(say_hi())  # "Hello, Aarav!"


# 3. Decorators — Flask's @app.get is literally a decorator
def log_calls(func):
    def wrapper(*args, **kwargs):
        print(f"calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper


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


print(add(2, 3))  # "calling add", then 5

# Why this matters for Flask:
# - Flask routes are decorated functions (@app.get("/")).
# - Flask views return dicts that get converted to JSON.
# - Flask uses higher-order functions and closures everywhere.
# Without these patterns, Flask feels like magic.
# With them, Flask feels like Python — because it is.

# python_fundamentals_2.py — the everyday Python skills Flask depends on

import json
import os


# 1. Files and JSON — Flask reads config and writes JSON responses
def load_config(path="config.json"):
    if not os.path.exists(path):
        return {"debug": True}
    with open(path, "r") as f:
        return json.load(f)


# 2. Error handling — Flask error handlers wrap try/except
def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return None
    except TypeError:
        return None


# 3. Classes — Flask blueprints and app factories use them
class AppConfig:
    def __init__(self, name, debug=False):
        self.name = name
        self.debug = debug

    def describe(self):
        return f"App {self.name} (debug={self.debug})"


cfg = AppConfig("todo", debug=True)
print(cfg.describe())


# 4. List comprehensions and generators
numbers = [1, 2, 3, 4, 5]
squared = [n * n for n in numbers]
print(squared)


# Why this matters for Flask:
# - Config, secrets, and JSON bodies are everyday Flask tasks.
# - Error handling is how you return 400/500 responses instead of crashing.
# - Classes appear in blueprints, extensions, and app factories.
# - List comprehensions are how you transform data before returning it.
# These are core Python — not Flask tricks.

# flask_app.py — what it looks like AFTER Python fundamentals
# If you can read the Python above, this entire file already makes sense.

from flask import Flask, jsonify, request

app = Flask(__name__)

# In-memory store — same pattern as the dict exercises earlier
todos = []


# 1. A decorator + a function + a dict — all Python fundamentals
@app.get("/health")
def health():
    return jsonify(status="ok")


# 2. A decorator + a function + list iteration
@app.get("/todos")
def list_todos():
    return jsonify(todos)


# 3. A decorator + a function + JSON body + try/except
@app.post("/todos")
def create_todo():
    data = request.get_json(silent=True)
    if not data or "title" not in data:
        return jsonify(error="title is required"), 400

    todo = {"id": len(todos) + 1, "title": data["title"]}
    todos.append(todo)
    return jsonify(todo), 201


if __name__ == "__main__":
    app.run(debug=True)


# Why this file makes sense now:
# - @app.get is a decorator — you learned decorators in Python.
# - Every view is a function returning a dict — you know this.
# - request.get_json is just Python dict handling.
# - try/except is Python error handling — same as your earlier scripts.
#
# If you skipped Python, this file would feel magical.
# With Python, this file is just code.