Kurs Python · Moduł 5: Flask i aplikacje webowe

Routing i view functions - zaawansowane techniki

11 min czytania ·
W tej lekcji12

Witaj ponownie! Darwin tutaj, gotowy pokazać Ci zaawansowane techniki routingu w Flask!

W poprzedniej lekcji stworzyłeś/aś prostą aplikację Flask z podstawowymi routes. Teraz nauczysz się profesjonalnych technik używanych w produkcyjnych aplikacjach!

Analogia Safari: Routing to jak sieć szlaków safari - musisz umieć przekierowywać turystów (użytkowników), obsługiwać różne trasy, reagować na błędy (zgubienie się), i budować mapy (URL building)!

Przypomnienie - podstawy routingu

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Strona główna"

@app.route('/species/<int:species_id>')
def show_species(species_id):
    return f"Gatunek ID: {species_id}"

Route = dekorator @app.route() mapujący URL → funkcję widoku.

Teraz nauczysz się zaawansowanych technik!

Wiele routes dla jednej funkcji

Możesz przypisać wiele URL do tej samej funkcji:

@app.route('/')
@app.route('/home')
@app.route('/index')
def home():
    return "<h1>Strona główna Safari Database</h1>"

Użytkownik może wejść:

  • / → wykonuje się home()
  • /home → wykonuje się home()
  • /index → wykonuje się home()

Po co? Wiele możliwych wejść do tej samej zawartości - wygodniejsze dla użytkowników!

Analogia: To jak wiele wejść do tego samego siedliska - turyści mogą wejść od północy, południa lub wschodu, ale wszyscy widzą te same lwy!

Trailing slash - różnica między / a bez /

Flask rozróżnia URL z / na końcu i bez:

# Z trailing slash (domyślne)
@app.route('/species/')
def list_species():
    return "Lista gatunków"

# Bez trailing slash
@app.route('/about')
def about():
    return "O systemie"

Jak to działa?

Z trailing slash (/species/):

  • /species/ → działa
  • /species → przekierowanie 301 do /species/

Bez trailing slash (/about):

  • /about → działa
  • /about/ → 404 Not Found

Najlepsza praktyka: Używaj z trailing slash dla "folderów" (collections), bez slash dla "plików" (pojedynczych zasobów):

@app.route('/species/')          # Lista (folder)
@app.route('/species/<int:id>')  # Pojedynczy (plik)

HTTP Methods - szczegóły

Flask pozwala na obsługę różnych metod HTTP w tym samym route:

from flask import request

@app.route('/species', methods=['GET', 'POST', 'PUT', 'DELETE'])
def species_handler():
    if request.method == 'GET':
        return "Pobierz listę gatunków"

    elif request.method == 'POST':
        return "Utwórz nowy gatunek"

    elif request.method == 'PUT':
        return "Aktualizuj gatunek"

    elif request.method == 'DELETE':
        return "Usuń gatunek"

Lepszy sposób - osobne funkcje:

@app.route('/species', methods=['GET'])
def list_species():
    return "Lista gatunków"

@app.route('/species', methods=['POST'])
def create_species():
    return "Utworzono gatunek"

Lub jeszcze lepiej - użyj dekoratorów skrótowych:

@app.get('/species')
def list_species():
    return "Lista gatunków (GET)"

@app.post('/species')
def create_species():
    return "Utworzono gatunek (POST)"

@app.put('/species/<int:id>')
def update_species(id):
    return f"Zaktualizowano gatunek {id} (PUT)"

@app.delete('/species/<int:id>')
def delete_species(id):
    return f"Usunięto gatunek {id} (DELETE)"

Analogia: Różne metody HTTP to jak różne czynności w safari - GET to obserwacja (bezpieczne), POST to dodanie nowego gatunku do bazy (zmiana stanu), DELETE to usunięcie wpisu!

Request object - dostęp do danych

Obiekt request zawiera wszystkie informacje o żądaniu HTTP:

from flask import request

@app.route('/search')
def search():
    # Query parameters (?name=lion&habitat=savanna)
    species_name = request.args.get('name')
    habitat = request.args.get('habitat')
    page = request.args.get('page', 1, type=int)  # Domyślnie 1

    return f"""
    <h1>Wyszukiwanie</h1>
    <p>Gatunek: {species_name}</p>
    <p>Siedlisko: {habitat}</p>
    <p>Strona: {page}</p>
    """

@app.route('/add-species', methods=['POST'])
def add_species():
    # Form data (z formularza HTML)
    name = request.form.get('name')
    population = request.form.get('population', type=int)

    return f"Dodano: {name} (populacja: {population})"

@app.route('/api/species', methods=['POST'])
def api_create_species():
    # JSON data (z fetch/API)
    data = request.get_json()
    name = data.get('name')
    population = data.get('population')

    return {"message": f"Utworzono {name}", "id": 123}

@app.route('/info')
def request_info():
    return f"""
    <h1>Informacje o żądaniu</h1>
    <p><strong>URL:</strong> {request.url}</p>
    <p><strong>Metoda:</strong> {request.method}</p>
    <p><strong>Path:</strong> {request.path}</p>
    <p><strong>User-Agent:</strong> {request.user_agent}</p>
    <p><strong>IP:</strong> {request.remote_addr}</p>
    <p><strong>Cookies:</strong> {request.cookies}</p>
    <p><strong>Headers:</strong> {dict(request.headers)}</p>
    """

Przydatne atrybuty request:

  • request.args - query parameters (?key=value)
  • request.form - dane z formularza (POST)
  • request.get_json() - JSON data
  • request.files - przesłane pliki
  • request.cookies - ciasteczka
  • request.headers - nagłówki HTTP
  • request.method - metoda HTTP (GET, POST, etc.)
  • request.url - pełny URL
  • request.path - ścieżka URL
  • request.remote_addr - IP klienta

Przykład - wyszukiwarka Safari:

@app.route('/search')
def search():
    query = request.args.get('q', '')
    filter_type = request.args.get('type', 'all')
    sort = request.args.get('sort', 'name')

    # Symulacja wyszukiwania
    results = [
        {"name": "Lew", "type": "mammal"},
        {"name": "Gepard", "type": "mammal"},
    ]

    # Filtruj według typu
    if filter_type != 'all':
        results = [r for r in results if r['type'] == filter_type]

    html = f"<h1>Wyniki dla: {query}</h1>"
    html += f"<p>Typ: {filter_type}, Sortowanie: {sort}</p>"

    for result in results:
        html += f"<p>{result['name']} ({result['type']})</p>"

    return html

Test:

  • /search?q=lew
  • /search?q=lew&type=mammal&sort=population

Response object - zwracanie odpowiedzi

Flask automatycznie konwertuje zwracane wartości na obiekty Response:

from flask import make_response, jsonify

# Prosty string (status 200)
@app.route('/hello')
def hello():
    return "Hello Safari!"

# String + status code
@app.route('/created')
def created():
    return "Gatunek utworzony!", 201

# String + status + headers
@app.route('/custom')
def custom():
    return "Custom response", 200, {'X-Custom-Header': 'Safari'}

# JSON response
@app.route('/api/species/<int:id>')
def api_species(id):
    species = {"id": id, "name": "Lew", "population": 120}
    return jsonify(species)

# make_response() - bardziej kontroli
@app.route('/cookie')
def set_cookie():
    response = make_response("Cookie ustawiony!")
    response.set_cookie('user_id', '123', max_age=3600)
    return response

Format zwracania:

  • return "text" → 200 OK
  • return "text", 201 → 201 Created
  • return "text", 404 → 404 Not Found
  • return jsonify(data) → JSON response
  • return make_response(...) → custom Response

Redirects - przekierowania

Użyj redirect() do przekierowania użytkownika na inny URL:

from flask import redirect, url_for

@app.route('/old-species')
def old_species():
    # Przekieruj na nowy URL
    return redirect('/species')

@app.route('/species/<int:id>')
def show_species(id):
    # Jeśli gatunek nie istnieje, przekieruj do listy
    species = get_species_by_id(id)

    if species is None:
        return redirect('/species')

    return f"<h1>{species['name']}</h1>"

@app.route('/login', methods=['POST'])
def login():
    username = request.form.get('username')
    password = request.form.get('password')

    if authenticate(username, password):
        # Sukces - przekieruj do dashboardu
        return redirect('/dashboard')
    else:
        # Błąd - przekieruj z powrotem do logowania
        return redirect('/login?error=invalid')

Analogia: Redirect to jak zmiana trasy safari - jeśli szlak jest zamknięty (gatunek nie istnieje), przewodnik przekierowuje grupę na inną trasę (listę gatunków)!

url_for() - budowanie URL

url_for() buduje URL na podstawie nazwy funkcji zamiast hardcoded URL:

from flask import url_for

@app.route('/')
def home():
    # Zamiast hardcoded '/species'
    species_url = url_for('list_species')

    # Zamiast hardcoded '/species/1'
    lion_url = url_for('show_species', species_id=1)

    return f"""
    <h1>Safari Database</h1>
    <a href="{species_url}">Lista gatunków</a> |
    <a href="{lion_url}">Zobacz lwa</a>
    """

@app.route('/species')
def list_species():
    return "<h1>Lista gatunków</h1>"

@app.route('/species/<int:species_id>')
def show_species(species_id):
    return f"<h1>Gatunek ID: {species_id}</h1>"

Po co url_for()? Centralny routing - zmiana URL w jednym miejscu Bezpieczniejsze - Flask automatycznie escape'uje parametry Czytelniejsze - używasz nazw funkcji zamiast URL

Przykład z query parameters:

@app.route('/search')
def search():
    return "Wyniki wyszukiwania"

# Buduj URL z query params
url = url_for('search', q='lew', type='mammal')
# Wynik: /search?q=lew&type=mammal

Przekierowanie z url_for():

@app.route('/old-url')
def old_url():
    return redirect(url_for('list_species'))

Error Handlers - obsługa błędów

Stwórz custom error pages dla 404, 500, etc.:

# 404 - Not Found
@app.errorhandler(404)
def page_not_found(error):
    return """
    <!DOCTYPE html>
    <html>
    <head>
        <title>404 - Safari Database</title>
        <style>
            body {
                font-family: Arial, sans-serif;
                text-align: center;
                padding: 100px;
                background-color: #f4f1de;
            }
            h1 { color: #d62828; font-size: 72px; }
        </style>
    </head>
    <body>
        <h1>404</h1>
        <h2>Gatunek nie znaleziony!</h2>
        <p>Szukany zasób nie istnieje w bazie Safari Database.</p>
        <a href="/">← Powrót do strony głównej</a>
    </body>
    </html>
    """, 404

# 500 - Internal Server Error
@app.errorhandler(500)
def internal_error(error):
    return """
    <h1>500 - Błąd serwera</h1>
    <p>Coś poszło nie tak. Nasze lwy pracują nad naprawą!</p>
    <a href="/">← Powrót do strony głównej</a>
    """, 500

# Custom exception
class SpeciesNotFoundError(Exception):
    pass

@app.errorhandler(SpeciesNotFoundError)
def handle_species_not_found(error):
    return f"<h1>Gatunek nie znaleziony</h1><p>{error}</p>", 404

@app.route('/species/<int:id>')
def show_species(id):
    species = get_species_by_id(id)

    if species is None:
        raise SpeciesNotFoundError(f"Gatunek o ID {id} nie istnieje")

    return f"<h1>{species['name']}</h1>"

Analogia: Error handlers to jak procedury awaryjne w safari - gdy turysta zgubi się (404) lub wystąpi awaria pojazdu (500), przewodnik wie, jak zareagować!

Before/After Request Hooks

Flask pozwala wykonywać kod przed i po każdym żądaniu:

import time

# Przed każdym żądaniem
@app.before_request
def before_request():
    # Zapisz czas rozpoczęcia
    request.start_time = time.time()

    # Loguj żądanie
    print(f"{request.method} {request.path}")

# Po każdym żądaniu
@app.after_request
def after_request(response):
    # Oblicz czas wykonania
    if hasattr(request, 'start_time'):
        duration = time.time() - request.start_time
        print(f"Czas wykonania: {duration:.3f}s")

    # Dodaj custom header
    response.headers['X-Safari-Database'] = 'v1.0'

    return response

# Po każdym żądaniu (nawet gdy wystąpi błąd)
@app.teardown_request
def teardown_request(exception=None):
    if exception:
        print(f"Wystąpił błąd: {exception}")

    # Zamknij połączenie z bazą danych
    # db.close()

Przypadki użycia:

  • Autentykacja (sprawdź, czy użytkownik zalogowany)
  • Logowanie requestów
  • ⏱Mierzenie czasu wykonania
  • Połączenie/zamknięcie bazy danych
  • Nagłówki bezpieczeństwa

Analogia: Hooki to jak procedury przed/po safari - przed: sprawdź sprzęt, zlicz turystów; po: zapisz obserwacje, sprawdź, czy wszyscy wrócili!

Praktyczny przykład - Safari Database v2

Stworzymy ulepszoną wersję Safari Database używając wszystkich poznanych technik!

# app.py
from flask import Flask, request, redirect, url_for, make_response, jsonify
import time

app = Flask(__name__)

# Dane testowe
species_db = {
    1: {"id": 1, "name": "Lew", "scientific_name": "Panthera leo", "population": 120},
    2: {"id": 2, "name": "Słoń", "scientific_name": "Loxodonta africana", "population": 450},
    3: {"id": 3, "name": "Gepard", "scientific_name": "Acinonyx jubatus", "population": 7100},
}
next_id = 4

# --- Hooks ---
@app.before_request
def log_request():
    request.start_time = time.time()
    print(f"[{request.method}] {request.path}")

@app.after_request
def log_response(response):
    if hasattr(request, 'start_time'):
        duration = time.time() - request.start_time
        print(f"Status: {response.status_code} | Czas: {duration:.3f}s")
    return response

# --- Routes ---
@app.route('/')
@app.route('/home')
def home():
    return f"""
    <!DOCTYPE html>
    <html>
    <head>
        <title>Safari Database</title>
        <style>
            body {{ font-family: Arial; max-width: 800px; margin: 50px auto; background: #f4f1de; }}
            h1 {{ color: #2c5f2d; }}
            nav {{ margin: 20px 0; }}
            nav a {{ margin-right: 15px; color: #2c5f2d; text-decoration: none; font-weight: bold; }}
            nav a:hover {{ text-decoration: underline; }}
        </style>
    </head>
    <body>
        <h1>Safari Database</h1>
        <nav>
            <a href="{url_for('home')}">Home</a>
            <a href="{url_for('list_species')}">Lista gatunków</a>
            <a href="{url_for('add_species_form')}">Dodaj gatunek</a>
            <a href="{url_for('search')}">Szukaj</a>
        </nav>
        <h2>Witaj w Safari Database!</h2>
        <p>Baza zawiera <strong>{len(species_db)} gatunków</strong>.</p>
        <p><a href="{url_for('list_species')}">Zobacz wszystkie →</a></p>
    </body>
    </html>
    """

@app.get('/species')
def list_species():
    species_html = ""
    for spec in species_db.values():
        species_html += f"""
        <div style="background: white; padding: 15px; margin: 10px 0; border-radius: 8px;">
            <h3>{spec['name']}</h3>
            <p><strong>Populacja:</strong> {spec['population']}</p>
            <a href="{url_for('show_species', species_id=spec['id'])}">Szczegóły</a> |
            <a href="{url_for('delete_species', species_id=spec['id'])}" style="color: red;">Usuń</a>
        </div>
        """

    return f"""
    <!DOCTYPE html>
    <html>
    <head><title>Lista gatunków</title></head>
    <body style="font-family: Arial; max-width: 800px; margin: 50px auto; background: #f4f1de;">
        <h1>Lista gatunków ({len(species_db)})</h1>
        {species_html}
        <p><a href="{url_for('home')}">← Powrót</a></p>
    </body>
    </html>
    """

@app.route('/species/<int:species_id>')
def show_species(species_id):
    spec = species_db.get(species_id)

    if spec is None:
        # Użyj custom error handler
        return f"<h1>404</h1><p>Gatunek {species_id} nie istnieje</p>", 404

    return f"""
    <!DOCTYPE html>
    <html>
    <head><title>{spec['name']}</title></head>
    <body style="font-family: Arial; max-width: 800px; margin: 50px auto; background: #f4f1de;">
        <h1>{spec['name']}</h1>
        <div style="background: white; padding: 30px; border-radius: 12px;">
            <p><strong>Nazwa naukowa:</strong> {spec['scientific_name']}</p>
            <p><strong>Populacja:</strong> {spec['population']} osobników</p>
            <p><strong>ID:</strong> {spec['id']}</p>
        </div>
        <p style="margin-top: 20px;">
            <a href="{url_for('list_species')}">← Lista</a> |
            <a href="{url_for('home')}">← Home</a>
        </p>
    </body>
    </html>
    """

@app.route('/species/add', methods=['GET'])
def add_species_form():
    return f"""
    <!DOCTYPE html>
    <html>
    <head><title>Dodaj gatunek</title></head>
    <body style="font-family: Arial; max-width: 800px; margin: 50px auto; background: #f4f1de;">
        <h1>Dodaj nowy gatunek</h1>
        <form method="POST" action="{url_for('add_species')}" style="background: white; padding: 30px; border-radius: 12px;">
            <p><label>Nazwa: <input type="text" name="name" required></label></p>
            <p><label>Nazwa naukowa: <input type="text" name="scientific_name" required></label></p>
            <p><label>Populacja: <input type="number" name="population" required></label></p>
            <button type="submit" style="padding: 10px 20px; background: #2c5f2d; color: white; border: none; border-radius: 4px;">Dodaj</button>
        </form>
        <p><a href="{url_for('home')}">← Powrót</a></p>
    </body>
    </html>
    """

@app.post('/species/add')
def add_species():
    global next_id

    name = request.form.get('name')
    scientific_name = request.form.get('scientific_name')
    population = request.form.get('population', type=int)

    # Dodaj do bazy
    new_species = {
        "id": next_id,
        "name": name,
        "scientific_name": scientific_name,
        "population": population
    }
    species_db[next_id] = new_species
    next_id += 1

    # Przekieruj do szczegółów nowego gatunku
    return redirect(url_for('show_species', species_id=new_species['id']))

@app.route('/species/<int:species_id>/delete')
def delete_species(species_id):
    if species_id in species_db:
        del species_db[species_id]

    # Przekieruj do listy
    return redirect(url_for('list_species'))

@app.route('/search')
def search():
    query = request.args.get('q', '').lower()

    if not query:
        return f"""
        <h1>Wyszukiwarka</h1>
        <form method="GET">
            <input type="text" name="q" placeholder="Wpisz nazwę gatunku">
            <button type="submit">Szukaj</button>
        </form>
        <a href="{url_for('home')}">← Powrót</a>
        """

    # Wyszukaj
    results = [s for s in species_db.values() if query in s['name'].lower()]

    results_html = f"<h2>Znaleziono: {len(results)}</h2>"
    for spec in results:
        results_html += f"<p><a href='{url_for('show_species', species_id=spec['id'])}'>{spec['name']}</a></p>"

    return f"""
    <h1>Wyniki dla: "{query}"</h1>
    {results_html}
    <p><a href="{url_for('search')}">← Nowe wyszukiwanie</a></p>
    """

# --- API Endpoints ---
@app.get('/api/species')
def api_list_species():
    return jsonify(list(species_db.values()))

@app.get('/api/species/<int:species_id>')
def api_get_species(species_id):
    spec = species_db.get(species_id)
    if spec is None:
        return jsonify({"error": "Not found"}), 404
    return jsonify(spec)

# --- Error Handlers ---
@app.errorhandler(404)
def page_not_found(error):
    return f"""
    <div style="text-align: center; padding: 100px; background: #f4f1de;">
        <h1 style="font-size: 72px; color: #d62828;">404</h1>
        <h2>Nie znaleziono!</h2>
        <p><a href="{url_for('home')}">← Powrót do strony głównej</a></p>
    </div>
    """, 404

if __name__ == '__main__':
    print("Safari Database v2 startuje...")
    app.run(debug=True)

Testuj aplikację:

Podsumowanie

W tej lekcji nauczyłeś/aś się:

  • Wiele routes dla jednej funkcji
  • Trailing slash (/ vs bez /)
  • HTTP methods (GET, POST, PUT, DELETE)
  • Request object (args, form, json, headers)
  • Response object (make_response, jsonify)
  • Redirects (redirect, url_for)
  • URL building z url_for()
  • Error handlers (404, 500, custom)
  • Before/After request hooks
  • Praktyczna aplikacja Safari Database v2

Analogia Safari finalna: Zaawansowany routing to jak profesjonalny system szlaków safari - możesz przekierowywać turystów (redirect), obsługiwać zgubienia się (404), mierzyć czas trasy (hooki), i budować mapy z nazw zamiast współrzędnych (url_for)!

Następna lekcja: Darwin pokaże Ci Jinja2 templates - kończymy z hardcoded HTML strings i zaczynamy dynamiczne szablony!

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Jak zdefiniować dynamiczny parametr 'species_id' w URL Flask?

  2. 2. Jak wymusić, żeby parametr 'id' był typu int w Flask?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż dekorator route z dynamicznym parametrem int:

  • Klikanie w kolejności

    Ułóż funkcję widoku przyjmującą parametr species_id:

  • Edytor kodu

    Napisz funkcję widoku z dynamicznym parametrem id typu int.

  • Układanie w pionie

    Ułóż kod obsługi błędu 404 w Flask:

  1. PytanieDynamiczne parametry URL
  2. PytanieKonwerter typu int
  3. PytanieMetody HTTP
  4. Ułóż w kolejnościDynamiczny routing
  5. Kliknij w kolejnościFunkcja widoku z parametrem
  6. Zadanie z kodemAPI endpointy
  7. Ułóż w kolejnościObsługa błędu 404

Przydatne artykuły