Czym jest Python Flask?

Flask to mikro-framework webowy napisany w Pythonie, stworzony przez Armina Ronachera i opublikowany po raz pierwszy w 2010 roku. Określenie "mikro" nie oznacza, że Flask jest ograniczony w swoich możliwościach — wręcz przeciwnie. Oznacza to, że framework utrzymuje proste, minimalistyczne jądro, pozostawiając programiście pełną swobodę w doborze narzędzi i bibliotek. Flask nie narzuca konkretnej struktury bazy danych, systemu uwierzytelniania ani żadnych innych komponentów, które możesz chcieć dodać do swojej aplikacji.

W porównaniu do Django, który jest bardziej rozbudowanym frameworkiem, Flask wyróżnia się prostotą i elastycznością. Jest idealnym wyborem dla małych i średnich projektów, prototypów, API RESTowych oraz dla osób, które dopiero zaczynają swoją przygodę z tworzeniem aplikacji webowych w Pythonie.

Wymagania wstępne

Zanim przystąpimy do tworzenia pierwszej aplikacji, upewnij się, że masz zainstalowane następujące narzędzia:

  • Python 3.8 lub nowszy — Flask wymaga Pythona w wersji 3.x
  • pip — menedżer pakietów Pythona (zazwyczaj instalowany razem z Pythonem)
  • Edytor kodu — np. Visual Studio Code, PyCharm lub dowolny inny
  • Terminal / wiersz poleceń — do uruchamiania poleceń

Możesz sprawdzić wersję Pythona poleceniem:

python --version

Tworzenie środowiska wirtualnego

Dobrą praktyką jest tworzenie oddzielnego środowiska wirtualnego dla każdego projektu Pythonowego. Dzięki temu unikamy konfliktów między wersjami pakietów w różnych projektach. Utwórzmy środowisko wirtualne dla naszej aplikacji Flask:

# Utwórz folder projektu
mkdir moja_aplikacja_flask
cd moja_aplikacja_flask

# Utwórz środowisko wirtualne
python -m venv venv

# Aktywuj środowisko (Windows)
venv\Scripts\activate

# Aktywuj środowisko (macOS/Linux)
source venv/bin/activate

Po aktywacji środowiska wirtualnego zobaczysz jego nazwę w nawiasach na początku wiersza poleceń, np. (venv). Teraz możemy zainstalować Flask:

pip install flask

Pierwsza aplikacja Flask — "Hello, World!"

Zacznijmy od najprostszego możliwego przykładu. Utwórz plik app.py w swoim folderze projektu i wpisz następujący kod:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Witaj, świecie!'

if __name__ == '__main__':
    app.run(debug=True)

Przeanalizujmy ten kod linijka po linijce:

  • from flask import Flask — importujemy klasę Flask z pakietu flask
  • app = Flask(__name__) — tworzymy instancję aplikacji Flask; parametr __name__ pomaga Flaskowi znaleźć zasoby aplikacji
  • @app.route('/') — dekorator, który mówi Flaskowi, że ta funkcja powinna być wywołana, gdy użytkownik odwiedzi adres główny aplikacji
  • def hello_world() — funkcja widoku, która zwraca odpowiedź HTTP
  • app.run(debug=True) — uruchamia serwer deweloperski z trybem debug włączonym

Uruchom aplikację poleceniem:

python app.py

Otwórz przeglądarkę i przejdź pod adres http://127.0.0.1:5000. Powinieneś zobaczyć napis "Witaj, świecie!".

Routing i parametry URL

Flask umożliwia definiowanie różnych tras (routes) dla różnych adresów URL. Możesz również przekazywać parametry w adresie URL:

from flask import Flask

app = Flask(__name__)

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

@app.route('/o-nas')
def o_nas():
    return 'Strona o nas'

@app.route('/uzytkownik/<nazwa>')
def profil_uzytkownika(nazwa):
    return f'Profil użytkownika: {nazwa}'

@app.route('/artykul/<int:id>')
def artykul(id):
    return f'Artykuł numer: {id}'

if __name__ == '__main__':
    app.run(debug=True)

W powyższym przykładzie <nazwa> to dynamiczny parametr URL, który zostanie przekazany jako argument do funkcji. Możesz również określić typ parametru, np. <int:id> wymusza, aby parametr był liczbą całkowitą.

Szablony HTML z Jinja2

Zwracanie surowego tekstu z funkcji widoku nie jest zbyt praktyczne. Flask integruje się z silnikiem szablonów Jinja2, który pozwala na tworzenie dynamicznych stron HTML. Utwórz folder templates w swoim projekcie i dodaj plik index.html:

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Moja aplikacja Flask</title>
</head>
<body>
    <h1>Witaj, {{ imie }}!</h1>
    <p>Dzisiaj jest: {{ data }}</p>
    
    {% if uzytkownik_zalogowany %}
        <p>Jesteś zalogowany.</p>
    {% else %}
        <p>Nie jesteś zalogowany.</p>
    {% endif %}
    
    <ul>
    {% for artykul in artykuly %}
        <li>{{ artykul }}</li>
    {% endfor %}
    </ul>
</body>
</html>

Teraz zaktualizuj plik app.py, aby używał tego szablonu:

from flask import Flask, render_template
from datetime import date

app = Flask(__name__)

@app.route('/')
def index():
    artykuly = ['Wprowadzenie do Pythona', 'Flask dla początkujących', 'Bazy danych z SQLAlchemy']
    return render_template(
        'index.html',
        imie='Programisto',
        data=date.today().strftime('%d.%m.%Y'),
        uzytkownik_zalogowany=True,
        artykuly=artykuly
    )

if __name__ == '__main__':
    app.run(debug=True)

Funkcja render_template() renderuje plik HTML z folderu templates i przekazuje do niego zmienne, które można następnie użyć w szablonie za pomocą składni Jinja2 ({{ zmienna }}).

Obsługa formularzy i metod HTTP

Praktycznie każda aplikacja webowa wymaga obsługi formularzy. Flask umożliwia obsługę zarówno żądań GET, jak i POST. Utwórz plik templates/formularz.html:

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Formularz kontaktowy</title>
</head>
<body>
    <h1>Formularz kontaktowy</h1>
    {% if wiadomosc %}
        <p style="color: green;">{{ wiadomosc }}</p>
    {% endif %}
    <form method="POST">
        <label>Imię: <input type="text" name="imie" required></label><br>
        <label>Email: <input type="email" name="email" required></label><br>
        <label>Wiadomość: <textarea name="tresc"></textarea></label><br>
        <button type="submit">Wyślij</button>
    </form>
</body>
</html>

W pliku app.py dodaj obsługę tego formularza:

from flask import Flask, render_template, request

@app.route('/kontakt', methods=['GET', 'POST'])
def kontakt():
    wiadomosc = None
    if request.method == 'POST':
        imie = request.form.get('imie')
        email = request.form.get('email')
        tresc = request.form.get('tresc')
        # Tutaj można dodać logikę zapisu do bazy danych lub wysyłki emaila
        wiadomosc = f'Dziękujemy, {imie}! Twoja wiadomość została wysłana.'
    return render_template('formularz.html', wiadomosc=wiadomosc)

Pliki statyczne

Flask automatycznie obsługuje pliki statyczne (CSS, JavaScript, obrazy) umieszczone w folderze static. Utwórz plik static/style.css:

body {
    font-family: Arial, sans-serif;
    max-width: 800px;
    margin: 0 auto;
    padding: 20px;
    background-color: #f5f5f5;
}

h1 {
    color: #333;
    border-bottom: 2px solid #007bff;
    padding-bottom: 10px;
}

W szablonie HTML możesz odwołać się do pliku statycznego używając funkcji url_for():

<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">

Struktura projektu Flask

Dla większych projektów warto zorganizować kod w odpowiednią strukturę katalogów. Oto przykładowa struktura dla średniej wielkości aplikacji Flask:

moja_aplikacja_flask/
│
├── app.py
├── requirements.txt
├── venv/
│
├── static/
│   ├── css/
│   │   └── style.css
│   ├── js/
│   │   └── main.js
│   └── images/
│
└── templates/
    ├── base.html
    ├── index.html
    ├── formularz.html
    └── o-nas.html

Dobrą praktyką jest również utworzenie szablonu bazowego (base.html), który będzie zawierał wspólne elementy strony (nagłówek, stopkę, menu nawigacyjne), a pozostałe szablony będą go rozszerzać:

<!-- base.html -->
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>{% block title %}Moja Aplikacja{% endblock %}</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
</head>
<body>
    <nav>
        <a href="{{ url_for('index') }}">Strona główna</a>
        <a href="{{ url_for('kontakt') }}">Kontakt</a>
    </nav>
    <main>
        {% block content %}{% endblock %}
    </main>
    <footer><p>&copy; 2026 Moja Aplikacja</p></footer>
</body>
</html>

<!-- index.html -->
{% extends 'base.html' %}

{% block title %}Strona główna{% endblock %}

{% block content %}
    <h1>Witaj na stronie głównej!</h1>
    <p>To jest moja pierwsza aplikacja Flask.</p>
{% endblock %}

Przydatne rozszerzenia Flask

Ekosystem Flask jest bogaty w rozszerzenia, które znacznie ułatwiają pracę. Oto kilka najpopularniejszych:

  • Flask-SQLAlchemy — integracja z bazami danych SQL poprzez ORM SQLAlchemy
  • Flask-Login — zarządzanie sesjami użytkowników i uwierzytelnianie
  • Flask-WTF — zaawansowana obsługa formularzy z walidacją i ochroną CSRF
  • Flask-Mail — wysyłanie wiadomości email
  • Flask-Migrate — zarządzanie migracjami bazy danych
  • Flask-RESTful — tworzenie REST API

Możesz zainstalować je za pomocą pip, np.:

pip install flask-sqlalchemy flask-login flask-wtf

Podsumowanie

Flask to doskonały wybór dla każdego, kto chce nauczyć się tworzenia aplikacji webowych w Pythonie. Jego prostota sprawia, że pierwsze kroki są łatwe, a elastyczność pozwala na budowanie zaawansowanych projektów. W tym artykule omówiliśmy podstawowe koncepcje: instalację, tworzenie tras, obsługę szablonów Jinja2, formularzy oraz plików statycznych.

To dopiero wstęp do możliwości, jakie oferuje Flask. W kolejnych artykułach na techbyte.pl omówimy integrację z bazami danych, tworzenie REST API oraz wdrażanie aplikacji Flask na serwerze produkcyjnym. Zachęcamy do eksperymentowania i rozwijania własnych projektów — najlepszą nauką jest praktyka!