Kurs Python · Moduł 5: Flask i aplikacje webowe
Flask - mikroframework webowy
W tej lekcji11
Witaj z powrotem! Darwin tutaj, gotowy pokazać Ci Flask - najpopularniejszy mikroframework webowy w Pythonie!
W poprzedniej lekcji poznałeś/aś podstawy frontendu (HTML, CSS, JavaScript). Teraz połączymy to z Pythonem używając Flask!
Analogia Safari: Flask to jak mobilne centrum badawcze - lekkie, elastyczne, możesz je łatwo przenieść w dowolne miejsce i szybko zacząć obserwacje! Nie potrzebujesz ogromnego laboratorium (Django), aby rozpocząć badania.
Czym jest Flask?
Flask to mikroframework webowy napisany w Pythonie przez Armina Ronachera w 2010 roku.
Mikroframework = minimalistyczny framework z podstawowymi funkcjami, który możesz rozbudować wtyczkami.
Flask vs Django
| Flask | Django |
|---|---|
| Mikroframework - minimalistyczny | Full-stack framework - wszystko w jednym |
| Elastyczny, modułowy | Opinionated, konwencje |
| Świetny do małych/średnich projektów | Świetny do dużych projektów |
| Musisz sam wybrać komponenty | Wszystko out-of-the-box |
| ~10 linii dla Hello World | ~50 linii dla Hello World |
| Świetny do nauki! | Bardziej skomplikowany |
Analogia: Flask to namiot badawczy (szybkie ustawienie), Django to pełne laboratorium (długa konfiguracja, ale wszystkie narzędzia).
Po co używać Flask?
Prosty - minimalna krzywa uczenia Elastyczny - sam wybierasz komponenty Lekki - mała aplikacja, szybki start Pythonowy - czysty, czytelny kod Świetna dokumentacja - łatwo się uczyć Duża społeczność - mnóstwo wtyczek
Przykłady użycia Flask:
- Prototypy i MVP
- Dashboardy i panele admina
- API dla aplikacji mobilnych
- Wizualizacje danych
- Projekty edukacyjne
Instalacja Flask
Flask instalujemy przez pip jak każdy pakiet Pythona.
Krok 1: Stwórz wirtualne środowisko
Zawsze używaj wirtualnego środowiska dla projektów Pythona!
# Stwórz folder projektu
mkdir safari_web
cd safari_web
# Stwórz wirtualne środowisko
python -m venv venv
# Aktywuj środowisko
# Windows:
venv\Scripts\activate
# Mac/Linux:
source venv/bin/activateAnalogia: Wirtualne środowisko to jak odseparowana zagroda dla Twojego projektu - biblioteki z jednego projektu nie będą kolidować z innymi!
Krok 2: Zainstaluj Flask
# Zainstaluj Flask
pip install Flask
# Sprawdź wersję
flask --version
# Output: Python 3.11.0
# Flask 3.0.0
# Werkzeug 3.0.0Flask automatycznie instaluje:
- Werkzeug - WSGI utility library (routing, debugging)
- Jinja2 - template engine (dynamiczny HTML)
- MarkupSafe - bezpieczne renderowanie HTML
- ItsDangerous - bezpieczne podpisywanie danych
- Click - CLI framework
Krok 3: Stwórz plik requirements.txt
# Zapisz zależności
pip freeze > requirements.txt
# Zawartość requirements.txt:
Flask==3.0.0
Werkzeug==3.0.0
Jinja2==3.1.2
...Po co? Inni developerzy mogą zainstalować te same wersje:
pip install -r requirements.txtPierwsza aplikacja Flask - Hello World
Czas na pierwszy program Flask! Stworzymy stronę wyświetlającą "Hello Safari!"
Krok 1: Stwórz plik app.py
# app.py
from flask import Flask
# Stwórz instancję aplikacji Flask
app = Flask(__name__)
# Zdefiniuj route (adres URL)
@app.route('/')
def hello():
return "Hello Safari!"
# Uruchom serwer developerski
if __name__ == '__main__':
app.run(debug=True)Co się dzieje?
Flask(__name__)- tworzy instancję aplikacji__name__to nazwa modułu (Flask używa tego do lokalizacji zasobów)
@app.route('/')- dekorator definiujący route (ścieżkę URL)/= strona główna (home page)- Gdy użytkownik wejdzie na
http://localhost:5000/, wykona się funkcjahello()
def hello()- view function (funkcja widoku)- Zwraca treść, która zostanie wyświetlona użytkownikowi
app.run(debug=True)- uruchamia serwer deweloperskidebug=Truewłącza tryb debugowania (auto-reload, szczegółowe błędy)
Krok 2: Uruchom aplikację
python app.pyOutput:
* Serving Flask app 'app'
* Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment.
* Running on http://127.0.0.1:5000
Press CTRL+C to quit
* Restarting with stat
* Debugger is active!Krok 3: Otwórz w przeglądarce
Przejdź do: http://localhost:5000/
Zobaczysz: Hello Safari!
Gratulacje! Właśnie stworzyłeś/aś pierwszą aplikację Flask!
Anatomia aplikacji Flask
Przeanalizujmy dokładniej, jak działa Flask.
1. Instancja aplikacji
from flask import Flask
app = Flask(__name__)Flask(__name__) tworzy obiekt aplikacji:
__name__= nazwa modułu (np.'__main__'lub'app')- Flask używa tego do lokalizacji templates, static files
2. Routes (ścieżki URL)
Route = mapowanie URL → funkcja
@app.route('/species')
def list_species():
return "Lista wszystkich gatunków"
@app.route('/species/lion')
def show_lion():
return "Szczegóły lwa"Jak to działa?
- Użytkownik wchodzi na
/species→ wykonuje sięlist_species() - Użytkownik wchodzi na
/species/lion→ wykonuje sięshow_lion()
Analogia: Route to jak szlak safari - każdy szlak prowadzi do innego siedliska (view function)!
3. View functions (funkcje widoku)
View function = funkcja zwracająca odpowiedź HTTP
@app.route('/')
def home():
return "<h1>Safari Database</h1><p>Witaj w systemie!</p>"Co możesz zwrócić?
- String - zostanie przekonwertowany na HTML
- HTML - renderowany w przeglądarce
- JSON - dla API (
jsonify()) - Template - dynamiczny HTML z Jinja2
4. Uruchomienie serwera
if __name__ == '__main__':
app.run(debug=True)Parametry app.run():
debug=True- tryb debugowania (auto-reload, debugger)host='0.0.0.0'- dostępny z innych urządzeńport=5000- numer portu (domyślnie 5000)
WAŻNE: NIGDY nie używaj debug=True w produkcji!
Safari Database - pierwsza aplikacja
Stworzymy prostą aplikację Safari Database z kilkoma route'ami!
app.py - pełna aplikacja
# app.py
from flask import Flask
app = Flask(__name__)
# Dane testowe
species = [
{"id": 1, "name": "Lew", "scientific_name": "Panthera leo", "population": 120},
{"id": 2, "name": "Słoń afrykański", "scientific_name": "Loxodonta africana", "population": 450},
{"id": 3, "name": "Gepard", "scientific_name": "Acinonyx jubatus", "population": 7100},
]
# Route 1: Strona główna
@app.route('/')
def home():
html = """
<!DOCTYPE html>
<html>
<head>
<title>Safari Database</title>
<style>
body {
font-family: Arial, sans-serif;
max-width: 800px;
margin: 50px auto;
padding: 20px;
background-color: #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>
<p>System zarządzania danymi o gatunkach afrykańskich</p>
<nav>
<a href="/">Strona główna</a>
<a href="/species">Lista gatunków</a>
<a href="/about">O systemie</a>
</nav>
<h2>Witaj w Safari Database!</h2>
<p>Baza danych zawiera <strong>{} gatunków</strong> afrykańskich.</p>
<p><a href="/species">Zobacz pełną listę gatunków →</a></p>
</body>
</html>
""".format(len(species))
return html
# Route 2: Lista gatunków
@app.route('/species')
def list_species():
species_html = ""
for spec in species:
species_html += f"""
<div style="background: white; padding: 15px; margin: 10px 0; border-radius: 8px; border-left: 4px solid #2c5f2d;">
<h3>{spec['name']}</h3>
<p><strong>Nazwa naukowa:</strong> {spec['scientific_name']}</p>
<p><strong>Populacja:</strong> {spec['population']} osobników</p>
<a href="/species/{spec['id']}">Zobacz szczegóły →</a>
</div>
"""
html = f"""
<!DOCTYPE html>
<html>
<head>
<title>Lista gatunków - Safari Database</title>
<style>
body {{
font-family: Arial, sans-serif;
max-width: 800px;
margin: 50px auto;
padding: 20px;
background-color: #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>Lista gatunków</h1>
<nav>
<a href="/">Strona główna</a>
<a href="/species">Lista gatunków</a>
<a href="/about">O systemie</a>
</nav>
<p>Łącznie: <strong>{len(species)} gatunków</strong></p>
{species_html}
<p><a href="/">← Powrót do strony głównej</a></p>
</body>
</html>
"""
return html
# Route 3: Szczegóły gatunku (dynamiczny URL)
@app.route('/species/<int:species_id>')
def show_species(species_id):
# Znajdź gatunek po ID
spec = next((s for s in species if s['id'] == species_id), None)
if spec is None:
return "<h1>404 - Gatunek nie znaleziony</h1><a href='/species'>Powrót do listy</a>", 404
html = f"""
<!DOCTYPE html>
<html>
<head>
<title>{spec['name']} - Safari Database</title>
<style>
body {{
font-family: Arial, sans-serif;
max-width: 800px;
margin: 50px auto;
padding: 20px;
background-color: #f4f1de;
}}
h1 {{ color: #2c5f2d; }}
.card {{
background: white;
padding: 30px;
border-radius: 12px;
border: 3px solid #2c5f2d;
}}
</style>
</head>
<body>
<h1>{spec['name']}</h1>
<div class="card">
<h2>{spec['name']}</h2>
<p><strong>Nazwa naukowa:</strong> <em>{spec['scientific_name']}</em></p>
<p><strong>Populacja:</strong> {spec['population']} osobników</p>
<p><strong>ID w systemie:</strong> {spec['id']}</p>
</div>
<p style="margin-top: 20px;">
<a href="/species">← Powrót do listy gatunków</a> |
<a href="/">← Strona główna</a>
</p>
</body>
</html>
"""
return html
# Route 4: O systemie
@app.route('/about')
def about():
html = """
<!DOCTYPE html>
<html>
<head>
<title>O systemie - Safari Database</title>
<style>
body {
font-family: Arial, sans-serif;
max-width: 800px;
margin: 50px auto;
padding: 20px;
background-color: #f4f1de;
}
h1 { color: #2c5f2d; }
</style>
</head>
<body>
<h1>O Safari Database</h1>
<p><strong>Safari Database</strong> to system zarządzania danymi o gatunkach afrykańskich.</p>
<h2>Technologie:</h2>
<ul>
<li>Flask 3.0 - mikroframework webowy</li>
<li>Python 3.11 - język programowania</li>
<li>HTML/CSS - frontend</li>
</ul>
<h2>Funkcje:</h2>
<ul>
<li>Przeglądanie listy gatunków</li>
<li>Szczegóły każdego gatunku</li>
<li>Statystyki populacji</li>
</ul>
<p><a href="/">← Powrót do strony głównej</a></p>
</body>
</html>
"""
return html
# Uruchom serwer deweloperski
if __name__ == '__main__':
print("Safari Database startuje...")
print("Serwer dostępny pod adresem: http://localhost:5000/")
app.run(debug=True)Testowanie aplikacji
python app.pyOtwórz w przeglądarce:
- 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/2 - szczegóły słonia
- http://localhost:5000/about - o systemie
Sprawdź też błędy:
- http://localhost:5000/species/999 - gatunek nie istnieje (404)
Dynamiczne URL - parametry
Flask pozwala na dynamiczne URL z parametrami:
# Podstawowy parametr (string)
@app.route('/user/<username>')
def show_user(username):
return f"Użytkownik: {username}"
# Parametr typu int
@app.route('/species/<int:species_id>')
def show_species(species_id):
return f"Gatunek ID: {species_id}"
# Parametr typu float
@app.route('/price/<float:price>')
def show_price(price):
return f"Cena: {price:.2f} zł"
# Parametr path (może zawierać /)
@app.route('/file/<path:filepath>')
def show_file(filepath):
return f"Plik: {filepath}"Typy konwerterów:
string- akceptuje tekst bez slasha (domyślny)int- akceptuje liczby całkowitefloat- akceptuje liczby zmiennoprzecinkowepath- jak string, ale akceptuje slasheuuid- akceptuje UUID strings
Przykłady URL:
/user/darwin → username="darwin"
/species/42 → species_id=42
/price/19.99 → price=19.99
/file/images/lion.jpg → filepath="images/lion.jpg"HTTP Methods - GET i POST
Flask domyślnie obsługuje tylko GET requests. Możesz dodać inne metody:
from flask import request
# Tylko GET (domyślnie)
@app.route('/species')
def list_species():
return "Lista gatunków (GET)"
# GET i POST
@app.route('/species', methods=['GET', 'POST'])
def species():
if request.method == 'POST':
# Obsługa formularza
name = request.form['name']
return f"Dodano gatunek: {name}"
else:
# Wyświetl formularz
return """
<form method="POST">
<input type="text" name="name" placeholder="Nazwa gatunku">
<button type="submit">Dodaj</button>
</form>
"""
# Tylko POST
@app.route('/api/species', methods=['POST'])
def create_species():
return "Utworzono gatunek (POST only)"Metody HTTP:
- GET - pobierz dane (domyślne, bezpieczne)
- POST - wyślij dane (formularze, tworzenie)
- PUT - aktualizuj dane (pełna aktualizacja)
- PATCH - aktualizuj częściowo
- DELETE - usuń dane
Debugowanie i Auto-reload
Debug mode (debug=True) włącza:
1. Auto-reload
Serwer automatycznie restartuje się po zmianie kodu!
app.run(debug=True)Testuj:
- Uruchom
python app.py - Zmień coś w kodzie (np. tekst w route)
- Zapisz plik
- Flask automatycznie przeładuje aplikację!
2. Interaktywny debugger
Gdy wystąpi błąd, Flask pokazuje interaktywny debugger w przeglądarce:
@app.route('/error')
def error():
result = 10 / 0 # Błąd: dzielenie przez zero!
return "This won't be reached"Wejdź na /error → zobaczysz szczegółowy traceback z możliwością inspekcji zmiennych!
3. Szczegółowe komunikaty błędów
Flask pokazuje dokładne informacje o błędach zamiast ogólnego "500 Internal Server Error".
WAŻNE: NIGDY nie używaj debug=True w produkcji - pokazuje kod źródłowy i pozwala wykonywać kod!
Flask CLI - alternatywny sposób uruchamiania
Zamiast python app.py możesz użyć Flask CLI:
# Ustaw zmienną środowiskową
export FLASK_APP=app.py
export FLASK_DEBUG=1 # Włącz debug mode
# Uruchom serwer
flask run
# Uruchom na innym porcie
flask run --port 8000
# Dostępny z innych urządzeń
flask run --host=0.0.0.0Windows (PowerShell):
$env:FLASK_APP = "app.py"
$env:FLASK_DEBUG = "1"
flask runStruktura projektu Flask
Prosty projekt Flask może wyglądać tak:
safari_web/
│
├── venv/ # Wirtualne środowisko (nie commituj do git!)
│
├── app.py # Główna aplikacja
│
├── requirements.txt # Zależności (pip freeze)
│
├── static/ # Pliki statyczne (CSS, JS, obrazy)
│ ├── css/
│ │ └── style.css
│ ├── js/
│ │ └── script.js
│ └── images/
│ └── logo.png
│
├── templates/ # Szablony HTML (Jinja2)
│ ├── base.html
│ ├── home.html
│ └── species.html
│
└── .gitignore # Ignoruj venv/, __pycache__/, etc.W następnej lekcji nauczymy się używać templates zamiast hardcoded HTML strings!
Podsumowanie
W tej lekcji nauczyłeś/aś się:
- Czym jest Flask i po co go używać
- Instalacja Flask (
pip install Flask) - Pierwszy program Flask (Hello World)
- Anatomia aplikacji Flask (app, routes, view functions)
- Tworzenie wielu routes
- Dynamiczne URL z parametrami
- Debug mode i auto-reload
- Struktura projektu Flask
Analogia Safari finalna: Flask to mobilne centrum badawcze - lekkie, szybko się ustawia, możesz zacząć obserwacje w kilka minut! Nie potrzebujesz ogromnego laboratorium (Django), żeby rozpocząć badania Safari!
Kod aplikacji Safari Database
Stworzyłeś/aś funkcjonującą aplikację webową z:
- 4 routes (home, species list, species details, about)
- Dynamiczne URL (
/species/<int:species_id>) - HTML + inline CSS
- Dane testowe (lista gatunków)
Następna lekcja: Darwin pokaże Ci routing i view functions - zaawansowane techniki tworzenia routes, redirects, error handlers!
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 najlepiej opisać Flask?
2. Jak zainstalować Flask za pomocą pip?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Ułóż kod minimalnej aplikacji Flask w poprawnej kolejności:
- Klikanie w kolejności
Jak utworzyć instancję aplikacji Flask?
- Edytor kodu
Napisz aplikację Flask z endpointem '/' który zwraca 'Witaj w Safari!'