Flask Tutorial

Flask is a lightweight Python micro-framework. It gives you the core tools and lets you choose your own libraries — perfect when you want full control without the opinions of a full-stack framework.

Flask vs Django

Feature	Flask	Django
Size	Micro (minimal)	Full stack (batteries included)
ORM	Your choice (SQLAlchemy)	Built-in Django ORM
Admin	Flask-Admin (optional)	Auto-generated admin
Flexibility	Very high	Opinionated structure
Best for	Microservices, small APIs, custom apps	Large full-stack apps

Python – Flask Core Concepts

# Simulating Flask routing and request handling
from functools import wraps

class Flask:
    def __init__(self, name):
        self.name    = name
        self.routes  = {}
        self.filters = {}
        self.before_req = []

    def route(self, path, methods=None):
        def decorator(fn):
            m = tuple(methods or ["GET"])
            self.routes[(path, m)] = fn
            return fn
        return decorator

    def before_request(self, fn):
        self.before_req.append(fn); return fn

    def dispatch(self, path, method="GET", **kwargs):
        for _ in self.before_req: _()
        for (p, m), fn in self.routes.items():
            if p == path and method in m:
                return fn(**kwargs)
        return ("404 Not Found", 404)

app = Flask(__name__)

@app.before_request
def log_request():
    print("[LOG] Request received")

@app.route("/")
def index():
    return ("Welcome to Flask!", 200)

@app.route("/users", methods=["GET", "POST"])
def users():
    return ([{"id": 1, "name": "Alice"}], 200)

print(app.dispatch("/"))
print(app.dispatch("/users"))
print(app.dispatch("/missing"))

Try It – Flask Routing

Code Editor

class Flask:
    def __init__(self, name):
        self.routes     = {}
        self.before_req = []

def route(self, path, methods=None):
        def decorator(fn):
            for m in (methods or ["GET"]):
                self.routes[(path, m)] = fn
            return fn
        return decorator

def before_request(self, fn):
        self.before_req.append(fn)
        return fn

def dispatch(self, path, method="GET", **data):
        for fn in self.before_req:
            fn()
        fn = self.routes.get((path, method))
        if fn:
            return fn(**data)
        return ("404 Not Found", 404)

app = Flask("skillfort")

@app.before_request
def log():
    print("[LOG] Incoming request")

@app.route("/")
def home():
    return ("Hello, Flask!", 200)

@app.route("/greet")
def greet():
    return ("Hi there!", 200)

@app.route("/echo", methods=["POST"])
def echo(message=""):
    return (f"Echo: {message}", 200)

# Simulate requests
print(app.dispatch("/"))
print(app.dispatch("/greet"))
print(app.dispatch("/echo", "POST", message="Hello World"))
print(app.dispatch("/missing"))

Output

Click ▶ Run…

Quick Quiz

What is the name of Flask's built-in templating engine?

Flask Coding Labs

8 hands-on labs from basic routing to REST APIs and testing.

Lab 1 – REST API with JSON

Flask REST API Lab

Code Editor

import json
from datetime import datetime

# Simulate Flask REST API endpoints
users = [
    {"id": 1, "name": "Alice",  "email": "alice@example.com", "active": True},
    {"id": 2, "name": "Bob",    "email": "bob@example.com",   "active": True},
    {"id": 3, "name": "Carol",  "email": "carol@example.com", "active": False},
]
next_id = 4

def jsonify(data, status=200):
    return json.dumps(data, indent=2), status

# GET /api/users
def get_users(active_only=False):
    result = [u for u in users if not active_only or u["active"]]
    return jsonify(result)

# GET /api/users/<id>
def get_user(user_id):
    u = next((u for u in users if u["id"] == user_id), None)
    if not u: return jsonify({"error": "Not found"}, 404)
    return jsonify(u)

# POST /api/users
def create_user(name, email):
    global next_id
    if any(u["email"] == email for u in users):
        return jsonify({"error": "Email already exists"}, 400)
    user = {"id": next_id, "name": name, "email": email, "active": True}
    users.append(user); next_id += 1
    return jsonify(user, 201)

# DELETE /api/users/<id>
def delete_user(user_id):
    idx = next((i for i, u in enumerate(users) if u["id"] == user_id), None)
    if idx is None: return jsonify({"error": "Not found"}, 404)
    users.pop(idx)
    return jsonify({"message": "Deleted"})

# Run test requests
print("=== GET /api/users ===")
data, code = get_users(); print(f"Status: {code}\n{data}")

print("\n=== GET /api/users/1 ===")
data, code = get_user(1); print(f"Status: {code}\n{data}")

print("\n=== POST /api/users ===")
data, code = create_user("Dave", "dave@example.com")
print(f"Status: {code}\n{data}")

print("\n=== DELETE /api/users/3 ===")
data, code = delete_user(3); print(f"Status: {code}\n{data}")

print("\n=== GET /api/users (active only) ===")
data, code = get_users(active_only=True); print(f"Status: {code}\n{data}")

Output

Click ▶ Run…

Lab 2 – Blueprint Pattern

Flask Blueprints Lab

Code Editor

# Simulating Flask Blueprints (modular routing)
class Blueprint:
    def __init__(self, name, url_prefix=""):
        self.name       = name
        self.url_prefix = url_prefix
        self.routes     = {}

def route(self, path, methods=None):
        def decorator(fn):
            full_path = self.url_prefix + path
            for m in (methods or ["GET"]):
                self.routes[(full_path, m)] = fn
            return fn
        return decorator

class App:
    def __init__(self):
        self.routes = {}

def register_blueprint(self, bp):
        self.routes.update(bp.routes)
        print(f"[Blueprint] Registered: '{bp.name}' with {len(bp.routes)} routes")

def dispatch(self, path, method="GET", **data):
        fn = self.routes.get((path, method))
        return fn(**data) if fn else ("404 Not Found", 404)

# --- auth blueprint ---
auth_bp = Blueprint("auth", url_prefix="/auth")

@auth_bp.route("/login", methods=["POST"])
def login(username="", password=""):
    if username == "admin" and password == "secret":
        return ({"token": "jwt-token-here", "user": username}, 200)
    return ({"error": "Invalid credentials"}, 401)

@auth_bp.route("/logout", methods=["POST"])
def logout():
    return ({"message": "Logged out"}, 200)

# --- posts blueprint ---
posts_bp = Blueprint("posts", url_prefix="/posts")

@posts_bp.route("/")
def list_posts():
    return ([{"id": 1, "title": "Intro to Flask"},
             {"id": 2, "title": "Flask Blueprints"}], 200)

@posts_bp.route("/<int:post_id>")
def get_post(post_id=1):
    return ({"id": post_id, "title": f"Post {post_id}"}, 200)

# Register blueprints
app = App()
app.register_blueprint(auth_bp)
app.register_blueprint(posts_bp)

print("\n--- Dispatch Requests ---")
print("POST /auth/login:", app.dispatch("/auth/login", "POST", username="admin", password="secret"))
print("POST /auth/login:", app.dispatch("/auth/login", "POST", username="bad", password="wrong"))
print("GET  /posts/:",     app.dispatch("/posts/"))
print("GET  /posts/1:",    app.dispatch("/posts/1", post_id=1))

Output

Click ▶ Run…

←

FastAPI Tutorial

Back to

All Courses

→