Flask Grundlagen

6 Kernkonzepte

Die wichtigsten Flask-Konzepte für Webentwicklung mit Python: Routen · Templates · Requests · Sessions · Blueprints · Konfiguration Flask ist ein leichtgewichtiges Python-Webframework, das sich durch Einfachheit und Flexibilität auszeichnet. Diese Cheatsheet fasst die grundlegenden Konzepte und Best Practices zusammen.

Routen & Views – URLs mit Funktionen verbinden

@app.route() · variable rules · methods

@app.route('/') def index(): return 'Hallo Welt!'

Routen verbinden URLs mit Python-Funktionen (Views). Mit @app.route() werden Dekorateure verwendet, um die Zuordnung zu definieren.

Beispiele

from flask import Flask

app = Flask(__name__)

# Einfache Route

@app.route('/')

def home():

return 'Startseite'

# Variable Rules (dynamische URLs)

@app.route('/user/<name>')

def user(name):

return f'Benutzer: {name}'

# Variable mit Typ (int, float, path)

@app.route('/post/<int:post_id>')

def show_post(post_id):

return f'Beitrag {post_id}'

# HTTP-Methoden (GET, POST, etc.)

@app.route('/login', methods=['GET', 'POST'])

def login():

if request.method == 'POST':

return 'Login verarbeitet'

return 'Login-Formular'

Tipp: Verwenden Sie url_for('function_name', param=value), um URLs dynamisch zu generieren – das macht Ihre App wartbarer bei Routen-Änderungen.

Templates – HTML mit Jinja2

render_template · {{ }} · {% %}

from flask import render_template @app.route('/') def index(): return render_template('index.html', name='Anna')

Templates werden mit Jinja2 gerendert. Sie ermöglichen die Trennung von Logik und Präsentation. {{ }} für Variablen, {% %} für Kontrollstrukturen.

Beispiele

<!DOCTYPE html>

<html>

<body>

<h1>Hallo {{ name }}!</h1>

{% if user %}

<p>Eingeloggt als {{ user.name }}</p>

{% else %}

<p>Bitte einloggen</p>

{% endif %}

<ul>

{% for item in items %}

{% endfor %}

</ul>

</body>

</html>

# Template mit Vererbung (base.html)

<html>

<head>

{% block head %}<title>Meine App</title>{% endblock %}

</head>

<body>

{% block content %}{% endblock %}

</body>

</html>

Tipp: Nutzen Sie Template-Vererbung mit {% block %}, um redundanten Code zu vermeiden. render_template() sucht automatisch im templates/-Ordner.

Request-Objekt – Daten aus Anfragen

request.args · request.form · request.json · request.files

from flask import request name = request.args.get('name', 'Gast') email = request.form['email']

Request ist ein globales Objekt, das alle Daten der eingehenden HTTP-Anfrage enthält – Query-Parameter, Formulardaten, JSON, Dateien und Header.

Beispiele

# Query-Parameter (GET)

@app.route('/search')

def search():

q = request.args.get('q', '')

return f'Suche nach: {q}'

# Formulardaten (POST)

@app.route('/register', methods=['POST'])

def register():

username = request.form['username']

password = request.form.get('password')

return f'Registriert: {username}'

# JSON-Daten (API)

@app.route('/api/data', methods=['POST'])

def api_data():

data = request.get_json()

return {'received': data}

# Datei-Upload

@app.route('/upload', methods=['POST'])

def upload_file():

file = request.files['file']

file.save(f'uploads/{file.filename}')

return 'Datei hochgeladen'

# Zugriff auf Header

user_agent = request.headers.get('User-Agent')

Tipp: Verwenden Sie request.get_json(silent=True), um JSON zu parsen ohne Fehler bei ungültigen Daten – nützlich für robuste APIs.

Sessions & Cookies – Benutzerdaten speichern

session · secure · cookie

from flask import session app.config['SECRET_KEY'] = 'dein-geheimer-schlüssel' session['user_id'] = user.id

Sessions speichern Daten über mehrere Anfragen hinweg. Sie werden als signierte Cookies gespeichert und benötigen einen SECRET_KEY.

Beispiele

from flask import Flask, session, redirect, url_for

app.config['SECRET_KEY'] = 'supersecretkey123'

# Login – Session setzen

@app.route('/login', methods=['POST'])

def login():

user_id = request.form['user_id']

session['user_id'] = user_id

return redirect(url_for('dashboard'))

# Dashboard – Session auslesen

@app.route('/dashboard')

def dashboard():

user_id = session.get('user_id')

if user_id is None:

return redirect(url_for('login'))

return f'Willkommen, Benutzer {user_id}!'

# Logout – Session löschen

@app.route('/logout')

def logout():

session.pop('user_id', None)

return redirect(url_for('home'))

# Session-Daten als Cookie setzen (permanent)

session.permanent = True

app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=7)

Tipp: Setzen Sie session.permanent = True und konfigurieren Sie PERMANENT_SESSION_LIFETIME für langlebige Sessions. Der SECRET_KEY muss sicher und geheim sein!

Blueprints – Modulare App-Struktur

Blueprint · register_blueprint

# auth.py (Blueprint) from flask import Blueprint bp = Blueprint('auth', __name__) @bp.route('/login') def login(): return 'Login'

Blueprints ermöglichen die modulare Organisation von Flask-Anwendungen. Sie definieren Routen und View-Funktionen in separaten Dateien, die später in der Haupt-App registriert werden.

Beispiele

# auth.py

from flask import Blueprint, render_template

auth_bp = Blueprint('auth', __name__, url_prefix='/auth')

@auth_bp.route('/login')

def login():

return render_template('auth/login.html')

@auth_bp.route('/logout')

def logout():

# Logout-Logik

return 'Logout'

# blog.py

from flask import Blueprint

blog_bp = Blueprint('blog', __name__, url_prefix='/blog')

@blog_bp.route('/')

def index():

return 'Blog-Übersicht'

# app.py (Hauptdatei)

from flask import Flask

from auth import auth_bp

from blog import blog_bp

app = Flask(__name__)

app.register_blueprint(auth_bp)

app.register_blueprint(blog_bp)

# Blueprint mit Template-Ordner

admin_bp = Blueprint('admin', __name__, template_folder='admin_templates')

Tipp: Nutzen Sie url_prefix, um allen Routen eines Blueprints ein gemeinsames Präfix zu geben. So bleiben Ihre URLs sauber und organisiert.

Konfiguration – app.config & Umgebungsvariablen

app.config · from_object · from_envvar

app.config['DEBUG'] = True app.config.from_object('config.Config') app.config.from_envvar('APP_SETTINGS')

Konfiguration steuert das Verhalten Ihrer Flask-Anwendung. Über app.config können Sie Werte setzen, aus Dateien oder Umgebungsvariablen laden.

Beispiele

# Direkte Konfiguration

app.config['DEBUG'] = True

app.config['SECRET_KEY'] = 'dev-key-123'

app.config['DATABASE_URI'] = 'sqlite:///app.db'

# Konfiguration aus Klasse (config.py)

# config.py

class Config:

DEBUG = False

TESTING = False

SECRET_KEY = 'production-key'

class DevelopmentConfig(Config):

DEBUG = True

DATABASE_URI = 'sqlite:///dev.db'

# In app.py

app.config.from_object('config.DevelopmentConfig')

# Konfiguration aus JSON-Datei

app.config.from_json('config.json')

# Konfiguration aus Umgebungsvariable

import os

app.config.from_envvar('FLASK_SETTINGS', silent=True)

# Konfigurationswert auslesen

debug_mode = app.config.get('DEBUG', False)

Tipp: Nutzen Sie Umgebungsvariablen für sensible Daten wie Secret Keys oder API-Keys. Flask bietet mit from_envvar() eine einfache Möglichkeit, diese zu laden.

Flask im Überblick

@app.route Routen-Dekorator
URLs definieren

render_template Templates rendern
Jinja2-Templates

request Anfragedaten
Form, Query, JSON

session Benutzersitzung
Gesicherte Cookies

Blueprint Modulare Struktur
Wiederverwendbare Komponenten

app.config Konfiguration
Umgebungsvariablen

Quick Summary

@app.route

Routen

render_template

Templates

request

Anfragedaten

session

Sessions

Blueprint

Module

app.config

Konfiguration

@app.route('/') · render_template('index.html', name=name) · request.form['email']