Kurs Python · Moduł 5: Flask i aplikacje webowe

Flask - mikroframework webowy

11 min czytania ·
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

FlaskDjango
Mikroframework - minimalistycznyFull-stack framework - wszystko w jednym
Elastyczny, modułowyOpinionated, konwencje
Świetny do małych/średnich projektówŚwietny do dużych projektów
Musisz sam wybrać komponentyWszystko 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/activate

Analogia: 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.0

Flask 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.txt

Pierwsza 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?

  1. Flask(__name__) - tworzy instancję aplikacji

    • __name__ to nazwa modułu (Flask używa tego do lokalizacji zasobów)
  2. @app.route('/') - dekorator definiujący route (ścieżkę URL)

    • / = strona główna (home page)
    • Gdy użytkownik wejdzie na http://localhost:5000/, wykona się funkcja hello()
  3. def hello() - view function (funkcja widoku)

    • Zwraca treść, która zostanie wyświetlona użytkownikowi
  4. app.run(debug=True) - uruchamia serwer deweloperski

    • debug=True włącza tryb debugowania (auto-reload, szczegółowe błędy)

Krok 2: Uruchom aplikację

python app.py

Output:

 * 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.py

Otwórz w przeglądarce:

Sprawdź też błędy:

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łkowite
  • float - akceptuje liczby zmiennoprzecinkowe
  • path - jak string, ale akceptuje slashe
  • uuid - 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:

  1. Uruchom python app.py
  2. Zmień coś w kodzie (np. tekst w route)
  3. Zapisz plik
  4. 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.0

Windows (PowerShell):

$env:FLASK_APP = "app.py"
$env:FLASK_DEBUG = "1"
flask run

Struktura 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. 1. Jak najlepiej opisać Flask?

  2. 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!'

  1. PytanieCzym jest Flask?
  2. PytanieInstalacja Flask
  3. PytanieDekorator @app.route
  4. Ułóż w kolejnościMinimalna aplikacja Flask
  5. Kliknij w kolejnościTworzenie instancji Flask
  6. Zadanie z kodemPierwsza aplikacja Flask

Przydatne artykuły