Kurs Python · Moduł 12: Projekt końcowy

Przygotowanie do Kariery

5 min czytania ·
W tej lekcji5

Gratulacje! Ukończyłeś Python Safari. Masz za sobą dwanaście lokacji, ale sam certyfikat jeszcze nikogo nie zatrudnił. Rekruter ma kilkadziesiąt sekund na Twoje CV, a na rozmowie technicznej padną pytania, które sprawdzą, czy rozumiesz to, co piszesz. Teraz czas zamienić zdobyte umiejętności w pierwszą pracę. Przygotujemy CV, profil LinkedIn, odpowiedzi na typowe pytania i listę miejsc, gdzie warto szukać ofert.

CV dla Python Developera

Dobre CV programisty jest krótkie i konkretne: dane kontaktowe z linkiem do GitHuba, jednozdaniowe podsumowanie, umiejętności pogrupowane w kategorie i projekty z wynikami. Oto szablon:

# Jan Kowalski
Python Developer | AI/ML Specialist

jan@example.com | linkedin.com/in/jan | github.com/jan

## Summary
Python developer z doświadczeniem w budowaniu aplikacji AI/ML.
Specjalizacja: RAG systems, FastAPI, Machine Learning.

## Skills

**Languages:** Python, JavaScript, SQL
**Frameworks:** FastAPI, Django, React
**AI/ML:** LlamaIndex, LangChain, PyTorch, scikit-learn
**Databases:** PostgreSQL, Qdrant, Redis
**Tools:** Docker, Git, GitHub Actions, AWS

## Projects

### AI Document Assistant | [GitHub](link) | [Demo](link)
- RAG system do przeszukiwania dokumentów
- Tech: FastAPI, LlamaIndex, Qdrant, OpenAI
- Wyniki: <2s response time, 92% accuracy

### ML Pipeline | [GitHub](link)
- End-to-end ML pipeline z MLflow
- Tech: scikit-learn, XGBoost, MLflow, Docker
- Wyniki: 15% improvement w accuracy

## Education

**Python Safari** - CodeWorlds (2024)
- 12-modułowy kurs Python i AI
- Capstone: AI Document Assistant

## Certifications
- [Nazwa certyfikatu]

Sekcja Projects jest ważniejsza niż Education, bo pokazuje, co zbudowałeś. Liczby w polach "Wyniki" to przykład formatu, nie gotowe wartości: wpisz tylko to, co naprawdę zmierzyłeś w swoim projekcie. Rekruter może o każdą liczbę zapytać na rozmowie. Na początku kariery trzymaj CV na jednej stronie i wysyłaj je jako PDF, żeby formatowanie nie rozjechało się po drugiej stronie.

LinkedIn Optimization

LinkedIn działa jak wyszukiwarka, rekruterzy szukają po słowach kluczowych w nagłówku i sekcji About. Nagłówek to nie tylko stanowisko, to lista technologii:

## Headline
Python Developer | AI/ML | FastAPI | Building intelligent applications

## About
Passionate Python developer specializing in AI applications.

RAG Systems & LLM Integration
FastAPI & Async Python
Machine Learning Pipelines

Currently building: AI Document Assistant - semantic search for documents.

Open to opportunities in AI/ML development.

## Featured
- Link do najlepszego projektu
- Artykuł/post o technologii
- Certyfikat/dyplom

Sekcja Featured to miejsce na link do najlepszego projektu. Jeden dobrze opisany projekt z demo mówi więcej niż lista dwudziestu technologii. Dodaj też link do GitHuba w danych kontaktowych, bo właśnie tam rekruter pójdzie szukać dowodów Twoich umiejętności.

Przygotowanie do Interview

Rozmowa techniczna dla Python developera zwykle obejmuje cztery obszary. Przejdźmy przez nie po kolei. Pierwszy to fundamenty języka, a klasyczne pytanie dotyczy GIL:

# Typowe pytania techniczne

# 1. Python fundamentals
def explain_gil():
    """
    GIL (Global Interpreter Lock) - mechanizm w CPython,
    który pozwala tylko jednemu wątkowi wykonywać
    bytecode Pythona w danym momencie.

    Rozwiązania:
    - multiprocessing dla CPU-bound
    - asyncio dla I/O-bound
    - alternatywne interpretery (PyPy)
    """
    pass

GIL (Global Interpreter Lock) w standardowym CPythonie pozwala tylko jednemu wątkowi naraz wykonywać bytecode Pythona. Wątki nie przyspieszą więc obliczeń na procesorze. Warto dodać, że od Pythona 3.13 istnieje osobny build free-threaded bez GIL (PEP 703), w 3.14 oficjalnie wspierany (PEP 779), ale wciąż opcjonalny. Drugi obszar to programowanie asynchroniczne:

# 2. Async Python
async def explain_async():
    """
    async/await - model współbieżności w Pythonie.
    - async def - definiuje coroutine
    - await - czeka na wynik async operacji
    - Idealne dla I/O-bound operations
    """
    pass

Moduł asyncio daje obsługę async/await. Zasada do zapamiętania: async/await dla operacji I/O-bound (sieć, baza, pliki), multiprocessing dla CPU-bound. Trzeci obszar to wzorce projektowe, które znasz z lekcji o architekturze:

# 3. Design Patterns
def explain_patterns():
    """
    Najważniejsze wzorce:
    - Repository Pattern - abstrakcja dostępu do danych
    - Dependency Injection - luźne powiązania
    - Factory Pattern - tworzenie obiektów
    - Observer Pattern - reaktywność
    """
    pass

Na rozmowie nie wystarczy nazwa wzorca, pokaż przykład z własnego projektu, na przykład DocumentRepository. Czwarty obszar to projektowanie systemu:

# 4. System Design
def design_rag_system():
    """
    Komponenty:
    1. API Gateway - routing, auth
    2. RAG Service - query processing
    3. Vector Database - embeddings storage
    4. LLM Service - text generation
    5. Cache - Redis for frequent queries
    6. Monitoring - Prometheus + Grafana
    """
    pass

To dokładnie architektura Twojego capstone projektu. Opowiedz, dlaczego wybrałeś każdy komponent, bo o to będą dopytywać.

Padną też pytania o narzędzia. Wirtualne środowisko tworzysz poleceniem python -m venv .venv, a aktywujesz na Linuksie i macOS przez source .venv/bin/activate. Plik requirements.txt zawiera listę zależności z wersjami. Pydantic w FastAPI waliduje dane i definiuje modele żądań oraz odpowiedzi. pytest domyślnie odkrywa pliki test_*.py oraz *_test.py.

Gdzie szukać pracy

Ostatni krok to wiedzieć, gdzie polować na oferty. Serwisy zmieniają się z czasem (GitHub Jobs i Stack Overflow Jobs już nie istnieją), więc traktuj tę listę jako punkt startu:

## Junior/Mid Python Developer

1. **LinkedIn Jobs** - najlepsze źródło
2. **NoFluffJobs** - polski rynek IT
3. **JustJoinIT** - startupy i korpo
4. **Bulldogjob** - polski portal z ofertami IT
5. **Wellfound** (dawniej AngelList Talent) - startupy, oferty międzynarodowe

## Freelance

1. **Upwork** - projekty długoterminowe
2. **Toptal** - premium, wymaga weryfikacji
3. **Fiverr** - mniejsze projekty

## Open Source

1. Contribute to projects you use
2. Build your reputation
3. Network with developers

Open source to często niedoceniana droga: kontrybucja do biblioteki, której używasz, to publiczny dowód umiejętności i kontakt z doświadczonymi programistami.

Następne kroki

Plan na najbliższe tygodnie jest prosty: ukończ Capstone Project, opublikuj go na GitHubie, zaktualizuj CV i LinkedIn, aplikuj na pozycje i kontynuuj naukę. Moja rada: nie czekaj, aż poczujesz się "gotowy". Aplikuj, gdy masz jeden porządny projekt, bo rozmowy same w sobie są najlepszym treningiem.

Pamiętaj: to nie koniec, to początek Twojej przygody z Pythonem, a każda kolejna ekspedycja zaczyna się od mapy, którą narysowałeś w tym module.

Kod do tej lekcji: main.py
# ===========================================
# Safari Capstone: Core Service Layer
# ===========================================
# Implement the core business logic service that
# manages wildlife operations and analytics.

from dataclasses import dataclass, field
from datetime import datetime
from typing import Optional
import json

# --- Models ---
@dataclass
class Animal:
    animal_id: str
    species: str
    name: str
    weight_kg: float
    region: str

@dataclass
class Observation:
    obs_id: str
    animal_id: str
    latitude: float
    longitude: float
    observer: str
    timestamp: str = ""

# --- Repository ---
class AnimalRepository:
    def __init__(self):
        self._data = {}

    def save(self, animal): self._data[animal.animal_id] = animal
    def get(self, aid): return self._data.get(aid)
    def get_all(self): return list(self._data.values())
    def delete(self, aid): return self._data.pop(aid, None) is not None
    def find_by_species(self, sp):
        return [a for a in self._data.values() if a.species.lower() == sp.lower()]

# --- Core Service ---
class SafariService:
    """Core business logic for the safari management system."""

    def __init__(self, repo: AnimalRepository):
        self.repo = repo
        self.observations: list[Observation] = []
        self._next_obs_id = 1

    def register_animal(self, species, name, weight_kg, region) -> Animal:
        """Register a new animal in the system."""
        prefix = species[:2].upper()
        count = len(self.repo.find_by_species(species)) + 1
        animal_id = f"{prefix}-{count:03d}"
        animal = Animal(animal_id, species, name, weight_kg, region)
        self.repo.save(animal)
        return animal

    def record_observation(self, animal_id, lat, lon, observer) -> Optional[Observation]:
        """Record a new wildlife observation."""
        animal = self.repo.get(animal_id)
        if not animal:
            return None
        obs = Observation(
            obs_id=f"OBS-{self._next_obs_id:04d}",
            animal_id=animal_id,
            latitude=lat,
            longitude=lon,
            observer=observer,
            timestamp=datetime.now().isoformat()
        )
        self.observations.append(obs)
        self._next_obs_id += 1
        return obs

    def get_species_stats(self) -> dict:
        """Get population statistics grouped by species."""
        stats = {}
        for animal in self.repo.get_all():
            species = animal.species
            if species not in stats:
                stats[species] = {"count": 0, "total_weight": 0.0, "regions": set()}
            stats[species]["count"] += 1
            stats[species]["total_weight"] += animal.weight_kg
            stats[species]["regions"].add(animal.region)
        # Convert sets to lists for JSON compatibility
        for sp in stats:
            stats[sp]["avg_weight"] = round(stats[sp]["total_weight"] / stats[sp]["count"], 1)
            stats[sp]["regions"] = list(stats[sp]["regions"])
        return stats

    def get_observation_count(self, animal_id: str) -> int:
        """Count observations for a specific animal."""
        return sum(1 for o in self.observations if o.animal_id == animal_id)

    def generate_report(self) -> str:
        """Generate a summary report of all wildlife data."""
        stats = self.get_species_stats()
        total_animals = self.repo.get_all()
        lines = [
            "=== Safari Wildlife Report ===",
            f"Total animals tracked: {len(total_animals)}",
            f"Total observations: {len(self.observations)}",
            f"Species tracked: {len(stats)}",
            ""
        ]
        for species, data in stats.items():
            lines.append(f"{species}: {data['count']} animals, "
                        f"avg {data['avg_weight']} kg, "
                        f"regions: {', '.join(data['regions'])}")
        return "\n".join(lines)

# --- Demo ---
repo = AnimalRepository()
service = SafariService(repo)

# Register animals
service.register_animal("Lion", "Simba", 195.0, "Savanna")
service.register_animal("Lion", "Nala", 130.0, "Savanna")
service.register_animal("Elephant", "Tembo", 5200.0, "Forest")
service.register_animal("Cheetah", "Duma", 52.0, "Grassland")

# Record observations
service.record_observation("LI-001", -2.33, 34.83, "Dr. Darwin")
service.record_observation("LI-001", -2.34, 34.84, "Dr. Darwin")
service.record_observation("EL-001", -2.41, 34.92, "Ranger Kate")

# Generate report
print(service.generate_report())
print(f"\nSimba observations: {service.get_observation_count('LI-001')}")
print(f"\nSpecies stats:")
print(json.dumps(service.get_species_stats(), indent=2))

# TODO: Add a method to find the most observed animal
# def most_observed_animal(self) -> Optional[str]:
#     counts = {}
#     for obs in self.observations:
#         counts[obs.animal_id] = counts.get(obs.animal_id, 0) + 1
#     if not counts:
#         return None
#     return max(counts, key=counts.get)

# TODO: Add data export functionality
# def export_data(self, format="json") -> str:
#     data = {
#         "animals": [vars(a) for a in self.repo.get_all()],
#         "observations": [vars(o) for o in self.observations],
#         "stats": self.get_species_stats()
#     }
#     return json.dumps(data, indent=2, default=str)

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Co to jest GIL (Global Interpreter Lock) w Pythonie?

  2. 2. Kiedy używać async/await zamiast multiprocessing?

To 2 z 5 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż elementy:

  • Klikanie w kolejności

    Kliknij w kolejności:

  • Edytor kodu

    Stwórz .github/workflows/ci.yml z krokami: checkout, setup-python, install, test.

  • Edytor kodu

    Zainicjuj projekt Capstone

  • Edytor kodu

    Stwórz rdzeń aplikacji

  • Edytor kodu

    Zaimplementuj warstwę API

  • Edytor kodu

    Dodaj testy do projektu

  1. PytanieGIL w Pythonie
  2. Ułóż w kolejnościPython venv
  3. Kliknij w kolejnościActivate venv
  4. Zadanie z kodemGitHub Actions CI
  5. PytanieAsync Python
  6. Zadanie z kodemCapstone: Project Setup
  7. Pytanierequirements.txt
  8. Zadanie z kodemCapstone: Core Service
  9. PytaniePydantic model
  10. Zadanie z kodemCapstone: API Layer
  11. PytaniePytest discovery
  12. Zadanie z kodemCapstone: Tests
  13. WideoCapstone Project - podsumowanie teorii
  14. Projekt do wysłaniaWyślij Capstone Project do mentora
  15. WideoPodsumowanie modułu

Przydatne artykuły