Zarządzanie wersjami kodu w Pythonie to jedna z podstawowych umiejętności każdego programisty. Git pozwala śledzić zmiany w projekcie, bezpiecznie eksperymentować, wracać do wcześniejszych wersji kodu i współpracować z innymi osobami bez chaosu w plikach.

Nawet jeśli tworzysz mały skrypt w Pythonie, Git szybko zaczyna się przydawać. Możesz sprawdzić, co zmieniło się od ostatniej wersji, zapisać działający etap projektu, utworzyć osobną gałąź na nową funkcję albo cofnąć błąd bez ręcznego kopiowania plików typu projekt_final_final2.py.

W tym artykule poznasz podstawy Git w projektach Pythonowych: inicjalizację repozytorium, najważniejsze komendy, pracę na branchach, plik .gitignore, dobre praktyki commitowania oraz przykładowy workflow dla projektu Python.

Dlaczego Git jest ważny w projektach Pythonowych?

Git to system kontroli wersji, który zapisuje historię zmian w plikach. Dzięki temu możesz zobaczyć, kiedy dana zmiana została wprowadzona, kto ją dodał i dlaczego.

W projektach Pythonowych Git pomaga szczególnie wtedy, gdy:

• rozwijasz aplikację krok po kroku,
• testujesz nowe rozwiązania,
• pracujesz z plikami konfiguracyjnymi,
• używasz środowisk wirtualnych,
• tworzysz skrypty automatyzujące,
• współpracujesz z innymi programistami,
• chcesz wrócić do poprzedniej wersji kodu,
• publikujesz projekt na GitHubie, GitLabie lub Bitbucket.

Bez Gita łatwo stracić kontrolę nad zmianami. Wystarczy kilka poprawek, kilka kopii plików i szybko nie wiadomo, która wersja działa. Git rozwiązuje ten problem, bo każda istotna zmiana może zostać zapisana jako commit.

Jak działa Git?

Git działa lokalnie na Twoim komputerze. Repozytorium to folder projektu, w którym Git zapisuje historię zmian. Najważniejsze pojęcia to:

• working directory — katalog roboczy, w którym edytujesz pliki,
• staging area — miejsce, do którego dodajesz zmiany przed commitem,
• commit — zapisany punkt w historii projektu,
• branch — osobna linia rozwoju kodu,
• remote repository — repozytorium zdalne, np. na GitHubie.

Typowy proces wygląda tak:

1. Edytujesz pliki.
2. Sprawdzasz zmiany.
3. Dodajesz wybrane pliki do staging area.
4. Tworzysz commit.
5. Wysyłasz zmiany do repozytorium zdalnego.

Inicjalizacja repozytorium Git

Jeśli masz lokalny projekt Python, możesz rozpocząć pracę z Gitem komendą:

Bash
Kopiuj
1
git init

Ta komenda tworzy ukryty katalog .git, w którym Git przechowuje historię projektu.

Przykład:

Bash
Kopiuj
1
2
3
mkdir moj-projekt-python
cd moj-projekt-python
git init

Następnie możesz dodać pierwsze pliki:

Bash
Kopiuj
1
2
touch main.py README.md
git status

Komenda git status pokaże, które pliki są nowe, zmienione albo gotowe do commita.

Klonowanie istniejącego repozytorium

Jeśli projekt istnieje już w repozytorium zdalnym, np. na GitHubie, użyj komendy git clone.

Bash
Kopiuj
1
git clone https://github.com/user/projekt-python.git

Po sklonowaniu repozytorium przejdź do folderu projektu:

Bash
Kopiuj
1
cd projekt-python

Od tego momentu masz lokalną kopię projektu wraz z historią zmian.

Podstawowe komendy Git

Najważniejsze komendy Git warto znać od początku. Używa się ich w niemal każdym projekcie.

git status

Pokazuje aktualny stan repozytorium.

Bash
Kopiuj
1
git status

Dzięki tej komendzie sprawdzisz, które pliki zostały zmienione, które są nowe i które czekają na commit.

git add

Dodaje zmiany do staging area.

Bash
Kopiuj
1
git add main.py

Możesz też dodać wszystkie zmiany:

Bash
Kopiuj
1
git add .

Warto uważać z git add ., szczególnie gdy w projekcie znajdują się pliki tymczasowe, dane lokalne albo sekrety. Dlatego ważny jest dobrze przygotowany .gitignore.

git commit

Zapisuje zmiany w historii repozytorium.

Bash
Kopiuj
1
git commit -m "Dodaj podstawowy skrypt aplikacji"

Dobry commit powinien opisywać konkretną zmianę. Zamiast pisać poprawki, lepiej napisać Dodaj walidację adresu email albo Napraw obsługę pustego pliku CSV.

git log

Pokazuje historię commitów.

Bash
Kopiuj
1
git log

Wygodniejsza, skrócona wersja:

Bash
Kopiuj
1
git log --oneline

git diff

Pokazuje różnice między aktualnym kodem a ostatnim commitem.

Bash
Kopiuj
1
git diff

To jedna z najważniejszych komend przed wykonaniem commita. Pozwala sprawdzić, czy zapisujesz dokładnie te zmiany, które chcesz.

git push

Wysyła lokalne commity do repozytorium zdalnego.

Bash
Kopiuj
1
git push origin main

git pull

Pobiera zmiany z repozytorium zdalnego i aktualizuje lokalny projekt.

Bash
Kopiuj
1
git pull origin main

Przed rozpoczęciem pracy w zespole warto wykonać git pull, aby pracować na aktualnej wersji kodu.

Przykładowy workflow Git w projekcie Python

Typowy przepływ pracy może wyglądać tak:

Bash
Kopiuj
1
2
3
git status
git pull origin main
git checkout -b feature/import-csv

Następnie edytujesz kod, np. dodajesz funkcję importu pliku CSV w Pythonie:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import csv

def read_users_from_csv(file_path: str) -> list[dict]:
    users = []

    with open(file_path, mode="r", encoding="utf-8") as file:
        reader = csv.DictReader(file)

        for row in reader:
            users.append({
                "name": row["name"],
                "email": row["email"]
            })

    return users

Po zakończeniu pracy sprawdzasz zmiany:

Bash
Kopiuj
1
2
git status
git diff

Dodajesz pliki i tworzysz commit:

Bash
Kopiuj
1
2
git add main.py
git commit -m "Dodaj import użytkowników z pliku CSV"

Na końcu wysyłasz gałąź do repozytorium zdalnego:

Bash
Kopiuj
1
git push origin feature/import-csv

Taki workflow ułatwia pracę zespołową i pozwala oddzielić nowe funkcje od stabilnej wersji projektu.

Branch, czyli gałęzie w Git

Branch to osobna linia rozwoju projektu. Dzięki gałęziom możesz pracować nad nową funkcją bez ryzyka uszkodzenia głównej wersji kodu.

Utworzenie nowej gałęzi:

Bash
Kopiuj
1
git checkout -b feature/new-report

Sprawdzenie dostępnych gałęzi:

Bash
Kopiuj
1
git branch

Przełączenie na gałąź main:

Bash
Kopiuj
1
git checkout main

Scalenie zmian z innej gałęzi:

Bash
Kopiuj
1
git merge feature/new-report

W praktyce warto tworzyć osobne branche dla:

• nowych funkcji,
• poprawek błędów,
• eksperymentów,
• refaktoryzacji,
• zmian w konfiguracji.

Przykładowe nazwy branchy:

Bash
Kopiuj
1
2
3
4
feature/export-to-excel
bugfix/fix-login-error
refactor/split-services
docs/update-readme

Dobre nazwy branchy pomagają zrozumieć, nad czym pracujesz.

.gitignore w projekcie Python

Plik .gitignore mówi Gitowi, których plików nie powinien śledzić. W projektach Pythonowych jest szczególnie ważny, bo łatwo przypadkowo dodać pliki tymczasowe, cache, środowisko wirtualne lub dane lokalne.

Przykładowy .gitignore dla projektu Python:

GITIGNORE
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# Python cache
__pycache__/
*.py[cod]
*.pyo

# Virtual environments
venv/
.env/
.venv/

# Environment variables
.env
.env.local

# Logs
*.log
logs/

# Test and coverage
.pytest_cache/
.coverage
htmlcov/

# Build files
build/
dist/
*.egg-info/

# IDE
.vscode/
.idea/

# Local data
data/
*.sqlite3
*.db

Dzięki .gitignore repozytorium pozostaje czyste. Nie przechowujesz w nim plików, które można odtworzyć albo które powinny zostać tylko lokalnie.

Git i środowisko wirtualne Python

W projektach Pythonowych często używa się środowiska wirtualnego, np. venv. Nie należy dodawać całego folderu venv do repozytorium. Zamiast tego zapisuje się listę zależności w pliku requirements.txt.

Utworzenie środowiska:

Bash
Kopiuj
1
python -m venv venv

Aktywacja w systemie Linux lub macOS:

Bash
Kopiuj
1
source venv/bin/activate

Aktywacja w Windows:

Bash
Kopiuj
1
venv\Scripts\activate

Instalacja bibliotek:

Bash
Kopiuj
1
pip install requests pandas

Zapis zależności:

Bash
Kopiuj
1
pip freeze > requirements.txt

Instalacja zależności na innym komputerze:

Bash
Kopiuj
1
pip install -r requirements.txt

Do repozytorium dodajesz requirements.txt, ale nie dodajesz folderu venv.

Dobre wiadomości commitów

Commit powinien być mały, konkretny i opisowy. Dzięki temu historia projektu jest czytelna, a cofanie zmian łatwiejsze.

Słabe wiadomości commitów:

Bash
Kopiuj
1
2
3
git commit -m "zmiany"
git commit -m "poprawki"
git commit -m "update"

Lepsze wiadomości:

Bash
Kopiuj
1
2
3
4
git commit -m "Dodaj obsługę plików CSV"
git commit -m "Napraw walidację pustego formularza"
git commit -m "Zaktualizuj instrukcję instalacji w README"
git commit -m "Dodaj testy dla funkcji calculate_total"

Dobra zasada: commit powinien odpowiadać na pytanie „co zostało zmienione?”.

Cofanie zmian w Git

Git pozwala bezpiecznie cofać zmiany, ale warto rozumieć, której komendy używasz.

Cofnięcie zmian w pliku przed commitem:

Bash
Kopiuj
1
git checkout -- main.py

W nowszych wersjach Gita można użyć:

Bash
Kopiuj
1
git restore main.py

Usunięcie pliku ze staging area:

Bash
Kopiuj
1
git restore --staged main.py

Cofnięcie ostatniego commita, ale pozostawienie zmian w plikach:

Bash
Kopiuj
1
git reset --soft HEAD~1

Utworzenie nowego commita odwracającego wcześniejszą zmianę:

Bash
Kopiuj
1
git revert <commit-hash>

W pracy zespołowej często bezpieczniejsze jest git revert, bo nie przepisuje historii repozytorium.

GitHub i zdalne repozytorium

Git działa lokalnie, ale najczęściej łączy się go z platformą taką jak GitHub, GitLab lub Bitbucket. Zdalne repozytorium ułatwia backup, współpracę i code review.

Dodanie repozytorium zdalnego:

Bash
Kopiuj
1
git remote add origin https://github.com/user/projekt-python.git

Wysłanie pierwszej wersji kodu:

Bash
Kopiuj
1
git push -u origin main

Sprawdzenie zdalnych repozytoriów:

Bash
Kopiuj
1
git remote -v

W projektach zespołowych zmiany często trafiają najpierw do pull requesta lub merge requesta. To miejsce, w którym inni programiści mogą sprawdzić kod przed scaleniem go z gałęzią główną.

README.md w projekcie Python

Plik README.md jest wizytówką projektu. Powinien wyjaśniać, do czego służy projekt, jak go uruchomić i jak zainstalować zależności.

Przykładowa struktura README:

Markdown
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Nazwa projektu

Krótki opis projektu Python.

## Wymagania

- Python 3.11+
- pip

## Instalacja

```bash
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

Uruchomienie

Bash
Kopiuj
1
python main.py

Testy

Bash
Kopiuj
1
pytest

Dobrze napisany README oszczędza czas Tobie i innym osobom, które będą korzystać z projektu.

## Git hooks w projektach Python

Git hooks to skrypty uruchamiane automatycznie przy określonych akcjach, np. przed commitem. Możesz ich używać do formatowania kodu, uruchamiania testów lub sprawdzania jakości.

Popularnym narzędziem jest `pre-commit`.

Instalacja:

```bash
pip install pre-commit

Przykładowy plik .pre-commit-config.yaml:

YAML
Kopiuj
1
2
3
4
5
6
7
8
9
10
repos:
  - repo: https://github.com/psf/black
    rev: 24.3.0
    hooks:
      - id: black

  - repo: https://github.com/pycqa/flake8
    rev: 7.0.0
    hooks:
      - id: flake8

Aktywacja:

Bash
Kopiuj
1
pre-commit install

Dzięki temu przed commitem możesz automatycznie formatować kod i wykrywać podstawowe problemy.

Najlepsze praktyki Git w Pythonie

Dobre zarządzanie wersjami kodu nie polega tylko na znajomości komend. Ważny jest też porządek pracy.

Najważniejsze praktyki:

• twórz małe i opisowe commity,
• sprawdzaj git diff przed commitem,
• nie dodawaj do repozytorium plików .env,
• nie commituj folderu venv,
• używaj .gitignore,
• pracuj na osobnych branchach,
• regularnie pobieraj zmiany przez git pull,
• zapisuj zależności w requirements.txt lub pyproject.toml,
• aktualizuj README.md,
• nie przechowuj haseł i tokenów w repozytorium,
• używaj pull requestów w pracy zespołowej,
• przed scaleniem uruchamiaj testy.

Te zasady pomagają uniknąć bałaganu, konfliktów i przypadkowego ujawnienia danych dostępowych.

Podsumowanie

Zarządzanie wersjami kodu w Pythonie z użyciem Git pozwala pracować bezpieczniej, czyściej i bardziej przewidywalnie. Git zapisuje historię zmian, ułatwia współpracę, pomaga cofać błędy i pozwala rozwijać nowe funkcje na osobnych branchach.

Najważniejsze komendy na start to git init, git clone, git status, git add, git commit, git pull, git push, git branch i git merge. W projektach Pythonowych szczególnie ważne są też pliki .gitignore, README.md oraz requirements.txt.

Jeśli dopiero zaczynasz, utwórz mały projekt Python, zainicjalizuj repozytorium, dodaj .gitignore, wykonaj pierwszy commit i opublikuj kod w repozytorium zdalnym. To prosty krok, który od razu uporządkuje Twoją pracę z kodem.