Kurs Python Data Science

Ten kurs jest przeznaczony dla osób, które w pierwszej kolejności opanowały podstawy programowania w Pythonie i chcą rozwijać kompetencje Python Data Science praktycznie: od analizy danych, przez aplikacje i warstwę bazodanową, aż po komunikację asynchroniczną oraz architekturę CQRS.

Rekomendowana kolejność nauki to: najpierw kurs Python, a następnie ten kurs. Dzięki temu pracujesz płynnie, rozumiesz kontekst techniczny modułów i w pełni wykorzystujesz część projektową.

Jeśli masz już wiedzę z kursu Python, możesz od razu przejść do realizacji modułów i budować portfolio oparte na realnych projektach data/backend.

To moduł, który buduje solidny fundament pod dalszą ścieżkę Python Data Science, a następnie Machine Learning i Deep Learning: najpierw ustawiasz środowisko (aby praca była szybka i powtarzalna), potem wchodzisz w NumPy jako bazę obliczeń numerycznych, rozwijasz analizę tabelaryczną w Pandas, a na końcu uczysz się wizualizacji danych (matplotlib/seaborn) — tak, aby umieć wyciągać wnioski i komunikować wyniki.

W praktyce pracujesz na dziesiątkach notebooków i ćwiczeń: poznajesz, jak działa ndarray (m.in. shape, strides, widoki vs kopie), uczysz się efektywnego przekształcania danych (reshape, ravel/flatten, concatenate/split), opanowujesz broadcasting i ufunc (reduce/accumulate), a potem przenosisz te umiejętności do Pandas: Series, DataFrame, filtrowanie, łączenie danych, agregacje, groupby, tabele przestawne oraz zagadnienia pracy z czasem (DatetimeIndex, parsowanie dat, resample, braki danych, shift).

Po ukończeniu modułu potrafisz szybko wczytać dane, oczyścić je, policzyć statystyki, zbudować sensowne agregacje i zwizualizować wynik — czyli samodzielnie realizować typowe zadania analityczne w praktycznym workflow.

Co opanujesz w tym module?

• Środowisko pracy Data Science: porównanie podejść (Colab/Codespaces/Anaconda), praca w notebookach, instalacja i zarządzanie paczkami.
• NumPy od podstaw do poziomu zaawansowanego: ndarray, dtype, shape/strides, wektoryzacja, indeksowanie, widoki vs kopie.
• Przekształcanie danych w NumPy: reshape, ravel/flatten, concatenate/vstack/hstack, split, repeat/tile, take/put.
• Broadcasting i ufunc: reguły rozgłaszania, redukcje (reduce/accumulate/reduceat), operacje typu outer, wektorowe podejście do obliczeń.
• Sortowanie i wyszukiwanie w NumPy: argsort/lexsort, searchsorted oraz praktyczne zadania na tablicach.
• Wydajność obliczeń: kiedy Python jest wolny i jak przyspieszać obliczenia (Numba).
• Podstawy Pandas: Series, DataFrame, indeksy, filtrowanie, wyrównywanie danych, praca na brakach, zmiana kształtu danych.
• Agregacje i analiza tabelaryczna: groupby (1 i wiele kluczy), iteracja po grupach, unstack/pivot jako baza pod raportowanie.
• Szeregi czasowe w Pandas: date_range/to_datetime, slicing po datach, resampling, ffill, operacje przesunięć (shift).
• Wizualizacja danych: matplotlib/seaborn, dobór wykresu do problemu, stylowanie i czytelne prezentowanie wniosków.

Wybierz ten moduł, jeśli:

• Chcesz mieć solidny fundament pod dalsze tematy DS/ML — bez luk w NumPy i Pandas.
• Chcesz liczyć i przekształcać dane szybko (wektoryzacja, broadcasting, ufunc) zamiast pisać wolne pętle.
• Chcesz umieć robić analizę danych tabelarycznych: groupby, agregacje, tabele przestawne, szeregi czasowe.
• Zależy Ci na komunikacji wyników przez dobre wykresy i poprawną interpretację.

Po ukończeniu modułu swobodnie pracujesz w typowym przepływie pracy analityka: środowisko → wczytanie danych → czyszczenie/przekształcenia → agregacje i statystyki → wizualizacje → wnioski. To fundament, na którym buduje się kolejne etapy nauki w zakresie Data Science oraz AI.

To moduł, w którym wchodzisz w jeden z najważniejszych obszarów pracy komercyjnej: trwałe przechowywanie i przetwarzanie danych. Aplikacje bazodanowe prowadzą Cię od solidnych fundamentów SQL do nowoczesnej pracy z bazami danych w aplikacji Python. To ten sam moduł, który realizujesz w kursie Python — jeśli masz go już przerobionego, możesz przejść dalej do kolejnych etapów kursu Python Data Science. Najpierw budujesz mocne podstawy w MySQL, żeby dobrze rozumieć co dzieje się „pod spodem”, następnie przenosisz tę wiedzę na projekty realizowane z użyciem SQLite i SQLAlchemy, a dodatkowo poznajesz podejście NoSQL na przykładzie MongoDB.

Moduł jest ułożony etapowo i praktycznie. W części SQL poznajesz kluczowe zagadnienia pracy z relacyjną bazą danych: projektowanie tabel i relacji, operacje CRUD, JOIN-y, agregacje, constraints, transakcje, widoki, indeksy, funkcje okna, CTE, triggery i procedury. Następnie wykorzystujesz tę wiedzę w projektach opartych o SQLite jako lekką bazę lokalną, a potem przechodzisz na SQLAlchemy jako komercyjny ORM. Uczysz się także zarządzania zmianami schematu bazy przez Alembic, budujesz warstwę repozytoriów do komunikacji aplikacji z bazą danych oraz rozszerzasz warsztat o podejście dokumentowe NoSQL (MongoDB). Całość rozwijasz z naciskiem na jakość: warstwa bazodanowa jest testowana również z użyciem Testcontainers.

To moduł, który realnie łączy backendowe podstawy danych z praktyką projektową: MySQL, SQL, SQLite, SQLAlchemy ORM, Alembic, MongoDB, NoSQL, Testcontainers, database migrations, repository pattern, transactional thinking, data integrity, scalable architecture. Dzięki temu Twoje aplikacje przestają opierać się wyłącznie na plikach i zaczynają działać jak profesjonalne systemy, przygotowane do pracy na większych zbiorach danych i realnych wymaganiach biznesowych.

Wybierz ten moduł jeśli:

• Chcesz opanować SQL od praktycznej strony i rozumieć relacyjne bazy danych na poziomie potrzebnym w pracy,
• Chcesz przejść płynnie od teorii do kodu — od MySQL do projektów z SQLite i SQLAlchemy,
• Zależy Ci na profesjonalnym podejściu do warstwy danych z migracjami (Alembic) i repozytoriami,
• Chcesz rozumieć różnicę między SQL i NoSQL oraz wiedzieć, kiedy użyć relacyjnej bazy, a kiedy podejścia dokumentowego,
• Chcesz tworzyć aplikacje bardziej skalowalne i niezawodne dzięki transakcjom, relacjom i kontroli integralności danych,
• Chcesz rozwijać projekty portfolio w kierunku komercyjnym i dodawać im pełną warstwę bazodanową.

Po ukończeniu modułu samodzielnie projektujesz i rozwijasz warstwę bazodanową aplikacji, świadomie dobierasz podejście SQL/ORM/NoSQL, wdrażasz migracje oraz tworzysz repozytoria wspierające czystą architekturę kodu. Potrafisz też testować komunikację z bazą danych w sposób zbliżony do środowiska produkcyjnego, również z wykorzystaniem Testcontainers. Co ważne, tę wiedzę od razu wykorzystujesz w kolejnych wspólnych projektach portfolio, które rozbudowujemy o realną komunikację z bazą danych.

To moduł, w którym budujesz interaktywne aplikacje webowe oparte o Python, przeznaczone do pracy z danymi i prezentacji wyników. Streamlit pozwala tworzyć dashboardy oraz proste interfejsy bez znajomości HTML/CSS/JavaScript.

W praktyce poznajesz cykl działania aplikacji Streamlit i uczysz się zarządzać stanem oraz powtarzalnymi obliczeniami. Następnie budujesz aplikacje jednoekranowe oraz wielostronicowe, projektujesz formularze i widoki filtrujące dane, a wyniki prezentujesz w postaci tabel i wykresów. Całość spinasz z warstwą logiki biznesowej lub repozytoriów, dzięki czemu interfejs jest integralną częścią aplikacji.

Moduł domykasz standardami jakości: przygotowujesz aplikację do uruchomienia w środowisku deweloperskim oraz do publikacji na docelowym hostingu w chmurze, a także pracujesz nad testowalnością interfejsu i poprawnym zachowaniem przy kontrolowanych danych wejściowych.

Co opanujesz w tym module?

• Podstawy Streamlit: zrozumienie działania aplikacji i cyklu uruchomienia skryptu.
• Konfiguracja i uruchomienie: przepływ uruchomienia, podstawowe ustawienia oraz organizacja kodu w projekcie.
• Elementy UI: komponenty interfejsu do wejścia danych, tabele i wykresy oraz czytelna struktura widoków.
• Aplikacje jednoekranowe i wielostronicowe: budowa prostego interfejsu oraz rozbudowa o kolejne widoki.
• Zarządzanie stanem i cache: utrzymanie danych między interakcjami oraz przyspieszanie powtarzalnych obliczeń.
• Interakcje z logiką biznesową: współpraca interfejsu z warstwą repozytoriów lub usług.
• Testowanie UI: weryfikacja zachowania interfejsu przy sterowanych danych wejściowych.
• Publikacja: przygotowanie aplikacji do wdrożenia w środowisku docelowym.

Wybierz ten moduł, jeśli:

• Chcesz szybko tworzyć aplikacje analityczne z czytelnym UI i wynikami w czasie rzeczywistym.
• Planujesz prezentować projekty portfolio jako działające aplikacje, a nie tylko notebooki.
• Potrzebujesz aplikacji wielostronicowych i rozbudowanych formularzy (filtry, wprowadzanie danych, kroki w UI).
• Chcesz mieć kontrolę nad kosztem obliczeń przez cache i świadome zarządzanie stanem.
• Dbasz o jakość i chcesz testować interfejs w sposób powtarzalny.

Po ukończeniu modułu potrafisz zbudować kompletną aplikację Streamlit: od podstaw i organizacji stron, przez zarządzanie stanem i cache, aż po integrację z warstwą logiki oraz testy UI. Dzięki temu Twoje projekty Data Science zaczynają wyglądać jak produktowe rozwiązania z interfejsem, który użytkownik rozumie i może użyć bez wsparcia technicznego.

To moduł, w którym wchodzisz w świat komunikacji zdarzeniowej i przetwarzania strumieniowego. Uczysz się, jak działa Apache Kafka i jak budować komunikację między komponentami aplikacji w sposób asynchroniczny: przez tematy, grupy konsumentów oraz kontrolę przetwarzania wiadomości.

Zaczynasz od fundamentów: architektury Kafki, podstawowych komend administracyjnych. Pracujesz na realistycznym zestawie usług: broker Kafka, rejestr schematów oraz panel do podglądu stanu systemu. Dzięki temu widzisz cały przepływ danych: od publikacji zdarzenia, przez serializację, aż po konsumpcję i obsługę błędów.

Następnie przechodzisz do komunikacji z poziomu Pythona w podejściu asynchronicznym. Budujesz producenta i konsumenta w sposób, który da się rozwijać komercyjnie: masz jasno zdefiniowane kontrakty wiadomości (schematy Avro w rejestrze schematów), walidację danych po stronie aplikacji oraz świadomą kontrolę przetwarzania (commit po stronie konsumenta). W przypadku błędów wdrażasz bezpieczny wzorzec obsługi problematycznych wiadomości (np. kierowanie do kolejki błędów), aby system był stabilny operacyjnie.

Moduł domykasz elementami jakości i utrzymania: automatyzujesz administrację (tworzenie/listowanie/usuwanie tematów), konfigurujesz środowisko przez zmienne środowiskowe oraz przygotowujesz testy asynchroniczne, które pozwalają weryfikować zachowanie komunikacji i przetwarzania bez ręcznego klikania.

Co opanujesz w tym module?

• Architektura Apache Kafka: tematy, partycje, grupy konsumentów, offsety i podstawy działania brokera.
• Konfiguracja i uruchomienie środowiska: Docker Compose, gotowy zestaw usług do pracy lokalnej oraz kontrola poprawnego startu.
• Narzędzia administracyjne i CLI: praca z tematami i diagnostyka, tak aby rozumieć, co dzieje się w klastrze.
• Komunikacja aplikacji Python z Kafka: producent i konsument w podejściu asynchronicznym, stabilne przetwarzanie wiadomości i kontrola potwierdzeń.
• Kontrakty wiadomości: schematy Avro + rejestr schematów, spójność danych i bezpieczna ewolucja formatu.
• Obsługa błędów i stabilność: walidacja danych, strategie obsługi niepoprawnych wiadomości oraz mechanizmy utrzymania systemu w ruchu.
• Automatyzacja administracji: zarządzanie tematami z poziomu aplikacji oraz sensowne uporządkowanie konfiguracji.
• Testy i jakość: testy asynchroniczne, kontrola powtarzalności oraz podstawy obserwowalności przez logi.

Wybierz ten moduł jeśli:

• Chcesz rozumieć komunikację zdarzeniową i stosować ją w praktycznych systemach.
• Budujesz aplikacje, które muszą przetwarzać dane asynchronicznie i zachować stabilność przy błędach.
• Zależy Ci na standardzie komercyjnym: kontrakty wiadomości, wersjonowanie, walidacja i testy.
• Chcesz mieć gotowy wzorzec producer/consumer, który później łatwo przeniesiesz do własnych projektów.

Po ukończeniu modułu potrafisz uruchomić i skonfigurować środowisko Kafka, zbudować komunikację aplikacji Python z brokerem w podejściu asynchronicznym oraz zadbać o spójność danych przez schematy i walidację. Masz również praktyczne wzorce obsługi błędów, administracji oraz testowania, które składają się na podejście produkcyjne.

To moduł projektowy, w którym budujesz kompletną aplikację webową w architekturze CQRS (Command Query Responsibility Segregation). W praktyce oznacza to, że rozdzielasz odpowiedzialności zapisu i odczytu: część odpowiedzialna za modyfikację danych działa niezależnie od części odpowiedzialnej za szybkie wyszukiwanie i prezentację wyników. Wymiana danych między tymi światami odbywa się przez Apache Kafka, dzięki czemu system jest skalowalny i odporny operacyjnie.

Po stronie zapisu budujesz usługę, która realizuje komendy, waliduje reguły domenowe i zapisuje dane w relacyjnej bazie. Jednocześnie wdrażasz podejście, które pozwala bezpiecznie publikować zdarzenia do Kafki bez ryzyka niespójności stanu (spójność zapisu i publikacji). Po stronie odczytu tworzysz usługę, która konsumuje zdarzenia, buduje zdenormalizowany model odczytu w bazie dokumentowej i udostępnia szybkie endpointy do pobierania danych bez kosztownych zapytań złożonych.

Cały projekt uruchamiasz jako spójny system w Docker Compose: broker Kafka z rejestrem schematów, bazy danych dla obu stron, cache dla mechanizmów niezawodności oraz reverse proxy, które kieruje ruch do właściwej usługi. Dzięki temu powstaje rozwiązanie, które wygląda jak realne wdrożenie: z monitoringiem infrastruktury, kontrolą startu usług i czytelną separacją odpowiedzialności.

Co opanujesz w tym module?

• CQRS end-to-end: rozdzielenie zapisu i odczytu, osobne modele danych i niezależne usługi.
• Integracja przez Kafka: publikacja zdarzeń po stronie zapisu oraz konsumpcja i budowanie projekcji po stronie odczytu.
• Relacyjna baza dla części zapisu: transakcje, migracje oraz modelowanie danych pod spójność i integralność.
• Dokumentowa baza dla części odczytu: model odczytu zoptymalizowany pod szybkie zapytania i filtrowanie.
• Niezawodność i bezpieczeństwo przetwarzania: idempotentność, kontrola duplikatów oraz odporność na błędy w przepływie zdarzeń.
• Uruchomienie i routing: kompletne środowisko w kontenerach oraz spójne API z rozdziałem na operacje odczytu i zapisu.

Wybierz ten moduł, jeśli:

• Chcesz zbudować system zgodny ze standardem wdrożeń produkcyjnych.
• Chcesz zrozumieć CQRS praktycznie i umieć uzasadnić, kiedy to podejście ma sens.
• Chcesz umieć spinać wiele komponentów w jeden, stabilny system: API, bazy danych, komunikację zdarzeniową i uruchomienie.

Po ukończeniu modułu masz działającą aplikację, która pokazuje pełny przepływ: komenda → zapis → zdarzenie → projekcja → szybki odczyt. To projekt, który buduje mocne portfolio, bo prezentuje zarówno inżynierię backendową, jak i praktyczne wzorce niezawodności w systemach opartych o zdarzenia.

To moduł, w którym uczysz się budować asynchroniczną komunikację między komponentami aplikacji z wykorzystaniem RabbitMQ. Zamiast łączyć usługi w sposób synchroniczny, wdrażasz podejście oparte o broker wiadomości: producent publikuje komunikaty, a konsument przetwarza je we własnym tempie. Dzięki temu system jest bardziej odporny na skoki obciążenia, awarie pojedynczych usług oraz naturalnie wspiera wzorzec kolejki zadań.

Zaczynasz od fundamentów architektury RabbitMQ: przepływu producer → exchange → binding → queue → consumer, zasad routingu oraz typowych topologii wymiany komunikatów. Następnie przechodzisz do konfiguracji środowiska uruchomieniowego (Docker, panel administracyjny, deklaratywne odtwarzanie konfiguracji) oraz do praktycznej implementacji komunikacji w Pythonie w podejściu asynchronicznym.

Duży nacisk kładziemy na elementy, które odróżniają rozwiązanie działające lokalnie od podejścia produkcyjnego: trwałość wiadomości, potwierdzenia po stronie producenta i konsumenta, kontrolę ponowień oraz bezpieczną obsługę komunikatów nieprzetwarzalnych. Dzięki temu poznajesz RabbitMQ jako narzędzie do budowy stabilnych procesów biznesowych, a nie tylko kolejkę do wysyłania komunikatów.

Co opanujesz w tym module?

• Architektura RabbitMQ: role exchange/queue/binding, podstawowe topologie i zasady routingu komunikatów.
• Routing i wzorce komunikacji: scenariusze 1:1, pub/sub oraz selekcja komunikatów po kluczu lub metadanych.
• Niezawodność przetwarzania: potwierdzenia, trwałość, kontrola at-least-once oraz świadome zarządzanie requeue.
• Obsługa błędów: strategie ponowień, opóźnienia, TTL oraz kolejki błędów oparte o mechanizm dead-letter.
• Konfiguracja i utrzymanie: uruchomienie w kontenerach, wygodna administracja, podstawy obserwowalności i diagnostyki.
• Integracja z Python: implementacja producenta i konsumenta w trybie asynchronicznym oraz uporządkowanie warstwy komunikacji w projekcie.

Wybierz ten moduł, jeśli:

• Budujesz system z mikrousługami lub zadaniami w tle i chcesz rozdzielić wysyłkę zadań od ich przetwarzania.
• Zależy Ci na odporności operacyjnej: buforowanie obciążenia, stabilna obsługa awarii i kontrola powtórzeń.
• Chcesz poznać praktyczne wzorce niezawodności w komunikacji asynchronicznej, w tym bezpieczną ścieżkę błędów.

Po ukończeniu modułu potrafisz zaprojektować topologię RabbitMQ pod konkretny przypadek, uruchomić środowisko lokalne oraz wdrożyć komunikację producent/konsument w Pythonie. Masz również sprawdzone wzorce na routing, potwierdzanie przetwarzania i obsługę błędów, które możesz bezpośrednio przenieść do projektów komercyjnych.