W opracowaniu będziemy posługiwali się językiem Python w wersji 3.

Wersja 2 oprogramowania została zdeprecjonowana i jest przestarzała.

Python jest zorientowanym obiektowo językiem programowania, który został stworzony na początku lat 90tych w Holandii. Autorem języka jest Guido van Rossum, który nazwał ten język na cześć swojego ulubionego serialu „Latający cyrk Monty Pythona” – Python.

Python jest językiem słabo typowanym, co oznacza, że typy generowane są dynamicznie, tak jak w PHP, a w przeciwieństwie do Javy. Do zarządzania pamięcią stosowany jest garbage collection.

Zobaczmy jak wygląda Python w rankingu Tiobe:

Dlaczego warto uczyć się Pythona?

1. Czytelność i prostota składni

Python został zaprojektowany z myślą o czytelności. Jego składnia przypomina naturalny język angielski i wykorzystuje wcięcia zamiast nawiasów klamrowych, co wymusza czytelne formatowanie kodu.

Filozofia Pythona (The Zen of Python):

• Beautiful is better than ugly
• Explicit is better than implicit
• Simple is better than complex
• Readability counts
• …

Możesz zobaczyć pełną listę zasad wpisując w Pythonie komendę import this

2. Wszechstronność zastosowań

Python jest wykorzystywany w niemal każdej dziedzinie informatyki:

Web Development:

• Django – pełnoprawny framework webowy (Instagram, Pinterest)
• Flask – mikroframework (Netflix, Reddit)
• FastAPI – nowoczesne API (Uber, Microsoft)

Data Science i Machine Learning:

• Pandas – analiza danych
• NumPy – obliczenia naukowe
• Scikit-learn – uczenie maszynowe
• TensorFlow, PyTorch – sztuczna inteligencja

Automatyzacja i DevOps:

• Automatyzacja testów (Selenium, pytest)
• Zarządzanie infrastrukturą (Ansible)
• Przetwarzanie danych
• Web scraping

Inne zastosowania:

• Gry komputerowe (Pygame)
• Aplikacje desktopowe (Tkinter, PyQt)
• Embedded systems (MicroPython, CircuitPython)
• Cybersecurity i penetration testing

3. Ogromna społeczność i ekosystem

PyPI (Python Package Index) zawiera ponad 450,000 pakietów gotowych do użycia. To największe repozytorium bibliotek programistycznych na świecie. Dla porównania, npm (Node.js) ma około 2 miliony pakietów, ale wiele z nich to duplikaty lub małe projekty.

Społeczność Pythona jest znana z przyjazności dla początkujących (friendly to beginners). Istnieje wiele miejsc, gdzie możesz uzyskać pomoc:

• Stack Overflow – tysiące odpowiedzi na pytania
• Reddit (r/learnpython) – społeczność pomocnych programistów
• Discord serwery dedykowane Pythonowi
• Lokalne spotkania Python User Groups (PUG)

4. Wysoka pozycja na rynku pracy

Według różnych rankingów i badań:

• TIOBE Index 2024 – Python jest na 1. miejscu
• Stack Overflow Survey 2023 – Python w top 3 najpopularniejszych języków
• GitHub Octoverse – Python na 2. miejscu najczęściej używanych języków

Średnie zarobki programistów Python w Polsce (2024):

• Junior: 6,000 – 10,000 PLN
• Mid: 12,000 – 18,000 PLN
• Senior: 18,000 – 30,000+ PLN

W branży Data Science i AI zarobki mogą być jeszcze wyższe.

5. Łatwy start, ale potężne możliwości

Python jest często pierwszym językiem programowania w szkołach i na uniwersytetach. Dlaczego?

• Nie wymaga deklarowania typów zmiennych
• Automatyczne zarządzanie pamięcią
• Prostsza składnia niż C++, Java czy JavaScript
• Natychmiastowe widzenie rezultatów (język interpretowany)
• Mnóstwo materiałów edukacyjnych dla początkujących

Mimo prostoty, Python jest używany w najpoważniejszych projektach:

• NASA używa Pythona w eksploracji kosmosu
• Google ma Pythona jako jeden z trzech oficjalnych języków
• Dropbox został napisany głównie w Pythonie
• Reddit, Instagram, Spotify – wszystkie używają Pythona

Charakterystyka języka Python

Język interpretowany

Python to język interpretowany, co oznacza, że kod jest wykonywany linia po linii przez interpreter, bez konieczności kompilacji do kodu maszynowego.

Dynamicznie typowany

W Pythonie nie musisz deklarować typów zmiennych. Interpreter sam rozpoznaje typ na podstawie przypisanej wartości.

W Javie (statyczne typowanie):

int x = 5;
String name = "Jan";

W Pythonie (dynamiczne typowanie):

x = 5
name = "Jan"

Python sam wie, że x to liczba całkowita, a name to tekst.

Wysokopoziomowy

Python abstrahuje wiele niskopoziomowych szczegółów:

• Nie musisz zarządzać pamięcią (garbage collector robi to za Ciebie)
• Nie musisz używać wskaźników
• Wbudowane struktury danych (listy, słowniki) są gotowe do użycia
• Operacje na plikach i sieciach są proste i intuicyjne

To pozwala skupić się na rozwiązaniu problemu, nie na technicznych detalach implementacji.

Obiektowy i proceduralny

Python wspiera wiele paradygmatów programowania:

• Programowanie proceduralne – funkcje i proste skrypty
• Programowanie obiektowe – klasy i obiekty
• Programowanie funkcyjne – funkcje pierwszej klasy, lambda

Możesz zacząć od prostych skryptów i stopniowo przechodzić do bardziej zaawansowanych konceptów.

Wieloplatformowy

Ten sam kod Pythona działa bez zmian na:

• Windows
• macOS
• Linux
• Raspberry Pi
• Wiele innych systemów Unix-like

Nie musisz kompilować kodu osobno dla każdego systemu operacyjnego.

Instalacja

Co zostanie zainstalowane:

• Interpreter Pythona (główny program wykonujący kod)
• Biblioteka standardowa (ponad 200 modułów wbudowanych)
• IDLE (prosty edytor i środowisko deweloperskie)
• pip (menedżer pakietów)
• Dokumentacja (opcjonalnie)

Aby pobrać najnowszą wersję języka wchodzimy na stronę https://www.python.org/downloads/

Na stronie automatycznie zostanie wykryta Twoja wersja Windows. Kliknij żółty przycisk „Download Python ….”.

Uruchom pobrany plik. Pojawi się okno instalatora. Pamiętaj zaznaczyć dodanie do PATH podczas instalacji!

☐ Add Python 3.12 to PATH

Zaznacz to pole! Jest to absolutnie kluczowe. Bez tego Python nie będzie dostępny z wiersza poleceń. (Jeżeli nie zaznaczyłeś musisz dodać ścieżkę ręcznie w zmiennych środowiskowych Windowsa)

Co to jest PATH? PATH to zmienna systemowa określająca, gdzie Windows szuka programów. Dodanie Pythona do PATH pozwala uruchamiać Python z dowolnego miejsca w systemie.

Sprawdź instalację: w terminalu lub w wierszu poleceń wpisz:

python --version

Powinieneś zobaczyć:

Python 3.12.0 #lub inną wersję

Jeśli widzisz numer wersji – gratulacje! Python jest zainstalowany poprawnie.

Sprawdzenie pip (pip to menedżer pakietów – będziesz go używać do instalowania dodatkowych bibliotek.)

W tym samym oknie wiersza poleceń wpisz:

pip --version

Powinieneś zobaczyć coś podobnego do:

pip 23.2.1 from C:\Users\...\Python312\site-packages\pip (python 3.12)

Edytory i środowiska deweloperskie (IDE)

Po zainstalowaniu Pythona potrzebujesz edytora kodu. Polecam Visual Studio Code. Doinstaluj wtyczki dla Python.

Do wyboru masz jeszcze IDE specjalnie dla Pythona, stworzone przez JetBrains – PyCharm.

Masz też do dyspozycji IDLE – prosty edytor instalowany razem z Pythonem (Windows: Menu Start > Python 3.12 > IDLE).

Porównanie edytorów

pip – Menedżer pakietów

pip (Pip Installs Packages) to standardowe narzędzie do instalowania bibliotek Pythona. Jest instalowane automatycznie razem z Pythonem.

Czym są pakiety?

Pakiety (packages) to gotowe biblioteki kodu napisane przez innych programistów. Zamiast pisać wszystko od zera, możesz użyć tysięcy gotowych rozwiązań.

Przykłady popularnych pakietów:

• requests – wysyłanie żądań HTTP (40+ milionów pobrań miesięcznie)
• pandas – analiza danych
• numpy – obliczenia naukowe
• django – framework webowy
• flask – mikroframework webowy
• pytest – testowanie kodu
• pillow – przetwarzanie obrazów
• beautifulsoup4 – web scraping

PyPI – Python Package Index

PyPI (https://pypi.org/) to repozytorium pakietów Pythona. Zawiera ponad 450,000 projektów.

Każdy może opublikować tam swoją bibliotekę. Gdy używasz pip, pobiera on pakiety właśnie z PyPI.

Podstawowe komendy pip

#Sprawdzenie wersji pip:
pip --version
#lub
pip3 --version

#Instalacja pakietu:
pip install nazwa_pakietu
#Przykład - instalacja biblioteki requests:
pip install requests

#Instalacja konkretnej wersji:
pip install nazwa_pakietu==1.2.3
#przykład
pip install django==4.2.0

#Aktualizacja pakietu:
pip install --upgrade nazwa_pakietu
#przykład
pip install --upgrade requests

#Odinstalowanie pakietu:
pip uninstall nazwa_pakietu
#przykład
pip uninstall requests

#Lista zainstalowanych pakietów:
pip list
#Zobaczysz wszystkie zainstalowane pakiety z ich wersjami:
#Package            Version
#------------------ --------
#pip                23.2.1
#setuptools         68.0.0
#requests           2.31.0

#Informacje o pakiecie:
pip show nazwa_pakietu
#przykład
pip show requests
"""Zobaczysz szczegóły:
Name: requests
Version: 2.31.0
Summary: Python HTTP for Humans.
Home-page: https://requests.readthedocs.io
Author: Kenneth Reitz
License: Apache 2.0
Location: ...
Requires: charset-normalizer, idna, urllib3, certifi"""

Środowiska wirtualne (Virtual Environments)

Środowiska wirtualne to jeden z najważniejszych konceptów w Pythonie. Zrozumienie ich jest kluczowe dla profesjonalnej pracy.

Problem bez środowisk wirtualnych

Wyobraź sobie sytuację:

• Pracujesz nad projektem A, który wymaga Django 3.2
• Zaczynasz nowy projekt B, który wymaga Django 4.2
• Instalujesz Django 4.2
• Projekt A przestaje działać, bo jego kod nie jest kompatybilny z Django 4.2

Inne problemy:

• Jeden projekt wymaga requests 2.25, inny requests 2.31
• Chcesz przetestować nową wersję biblioteki, ale nie chcesz zepsuć działających projektów
• Przesyłasz projekt komuś, ale ma zainstalowane inne wersje bibliotek

Rozwiązanie: izolowane środowiska

Środowisko wirtualne to izolowana instalacja Pythona dla konkretnego projektu. Każdy projekt ma:

• Własną kopię Pythona
• Własne zainstalowane pakiety
• Niezależność od innych projektów

Analogia: To jak mieć osobne szafki na narzędzia dla różnych projektów. Każda szafka ma narzędzia potrzebne tylko dla jednego projektu.

venv – tworzenie środowiska wirtualnego

venv to wbudowany moduł Pythona do tworzenia środowisk wirtualnych. Jest dostępny od Python 3.3.

Windows – krok po kroku

1. Otwórz wiersz poleceń w folderze projektu

Załóżmy, że chcesz utworzyć projekt w folderze C:\projekty\moj_projekt

cd C:\projekty\moj_projekt

2. Utwórz środowisko wirtualne

python -m venv venv

Rozbijmy tę komendę:

• python -m venv – uruchom moduł venv
• venv – nazwa folderu dla środowiska (może być dowolna, ale konwencja to „venv”)

Ta komenda stworzy folder venv z całym środowiskiem wirtualnym.

3. Aktywuj środowisko

venv\Scripts\activate

Po aktywacji zobaczysz (venv) przed ścieżką:

(venv) C:\projekty\moj_projekt>

To oznacza, że środowisko jest aktywne.

4. Zainstaluj pakiety w środowisku

Teraz wszystko co zainstalujesz, zostanie zainstalowane tylko w tym środowisku:

pip install flask

Flask zostanie zainstalowany tylko w tym projekcie, nie globalnie.

5. Pracuj nad projektem

Możesz teraz pisać kod, uruchamiać skrypty. Wszystko będzie używać Pythona i pakietów z tego środowiska.

6. Dezaktywuj środowisko

Gdy skończysz pracę:

deactivate

(venv) zniknie ze ścieżki. Wrócisz do globalnego Pythona.

Praktyczny przykład – projekt Flask

Stwórzmy kompletny projekt Flask od zera, krok po kroku.

1. Utwórz folder projektu

mkdir moja_aplikacja_flask
cd moja_aplikacja_flask

2. Utwórz środowisko wirtualne

python -m venv venv

3. Aktywuj środowisko

Windows: venv\Scripts\activate Linux/Mac: source venv/bin/activate

4. Zainstaluj Flask

pip install flask

5. Sprawdź zainstalowane pakiety

pip list

Zobaczysz:

Package      Version
------------ -------
blinker      1.6.2
click        8.1.7
Flask        3.0.0
itsdangerous 2.1.2
Jinja2       3.1.2
...

Flask automatycznie zainstalował swoje zależności.

6. Zapisz zależności

pip freeze > requirements.txt

7. Utwórz plik app.py

Teraz możesz utworzyć plik Pythona i zacząć programować.

8. Po zakończeniu pracy

deactivate

Nazwa środowiska – konwencje

Najpopularniejsze nazwy dla środowisk wirtualnych:

• venv – najczęstsza konwencja
• env – krótsza alternatywa
• .venv – ukryty folder (zaczyna się od kropki)
• virtualenv – starsza konwencja

Zalecenie: Używaj venv – jest to standard w społeczności Pythona.

Co zawiera folder venv?

Po utworzeniu venv, w folderze znajdziesz:

venv/
├── Include/
├── Lib/
│   └── site-packages/    # Tu są instalowane pakiety
├── Scripts/
│   ├── activate          # Skrypt aktywacyjny
│   ├── activate.bat
│   ├── python.exe        # Kopia Pythona
│   └── pip.exe           # pip dla tego środowiska
└── pyvenv.cfg            # Konfiguracja

.gitignore i środowiska wirtualne

Bardzo ważne: Nigdy nie commituj folderu venv do Git!

Folder venv zawiera:

• Tysiące plików
• Binarki specyficzne dla systemu operacyjnego
• Setki megabajtów danych

Zamiast tego:

• Commituj requirements.txt
• Dodaj venv/ do .gitignore
• Inni developerzy stworzą własne środowisko z requirements.txt

Przykładowy .gitignore dla Pythona:

# Virtual Environment
venv/
env/
ENV/
.venv

# Python cache
__pycache__/
*.py[cod]
*$py.class

# Distribution / packaging
dist/
build/
*.egg-info/

# IDE
.vscode/
.idea/
*.swp

# Environment variables
.env

# Database
*.db
*.sqlite3

# OS
.DS_Store
Thumbs.db

Kiedy tworzyć nowe środowisko?

Utwórz nowe środowisko wirtualne dla:

• Każdego nowego projektu
• Testowania nowej wersji biblioteki
• Projektu, który wymaga różnych wersji pakietów niż inne projekty
• Eksperymentowania z kodem (żeby nie psuć głównego środowiska)

Nie twórz nowego środowiska gdy:

• Pracujesz nad tym samym projektem na innym branchu Git (użyj tego samego venv)
• Piszesz prosty skrypt testowy (chyba że wymaga specjalnych pakietów)

Kompilator, interpreter, debugger

1. Jak komputer „rozumie” nasz kod?

Komputer rozumie tylko język maszynowy (zera i jedynki). Kod, który piszemy (np. w Pythonie), musi zostać w jakiś sposób przetłumaczony na instrukcje zrozumiałe dla procesora. Do tego służą kompilatory i interpretery.

2. Kompilator

Kompilator to program, który tłumaczy CAŁY kod źródłowy na kod maszynowy (lub inny język niższego poziomu) jeszcze przed uruchomieniem programu. Powstaje plik wykonywalny (np. .exe), który można uruchamiać wielokrotnie bez ponownego tłumaczenia.

Cechy:

• Tłumaczenie odbywa się jednorazowo, „z góry” (ahead-of-time).
• Błędy wykrywane są przed uruchomieniem programu (na etapie kompilacji).
• Gotowy program zwykle działa szybciej.
• Przykłady języków kompilowanych: C, C++, Rust, Go.

Analogia: Kompilator jest jak tłumacz, który tłumaczy całą książkę na inny język, zanim ktokolwiek zacznie ją czytać.

3. Interpreter

Interpreter to program, który tłumaczy i wykonuje kod linia po linii, w trakcie działania programu — nie tworzy osobnego pliku wykonywalnego.

Cechy:

• Tłumaczenie i wykonanie dzieje się „na żywo”.
• Błędy wykrywane są dopiero wtedy, gdy interpreter dojdzie do danej linijki.
• Łatwiej testować i modyfikować kod (nie trzeba go kompilować od nowa).
• Programy działają zazwyczaj wolniej niż skompilowane.
• Przykłady języków interpretowanych: Python, JavaScript, Ruby, PHP.

Analogia: Interpreter jest jak tłumacz symultaniczny — tłumaczy zdanie po zdaniu, na bieżąco, w trakcie wystąpienia mówcy.

4. Jak to wygląda w Pythonie?

Python jest językiem interpretowanym, choć w praktyce jest to trochę bardziej złożone:

1. Kod źródłowy (.py) jest najpierw tłumaczony na tzw. bytecode (plik .pyc) — to pośredni etap, coś między kompilacją a interpretacją.
2. Bytecode jest następnie wykonywany przez wirtualną maszynę Pythona (PVM – Python Virtual Machine), czyli interpreter.

Dlatego mówi się, że Python jest „kompilowany do bytecode’u, a potem interpretowany”.

Najpopularniejsza implementacja Pythona to CPython — to właśnie ją najczęściej mamy na komputerze, gdy piszemy python w terminalu.

Krótkie porównanie

5. Debugger (debugger/debuger)

Debugger to narzędzie, które pomaga znaleźć błędy (tzw. bugi) w kodzie poprzez śledzenie jego działania krok po kroku.

Do czego służy?

• Zatrzymywanie programu w wybranym miejscu (breakpoint, czyli „pułapka”).
• Podgląd wartości zmiennych w danym momencie działania programu.
• Wykonywanie kodu linia po linii (step by step).
• Sprawdzanie, którędy „przechodzi” program (np. czy wchodzi do danego if).

Podstawowe pojęcia

• Breakpoint – punkt, w którym program się zatrzymuje.
• Step over – wykonaj bieżącą linię i przejdź do następnej (bez wchodzenia do funkcji).
• Step into – wejdź do środka wywoływanej funkcji.
• Step out – wyjdź z bieżącej funkcji do miejsca, które ją wywołało.
• Watch – obserwowanie wartości konkretnej zmiennej.

Debugger w Pythonie

1. Wbudowany moduł pdb:

import pdb

x = 5
y = 0
pdb.set_trace()  # program zatrzyma się w tym miejscu
wynik = x / y
print(wynik)

Po zatrzymaniu w konsoli można wpisywać komendy:

• n (next) – następna linia
• s (step) – wejdź do funkcji
• c (continue) – kontynuuj do następnego breakpointu
• p zmienna (print) – wypisz wartość zmiennej
• q (quit) – zakończ debugowanie

2. Debugger w edytorze (np. VS Code, PyCharm):

• klikamy obok numeru linii, by ustawić breakpoint (czerwona kropka),
• uruchamiamy program w trybie „Debug” (nie „Run”),
• program zatrzymuje się na breakpoincie, a my widzimy wartości zmiennych w panelu bocznym.

6. Podsumowanie

• Kompilator – tłumaczy cały kod na raz, przed uruchomieniem (np. C++).
• Interpreter – tłumaczy i wykonuje kod na bieżąco, linia po linii (np. Python).
• Python w praktyce łączy oba podejścia: kod → bytecode → wykonanie przez interpreter (PVM).
• Debugger – narzędzie do „podglądania” działania programu i wyszukiwania błędów krok po kroku.

7. Pytania kontrolne (do sprawdzenia zrozumienia)

1. Czym różni się kompilator od interpretera?
2. Czy Python jest językiem kompilowanym, czy interpretowanym? Uzasadnij.
3. Co to jest bytecode?
4. Do czego służy breakpoint w debuggerze?
5. Jaka jest różnica między step over a step into?