Představ si, že máš za úkol sníst obrovského slona. To zní nemožně, že? Ale co kdyby sis ho rozdělil na malé kousky a každý den snědl jen jeden? Najednou se úkol zdá mnohem jednodušší. V životě i v informatice je to stejné. Když stojíme před velkým a složitým problémem, nejlepší způsob, jak ho vyřešit, je rozdělit si ho na menší, zvládnutelné části.
Rozdělení problému na části znamená, že velký a složitý úkol si rozkouskujeme na několik menších a jednodušších úkolů. Každý z těchto malých úkolů pak můžeme vyřešit samostatně.
Dekompozice je odborný název pro rozdělení složitého problému na menší, jednodušší a lépe zvládnutelné části.
Rozdělení problému nám pomáhá:
Když si problém rozdělíme na části, často si všimneme, že některé kroky se opakují. Tomu říkáme opakující se vzory.
Někdy náš postup není úplně přímý. Musíme se rozhodnout, co udělat dál, na základě nějaké podmínky. Tomu říkáme místo pro rozhodování nebo větvení.
Pojďme si to ukázat na příkladu z tvého oboru.
Právě jsi se naučil důležitou dovednost, kterou používají všichni programátoři! Když chceme vytvořit počítačový program nebo hru, musíme velký problém rozdělit na malé části.
Velký problém: Vytvořit hru, kde hráč ovládá postavu, sbírá předměty a získává body.
Rozdělení na menší části:
Výhoda tohoto přístupu:
Schopnost rozdělit velký problém na menší části je jednou z nejdůležitějších dovedností v digitálním světě. Pomáhá nám nejen při programování, ale i při řešení každodenních úkolů. Učí nás přemýšlet systematicky, plánovat a nenechat se odradit složitostí. Tato dovednost je klíčová pro efektivní práci s digitálními nástroji a pro úspěšné řešení problémů v jakémkoli oboru.
V profesionální praxi se dekompozice používá na mnoha úrovních:
Abstrakce je proces skrytí složitosti za jednoduché rozhraní. Například: tlačítko "Odeslat" skrývá složitý proces přenosu dat.
Divide and Conquer (Rozděl a panuj) je algoritmická strategie:
Příklady: Merge Sort, Quick Sort, binární vyhledávání.
Opakující se kód by měl být extrahován do funkce. Výhody:
Jako IT specialista budeš navrhovat software pomocí modulů a tříd. Naučíš se principy objektově orientovaného programování.
# matematika.py - vlastní modul
def secti(a, b):
return a + b
def odecti(a, b):
return a - b
def faktorial(n):
if n <= 1:
return 1
return n * faktorial(n - 1)
PI = 3.14159
# hlavni.py - použití modulu
import matematika
from matematika import faktorial, PI
print(matematika.secti(5, 3))
print(faktorial(5))
print(PI)
class Student:
"""Třída reprezentující studenta."""
def __init__(self, jmeno, vek):
"""Konstruktor - inicializace objektu."""
self.jmeno = jmeno
self.vek = vek
self.znamky = []
def pridej_znamku(self, znamka):
"""Přidá známku studentovi."""
if 1 <= znamka <= 5:
self.znamky.append(znamka)
def prumer(self):
"""Vypočítá průměr známek."""
if not self.znamky:
return 0
return sum(self.znamky) / len(self.znamky)
def __str__(self):
"""Reprezentace objektu jako text."""
return f"{self.jmeno} ({self.vek} let), průměr: {self.prumer():.2f}"
# Použití
jan = Student("Jan Novák", 15)
jan.pridej_znamku(1)
jan.pridej_znamku(2)
jan.pridej_znamku(1)
print(jan) # Jan Novák (15 let), průměr: 1.33
class Osoba:
"""Základní třída pro osoby."""
def __init__(self, jmeno, vek):
self.jmeno = jmeno
self.vek = vek
def predstav_se(self):
return f"Jmenuji se {self.jmeno}"
class Student(Osoba):
"""Student dědí od Osoba."""
def __init__(self, jmeno, vek, trida):
super().__init__(jmeno, vek) # Zavolej konstruktor rodiče
self.trida = trida
def predstav_se(self):
return f"{super().predstav_se()}, chodím do {self.trida}"
class Ucitel(Osoba):
"""Učitel dědí od Osoba."""
def __init__(self, jmeno, vek, predmet):
super().__init__(jmeno, vek)
self.predmet = predmet
def predstav_se(self):
return f"{super().predstav_se()}, učím {self.predmet}"
# Použití
student = Student("Jan", 15, "9.A")
ucitel = Ucitel("Mgr. Nováková", 35, "matematiku")
print(student.predstav_se()) # Jmenuji se Jan, chodím do 9.A
print(ucitel.predstav_se()) # Jmenuji se Mgr. Nováková, učím matematiku
muj_projekt/
├── main.py # Hlavní soubor
├── requirements.txt # Závislosti
├── README.md # Dokumentace
├── models/ # Datové modely
│ ├── __init__.py
│ ├── student.py
│ └── ucitel.py
├── utils/ # Pomocné funkce
│ ├── __init__.py
│ └── validators.py
├── tests/ # Testy
│ ├── test_student.py
│ └── test_ucitel.py
└── data/ # Data
└── studenti.csv
V kapitolách 10-13 vytvoříš kompletní aplikaci Správce kontaktů. Naučíš se správnou strukturu projektu, verzování v Gitu a psaní dokumentace.
Aplikace umožní:
# 1. Vytvoř složku projektu
mkdir spravce-kontaktu
cd spravce-kontaktu
# 2. Inicializuj Git
git init
# 3. Vytvoř základní strukturu
mkdir models
mkdir utils
mkdir tests
# 4. Vytvoř prázdné __init__.py (označí složky jako Python moduly)
echo. > models/__init__.py
echo. > utils/__init__.py
echo. > tests/__init__.py
# Správce kontaktů
Jednoduchá CLI aplikace pro správu kontaktů.
## Funkce
- Přidání nového kontaktu
- Zobrazení všech kontaktů
- Vyhledávání podle jména
- Mazání kontaktů
- Ukládání do souboru
## Instalace
```
git clone https://github.com/tvoje-jmeno/spravce-kontaktu.git
cd spravce-kontaktu
python main.py
```
## Použití
Spusť `python main.py` a následuj instrukce v menu.
## Autor
Tvoje Jméno
## Licence
MIT
# Python
__pycache__/
*.pyc
*.pyo
.env
venv/
# IDE
.vscode/
.idea/
*.swp
# Data (volitelně - pokud nechceš verzovat uživatelská data)
# data/*.json
# OS
.DS_Store
Thumbs.db
# models/kontakt.py
"""Modul obsahující třídu Kontakt."""
class Kontakt:
"""Třída reprezentující jeden kontakt."""
def __init__(self, jmeno, telefon, email=""):
"""
Inicializace kontaktu.
Args:
jmeno: Jméno kontaktu
telefon: Telefonní číslo
email: E-mailová adresa (volitelné)
"""
self.jmeno = jmeno
self.telefon = telefon
self.email = email
def __str__(self):
"""Textová reprezentace kontaktu."""
info = f"{self.jmeno} | Tel: {self.telefon}"
if self.email:
info += f" | Email: {self.email}"
return info
def to_dict(self):
"""Převede kontakt na slovník (pro ukládání do JSON)."""
return {
"jmeno": self.jmeno,
"telefon": self.telefon,
"email": self.email
}
@classmethod
def from_dict(cls, data):
"""Vytvoří kontakt ze slovníku (načítání z JSON)."""
return cls(
jmeno=data["jmeno"],
telefon=data["telefon"],
email=data.get("email", "")
)
# Přidej všechny soubory
git add .
# Vytvoř první commit
git commit -m "Počáteční struktura projektu
- Přidána základní struktura složek
- Vytvořen README.md s popisem projektu
- Přidán .gitignore pro Python
- Implementována třída Kontakt"
# (Volitelné) Propoj s GitHubem
git remote add origin https://github.com/tvoje-jmeno/spravce-kontaktu.git
git branch -M main
git push -u origin main
spravce-kontaktu/
├── .git/ # Git repozitář
├── .gitignore # Ignorované soubory
├── README.md # Dokumentace
├── models/
│ ├── __init__.py
│ └── kontakt.py # Třída Kontakt
├── utils/
│ └── __init__.py
└── tests/
└── __init__.py
aktualizuj() pro změnu údajů.V další kapitole: Přidáme správce kontaktů a ukládání do souboru.