Formularz logowania zaczyna się niewinnie, lecz po dodaniu walidacji, komunikatu błędu, stanu ładowania i ponawiania żądania kod interfejsu szybko puchnie. Najczęściej pomaga wtedy oddzielenie stanu ekranu od widoku, choć rozwiązanie ma sens dopiero wtedy, gdy ekran rzeczywiście podejmuje własne decyzje. Uważam, że ViewModel jest najbardziej użyteczny jako spokojny pośrednik między interfejsem a logiką aplikacji, a nie jako worek na każdą funkcję.

Model widoku porządkuje stan ekranu, ale nie zastępuje całej architektury
- Model przechowuje dane i reguły domenowe, a ViewModel przedstawia je w formie wygodnej dla ekranu.
- Widok renderuje stan i przekazuje intencje użytkownika, zamiast samodzielnie pobierać dane z bazy lub pliku.
- ViewModel powinien znać model i repozytoria, lecz nie powinien znać konkretnych przycisków, okien ani kontrolek.
- Python nie ma jednego wbudowanego mechanizmu MVVM, dlatego wzorzec składa się z prostych klas i ustalonego przepływu danych.
- Mały skrypt nie potrzebuje rozbudowanej architektury, jeśli dodatkowe warstwy nie rozwiązują żadnego problemu.
ViewModel jest warstwą dla ekranu, nie drugim modelem danych
Najłatwiej wyobrazić go sobie jako model przygotowany specjalnie dla widoku. Model może przechowywać użytkownika, zamówienie albo rekord z bazy, natomiast ViewModel decyduje, czy ekran powinien pokazać napis „Ładowanie”, listę wyników, komunikat błędu lub przycisk ponowienia.
W klasycznym MVVM widok zna ViewModel, a ViewModel zna model. Kierunek zależności kończy się właśnie na modelu, który nie powinien wiedzieć, czy dane trafią do aplikacji desktopowej, mobilnej czy przeglądarki. Taki podział opisuje również Microsoft Learn, wskazując na oddzielenie widoku, modelu widoku i modelu oraz możliwość testowania logiki bez uruchamiania interfejsu.
| Element | Za co odpowiada | Czego nie powinien robić |
|---|---|---|
| Model | Dane domenowe, reguły biznesowe, operacje na danych | Manipulować przyciskiem albo zmieniać kolor etykiety |
| ViewModel | Stan ekranu, walidacja wejścia, przygotowanie danych, obsługa intencji użytkownika | Tworzyć zależności od konkretnego okna lub widgetu |
| View | Wyświetlanie danych i przekazywanie zdarzeń | Pobierać dane z bazy przy każdym kliknięciu |
Granica między modelem a modelem widoku bywa płynna. Reguła „czy użytkownik może kupić produkt” należy do domeny, ale decyzja „pokaż czerwony komunikat pod polem ceny” należy już do warstwy prezentacji. Właśnie takie drobne rozróżnienia decydują o tym, czy po kilku miesiącach kod nadal da się czytać.
Najprostszy ViewModel w Pythonie mieści stan i decyzje widoku
W Pythonie nie trzeba instalować dużego frameworka, aby zacząć pracę z tym wzorcem. Wystarczy klasa przechowująca stan oraz zależność, która dostarcza dane. Do opisania takiego stanu dobrze pasuje dataclass, ponieważ dekorator automatycznie tworzy między innymi konstruktor i reprezentację obiektu, co potwierdza dokumentacja Pythona.
from dataclasses import dataclass
@dataclass(frozen=True)
class SearchState:
query: str = ""
status: str = "idle"
items: tuple[str, ...] = ()
error: str | None = None
class SearchViewModel:
def __init__(self, repository):
self.repository = repository
self.state = SearchState()
def search(self, text: str) -> None:
query = text.strip()
if not query:
self.state = SearchState(status="empty")
return
self.state = SearchState(
query=query,
status="loading"
)
try:
results = tuple(self.repository.search(query))
except ValueError:
self.state = SearchState(
query=query,
status="error",
error="Nie udało się odczytać wyników."
)
return
self.state = SearchState(
query=query,
status="success",
items=results
)
Widok nie musi wiedzieć, z jakiego źródła pochodzą wyniki. Wywołuje metodę search(), a potem odczytuje state. Jeśli repozytorium pobiera dane z XML, jego zadaniem jest parsowanie i filtrowanie pliku, natomiast ViewModel może zamienić wynik na listę nazw gotową do pokazania. Przy pracy z takim źródłem przydatne będzie również odczytywanie plików XML.
W tym przykładzie stan jest niezmienny, bo każda operacja tworzy nowy obiekt SearchState. Nie jest to jedyna poprawna technika, ale ogranicza przypadkowe zmiany rozsiane po kodzie. Widok może dzięki temu obsłużyć kilka sytuacji bez zaglądania do szczegółów zapytania.
Pięć stanów ekranu pokazuje, gdzie kończy się odpowiedzialność widoku
Najwięcej nieporozumień pojawia się wtedy, gdy programista opisuje ekran jednym polem data. W praktyce wyszukiwarka, formularz lub panel administracyjny potrzebują osobnych stanów, bo pusty wynik nie oznacza tego samego co błąd połączenia.
| Stan | Co wie ViewModel | Co robi View |
|---|---|---|
idle |
Użytkownik jeszcze nie rozpoczął operacji | Pokazuje pusty formularz |
empty |
Zapytanie nie zawiera użytecznej treści | Pokazuje informację o wymaganym polu |
loading |
Operacja trwa | Blokuje ponowne wysłanie i pokazuje wskaźnik postępu |
success |
Dane są dostępne | Renderuje listę wyników |
error |
Operacja zakończyła się problemem | Pokazuje komunikat i opcję ponowienia |
Ten układ daje prosty przepływ: użytkownik wysyła zdarzenie, ViewModel zmienia stan, a widok reaguje na nową wartość. W aplikacjach korzystających z wiązania danych mechanizm może aktualizować interfejs automatycznie. W Tkinterze podobną rolę mogą pełnić obiekty StringVar, IntVar lub BooleanVar, które łączą wartość Pythona z kontrolką zgodnie z dokumentacją Tkintera.
Nie oznacza to jednak, że każdy element interfejsu powinien mieć osobną klasę ViewModel. Dla prostego pola tekstowego wystarczy zwykła zmienna. Osobna warstwa zaczyna się opłacać, gdy ekran ma kilka stanów, wykonuje operacje asynchroniczne albo łączy dane z więcej niż jednego źródła.
Po dwóch obrotach telefonu ViewModel zostaje, lecz Activity znika
Android dobrze pokazuje, dlaczego model widoku nie jest zwykłą klasą pomocniczą. Podczas obrotu ekranu obiekt Activity może zostać zniszczony i utworzony ponownie, a ViewModel powiązany z tym ekranem zachowuje stan oraz może kontynuować pracę. Opis cyklu życia i zakresu ViewModelu znajduje się w Android Developers.
| Moment | Stan komponentów | Praktyczny skutek |
|---|---|---|
| Uruchomienie ekranu | Powstaje Activity i ViewModel | Rozpoczyna się pobieranie danych |
| Pierwszy obrót | Activity jest odtwarzane, ViewModel pozostaje | Stan ekranu nie musi być pobierany od początku |
| Drugi obrót | Powstaje kolejny widok, ale nadal działa ten sam zakres ViewModelu | Nowy widok odczytuje istniejący stan |
| Zamknięcie ekranu | ViewModel zostaje wyczyszczony po zakończeniu swojego zakresu | Można anulować zadania i zwolnić zasoby |
Tu pojawia się częsty błąd. Skoro ViewModel żyje dłużej niż widok, nie powinien przechowywać referencji do Activity, Context ani konkretnej kontrolki. Dokumentacja Androida ostrzega przed takim połączeniem, ponieważ dłuższe życie ViewModelu może zatrzymać obiekt interfejsu w pamięci.
Bezpieczniejszy układ wygląda tak: ViewModel otrzymuje repozytorium, repozytorium korzysta z warstwy danych, a widok obserwuje stan. Jeśli potrzebny jest tekst zależny od języka, formatowanie albo zasób aplikacji, najpierw trzeba sprawdzić, czy ta odpowiedzialność naprawdę należy do ViewModelu, czy lepiej przekazać już przygotowaną wartość z odpowiedniej warstwy.
MVVM nie ma jednej recepty, a przegląd wyróżnił 76 wariantów decyzji
W obiegu często przedstawia się MVVM tak, jakby istniała jedna poprawna liczba klas, jeden sposób nawigacji i jeden rodzaj wiązania danych. Przegląd MVVM Revisited opublikowany w 2025 roku pokazuje bardziej złożony obraz: autorzy zidentyfikowali 76 dodatkowych konstrukcji projektowych, pogrupowanych w 29 aspektów, a także 16 dodatkowych korzyści i 15 wad.
Wniosek jest praktyczny. Nazwa wzorca nie rozstrzyga, gdzie ma trafić nawigacja, walidacja, formatowanie, komunikacja między ekranami czy obsługa błędów. Takie decyzje trzeba podjąć dla konkretnej aplikacji, inaczej ViewModel szybko stanie się klasą, która pobiera dane, steruje nawigacją, otwiera okna i zna pół frameworka.
Przyjąłbym prostą granicę dla początkującego projektu:
- jeśli ekran ma co najmniej dwa niezależne stany, wykonuje operację trwającą dłużej niż pojedyncze kliknięcie i wymaga testowania bez GUI, wydzielenie ViewModelu zwykle jest rozsądne;
- jeśli ekran wyświetla stały tekst i obsługuje jedną prostą akcję, dodatkowa warstwa może tylko zwiększyć liczbę plików;
- jeśli ViewModel zaczyna zawierać kod nawigacji, dostęp do kontrolek i bezpośrednie zapytania do bazy, trzeba podzielić odpowiedzialności zamiast dopisywać kolejne metody.
W porównaniu z MVC model widoku przejmuje część zadań, które często trafiają do kontrolera, lecz nie powinien stać się kontrolerem w przebraniu. Przy małej aplikacji wybrałbym prostszy układ, a MVVM wprowadziłbym dopiero wtedy, gdy pojawi się powtarzalny problem ze stanem ekranu, testami lub zmianą interfejsu.
Gdy ViewModel puchnie, objaw zwykle wskazuje winowajcę
Duża klasa sama w sobie nie dowodzi jeszcze błędu architektonicznego. Częściej problem zdradza mieszanka importów, zależności i metod, które opisują zupełnie różne poziomy aplikacji.
| Sytuacja w kodzie | Prawdopodobna przyczyna | Co zrobić |
|---|---|---|
ViewModel importuje Button, Window albo Entry |
Logika ekranu zależy od konkretnego GUI | Przenieść obsługę kontrolek do widoku i zostawić w ViewModelu dane oraz metody biznesowe |
| Jedna metoda otwiera XML, filtruje rekordy i zapisuje wynik do bazy | Połączono dostęp do danych, reguły domenowe i prezentację | Wydzielić repozytorium oraz osobną operację domenową |
| Widok ma wiele warunków dotyczących błędów i walidacji | Decyzje prezentacyjne zostały wymieszane z renderowaniem | Przenieść wynik walidacji do stanu ViewModelu |
ViewModel przyjmuje Activity, Context albo obiekt okna |
Zależność od cyklu życia interfejsu | Zastąpić ją repozytorium, usługą albo prostym obiektem danych |
| Klasa ma kilkanaście metod dotyczących różnych ekranów | Jeden ViewModel obsługuje zbyt szeroki zakres | Podzielić go według ekranów lub niezależnych przypadków użycia |
W Pythonie łatwiej utrzymać taki podział, gdy każda klasa ma jasno określony kontrakt. Pomaga w tym świadome korzystanie z programowania obiektowego w Pythonie, zwłaszcza rozdzielenie danych, metod i zależności zamiast tworzenia jednej klasy „od wszystkiego”.
Nie trzeba też walczyć o absolutnie czysty widok. Krótka obsługa techniczna, na przykład ustawienie fokusu albo zamknięcie menu, może zostać w warstwie interfejsu. Granica przebiega tam, gdzie kod zaczyna podejmować decyzje o danych, błędach i stanie aplikacji.
Zostaw w ViewModelu tylko to, co należy do stanu ekranu
Najkrótsza definicja brzmi tak: ViewModel tłumaczy stan aplikacji na stan potrzebny widokowi. Model zna dane, widok je pokazuje, a warstwa pośrodku pilnuje, żeby kliknięcia, wyniki operacji i komunikaty błędów miały jedno uporządkowane miejsce.
Jeżeli aplikacja jest mała, zacznij od prostych funkcji i dopiero potem wydziel klasę. Jeżeli ekran ma kilka stanów, pobiera dane z wielu źródeł albo musi przeżyć odtworzenie interfejsu, ViewModel szybko przestaje być ozdobną warstwą i staje się wygodnym punktem kontroli nad całą logiką prezentacji.
