Kurs Python · Moduł 5: Flask i aplikacje webowe
Routing i view functions - zaawansowane techniki
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 datarequest.files- przesłane plikirequest.cookies- ciasteczkarequest.headers- nagłówki HTTPrequest.method- metoda HTTP (GET, POST, etc.)request.url- pełny URLrequest.path- ścieżka URLrequest.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 htmlTest:
/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 responseFormat zwracania:
return "text"→ 200 OKreturn "text", 201→ 201 Createdreturn "text", 404→ 404 Not Foundreturn jsonify(data)→ JSON responsereturn 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=mammalPrzekierowanie 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ę:
- http://localhost:5000/ - strona główna
- http://localhost:5000/species - lista gatunków
- http://localhost:5000/species/1 - szczegóły lwa
- http://localhost:5000/species/add - dodaj gatunek
- http://localhost:5000/search?q=lew - wyszukaj
- http://localhost:5000/api/species - API JSON
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. Jak zdefiniować dynamiczny parametr 'species_id' w URL Flask?
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: