Flask Cheat Sheet: A Comprehensive Quick-Reference Guide

Flask is a lightweight WSGI micro-framework for Python, designed to make getting started quick and easy, with the ability to scale up to complex applications. It was created by Armin Ronacher and is classified as a micro-framework because it does not require particular tools or libraries — it has no database abstraction layer, form validation, or any other pre-existing third-party library that provides common functions .

Flask's core philosophy is built on two pillars: the Werkzeug WSGI toolkit and the Jinja2 templating engine. Together, they give you URL routing, request/response handling, a development server, and powerful template rendering — all without the overhead of a full-stack framework.

The framework follows the MVC pattern loosely, giving you the flexibility to structure your app as you see fit. Flask's minimalist approach means you only add what you need — Flask-SQLAlchemy for databases, Flask-WTF for forms, Flask-Login for authentication, and so on.

Footnotes

1. Flask Official Documentation — The primary reference for Flask's API, patterns, and best practices including routing, contexts, and deployment guidelines. ↩

Application Setup & Configuration

Every Flask application begins by creating an application instance:

1from flask import Flask
2
3app = Flask(__name__)
4
5@app.route('/')
6def home():
7    return 'Hello, World!'
8
9if __name__ == '__main__':
10    app.run(debug=True, port=5000)

The __name__ argument tells Flask where to look for templates, static files, and other resources. When debug=True, Flask enables the interactive debugger and auto-reloads on code changes — never use this in production .

Key built-in configuration variables:

Footnotes

1. Flask Official Documentation — The primary reference for Flask's API, patterns, and best practices including routing, contexts, and deployment guidelines. ↩

Routing & URL Dispatching

Routing maps URLs to Python functions. Flask uses the route decorator to connect URL patterns to handler functions.

1# Basic routes
2@app.route('/')
3def index():
4    return 'Index Page'
5
6@app.route('/hello')
7def hello():
8    return 'Hello, World'
9
10# Dynamic routes with variable rules
11@app.route('/user/<username>')
12def show_user(username):
13    return f'User: {username}'
14
15@app.route('/post/<int:post_id>')
16def show_post(post_id):
17    return f'Post ID: {post_id}'
18
19@app.route('/path/<path:subpath>')
20def show_subpath(subpath):
21    return f'Subpath: {subpath}'

Variable converters:

HTTP method binding:

1@app.route('/api/data', methods=['GET', 'POST'])
2def handle_data():
3    if request.method == 'POST':
4        return 'Created', 201
5    return 'Data list', 200

url_for() — the proper way to build URLs:

1from flask import url_for
2
3url_for('show_user', username='alice')   # /user/alice
4url_for('static', filename='style.css')    # /static/style.css

The Request Object

Flask's request context provides access to all incoming request data through the global request object:

1from flask import request
2
3# Request method & URL
4request.method              # 'GET', 'POST', etc.
5request.url                 # Full URL
6request.path                # '/api/users'
7request.base_url            # URL without query string
8request.args                # ImmutableMultiDict of query params
9
10# Form & JSON data
11request.form                # Form data (POST)
12request.json                # Parsed JSON body
13request.data                # Raw body bytes
14
15# Headers & cookies
16request.headers             # Dict-like headers
17request.cookies             # Dict of cookies
18
19# Files
20request.files               # MultiDict of uploaded files
21file = request.files['upload']
22file.save(f'/uploads/{file.filename}')

Templates with Jinja2

Flask uses Jinja2 for rendering HTML. Templates should be stored in a templates/ directory.

1from flask import render_template
2
3@app.route('/profile/<username>')
4def profile(username):
5    return render_template('profile.html', name=username, age=25)

Template syntax cheat sheet:

1<!-- Variable interpolation -->
2<h1>Hello, {{ name }}!</h1>
3
4<!-- Filters -->
5<p>{{ name|capitalize }}</p>
6<p>{{ price|round(2) }}</p>
7<p>{{ content|truncate(100) }}</p>
8<p>{{ html_content|safe }}</p>
9<p>{{ items|length }}</p>
10
11<!-- Conditionals -->
12{% if user.is_authenticated %}
13  <p>Welcome back, {{ user.name }}</p>
14{% elif user.is_guest %}
15  <p>Browse as guest</p>
16{% else %}
17  <p>Please log in</p>
18{% endif %}
19
20<!-- Loops -->
21{% for item in items %}
22  <li>{{ loop.index }}: {{ item }}</li>
23{% endfor %}
24
25<!-- Macro (reusable template function) -->
26{% macro render_button(text, type='primary') %}
27  <button class="btn btn-{{ type }}">{{ text }}</button>
28{% endmacro %}
29
30{{ render_button('Submit') }}
31{{ render_button('Delete', 'danger') }}

Template inheritance:

1<!-- base.html -->
2<!DOCTYPE html>
3<html>
4<head>
5  <title>{% block title %}Default Title{% endblock %}</title>
6  {% block head %}{% endblock %}
7</head>
8<body>
9  {% block content %}{% endblock %}
10  {% block scripts %}{% endblock %}
11</body>
12</html>
13
14<!-- child.html -->
15{% extends "base.html" %}
16{% block title %}Child Page{% endblock %}
17{% block content %}
18  <h1>Child Content Here</h1>
19{% endblock %}

Databases with Flask-SQLAlchemy

Flask-SQLAlchemy is the most popular database extension. It provides an ORM layer and simplifies database configuration.

1from flask_sqlalchemy import SQLAlchemy
2from flask_migrate import Migrate
3
4app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db'
5app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
6
7db = SQLAlchemy(app)
8migrate = Migrate(app, db)
9
10# Model definition
11class User(db.Model):
12    __tablename__ = 'users'
13
14    id = db.Column(db.Integer, primary_key=True)
15    username = db.Column(db.String(80), unique=True, nullable=False)
16    email = db.Column(db.String(120), unique=True, nullable=False)
17    created_at = db.Column(db.DateTime, server_default=db.func.now())
18
19    # Relationship
20    posts = db.relationship('Post', backref='author', lazy=True)
21
22    def __repr__(self):
23        return f'<User {self.username}>'
24
25class Post(db.Model):
26    id = db.Column(db.Integer, primary_key=True)
27    title = db.Column(db.String(200), nullable=False)
28    content = db.Column(db.Text)
29    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)

Common SQLAlchemy column types & queries:

1# Column types available
2db.String(80)    db.Text          db.Integer
3db.Float         db.Boolean       db.DateTime
4db.Date          db.LargeBinary   db.Numeric
5db.Enum           db.JSON          db.ARRAY
6
7# Query operations
8User.query.all()                              # All records
9User.query.filter_by(username='alice').first() # Filter by exact
10User.query.filter(User.email.endswith('@org.com')).all()  # SQL-like
11User.query.order_by(User.created_at.desc()).limit(10).all()
12User.query.paginate(page=1, per_page=20)     # Pagination
13
14# CRUD Operations
15user = User(username='bob', email='bob@org.com')
16db.session.add(user)
17db.session.commit()
18
19user.username = 'bob_updated'
20db.session.commit()
21
22db.session.delete(user)
23db.session.commit()

Blueprints — Modular Application Architecture

Blueprints let you organize your application into distinct, reusable components — essential for anything beyond a single-file app.

1# auth/routes.py
2from flask import Blueprint, render_template
3
4auth_bp = Blueprint('auth', __name__,
5                     template_folder='templates',
6                     static_folder='static',
7                     url_prefix='/auth')
8
9@auth_bp.route('/login')
10def login():
11    return render_template('auth/login.html')
12
13@auth_bp.route('/register')
14def register():
15    return render_template('auth/register.html')

1# app.py — Register the blueprint
2from auth.routes import auth_bp
3
4app.register_blueprint(auth_bp)
5# Routes now available at /auth/login, /auth/register
6
7# Register with additional prefix
8app.register_blueprint(auth_bp, url_prefix='/v2/auth')

Recommended project structure:

myapp/
├── app/
│   ├── __init__.py          # create_app() factory
│   ├── models.py
│   ├── auth/
│   │   ├── __init__.py
│   │   ├── routes.py        # auth_bp blueprint
│   │   ├── forms.py
│   │   └── templates/auth/
│   ├── api/
│   │   ├── __init__.py
│   │   ├── routes.py        # api_bp blueprint
│   │   └── schemas.py
│   ├── main/
│   │   ├── __init__.py
│   │   ├── routes.py        # main_bp blueprint
│   │   └── templates/main/
│   ├── static/
│   └── templates/
│       └── base.html
├── migrations/
├── config.py
├── requirements.txt
└── run.py

Flask Authentication Flow