Představ si, že máš obrovskou tabulku se všemi žáky vaší školy. Jak v ní najdeš nejstaršího žáka? Nebo jak zobrazíš jen spolužáky z vaší třídy? Procházet tisíce řádků jeden po druhém by byla noční můra! Naštěstí máme dva mocné nástroje, které nám pomohou: řazení a filtrování. Naučíme se, jak s nimi pracovat, abychom z dat rychle získali odpovědi na naše otázky.
Řazení znamená, že si data v tabulce seřadíme podle nějakého pravidla. Je to jako když si v knihovně seřadíš knížky podle abecedy, aby se ti lépe hledaly.
Řazení dat je proces uspořádání řádků v tabulce podle hodnot v jednom nebo více sloupcích. Můžeme řadit vzestupně (od nejmenšího po největší, od A do Z) nebo sestupně (od největšího po nejmenší, od Z do A).
| Zvíře | Váha (kg) |
|---|---|
| Slon | 5000 |
| Myš | 0.02 |
| Pes | 15 |
| Kočka | 4 |
| Zvíře | Váha (kg) |
|---|---|
| Slon | 5000 |
| Pes | 15 |
| Kočka | 4 |
| Myš | 0.02 |
Filtrování je jako kouzelné síto. Řekneš mu, co chceš vidět, a ono ti to ukáže. Všechno ostatní dočasně schová.
Filtrování dat je proces, při kterém zobrazíme pouze ty řádky tabulky, které splňují námi zadanou podmínku. Ostatní řádky se dočasně skryjí.
Původní tabulka:
| Zvíře | Váha (kg) |
|---|---|
| Slon | 5000 |
| Myš | 0.02 |
| Pes | 15 |
| Kočka | 4 |
Filtrovaná tabulka:
| Zvíře | Váha (kg) |
|---|---|
| Myš | 0.02 |
| Pes | 15 |
| Kočka | 4 |
V programech jako Microsoft Excel nebo Google Tabulky najdeš tlačítka pro řazení a filtrování obvykle v menu "Data". Stačí označit tabulku, kliknout na tlačítko a vybrat si, podle kterého sloupce a jak chceš data seřadit nebo filtrovat. Je to velmi jednoduché a intuitivní!
Řazení a filtrování jsou základní dovednosti pro práci s informacemi v digitálním světě. Pomáhají nám rychle se zorientovat v obrovském množství dat, se kterým se setkáváme každý den – ať už jde o výsledky vyhledávání na internetu, nabídky v e-shopech nebo data v pracovních tabulkách. Učíme se tak efektivně hledat to, co je pro nás důležité, a nenechat se zahltit nepodstatnými informacemi.
Základní řazení A-Z nebo Z-A jsme si už ukázali. Ale co když potřebuješ něco složitějšího?
Představ si seznam zaměstnanců. Chceš je seřadit nejdřív podle oddělení (abys měl pohromadě všechny z IT, pak všechny z účtárny...) a v rámci každého oddělení podle platu od nejvyššího. To je vícenásobné řazení.
Jak na to v Excelu: Data → Seřadit → V dialogu přidej více úrovní tlačítkem "Přidat úroveň". První úroveň = Oddělení (A-Z), druhá = Plat (od největšího).
Co když máš sloupec s dny v týdnu? Abecedně by bylo: Čtvrtek, Neděle, Pátek, Pondělí... To nedává smysl! Excel umožňuje definovat vlastní pořadí: Pondělí, Úterý, Středa...
Jak na to: Data → Seřadit → Pořadí → Vlastní seznam → Vyber "Pondělí, Úterý..." nebo vytvoř vlastní.
Běžný filtr (Automatický filtr) je skvělý pro jednoduché úlohy. Pro složitější potřeby máme další nástroje:
Při filtrování textu můžeš použít speciální znaky:
Excel nabízí speciální filtry pro data: Tento týden, Minulý měsíc, Tento rok, Starší než 6 měsíců... Velmi užitečné pro analýzu časových řad.
Když klikneš na "Seřadit", počítač interně používá algoritmy řazení. Je zajímavé vědět, jak fungují:
Bubble Sort (bublinkové řazení) je nejjednodušší algoritmus: Porovnává dva sousední prvky a pokud jsou ve špatném pořadí, prohodí je. Opakuje dokud není vše seřazeno. Je pomalý, ale snadno pochopitelný.
Quick Sort je mnohem rychlejší: Vybere jeden prvek (pivot), rozdělí seznam na menší a větší než pivot, a rekurzivně seřadí obě části. Používá ho většina moderních programů.
V informatice je řazení jedním z nejdůležitějších problémů. Existuje mnoho algoritmů, které se liší rychlostí a složitostí. Časová složitost vyjadřuje, jak rychle roste čas výpočtu s rostoucím počtem prvků.
Algoritmus opakovaně prochází seznamem, porovnává sousední prvky a prohazuje je, pokud jsou ve špatném pořadí. Největší prvky "bublají" nahoru jako bubliny ve vodě.
Složitost O(n²) znamená: pro 1000 prvků potřebuje až 1 000 000 porovnání. Pro milion prvků by to bylo bilion operací – příliš pomalé!
Vybere jeden prvek (pivot), rozdělí seznam na dvě části – menší než pivot a větší než pivot. Každou část pak seřadí rekurzivně.
Složitost O(n log n) je mnohem lepší: pro 1000 prvků stačí asi 10 000 operací. Pro milion prvků "jen" 20 milionů. Proto ho používá většina reálných aplikací.
| Algoritmus | Složitost | Princip | Kdy použít |
|---|---|---|---|
| Bubble Sort | O(n²) | Porovnává sousedy | Výuka, malé seznamy |
| Quick Sort | O(n log n) | Pivot + rozdělení | Většina reálných případů |
| Merge Sort | O(n log n) | Rozdělení a slučování | Velká data, stabilní řazení |
V databázích se řazení a filtrování provádí pomocí SQL příkazů. Je to mnohem efektivnější než dělat to v Excelu pro miliony záznamů.
-- Seřaď produkty podle ceny od nejlevnějšího
SELECT * FROM Produkty ORDER BY Cena ASC;
-- Seřaď od nejdražšího
SELECT * FROM Produkty ORDER BY Cena DESC;
-- Vícenásobné řazení: nejdřív kategorie, pak cena
SELECT * FROM Produkty ORDER BY Kategorie ASC, Cena DESC;
-- Produkty dražší než 100 Kč z kategorie Elektronika
SELECT * FROM Produkty
WHERE Cena > 100 AND Kategorie = 'Elektronika';
-- Produkty, jejichž název začíná na "Smart"
SELECT * FROM Produkty WHERE Nazev LIKE 'Smart%';
-- Produkty v cenovém rozmezí
SELECT * FROM Produkty WHERE Cena BETWEEN 100 AND 500;
Řezy (Slicers) jsou vizuální tlačítka pro filtrování kontingenčních tabulek. Místo rozklikávání filtru jednoduše klikneš na tlačítko s hodnotou, kterou chceš vidět.
Rozšířený filtr umožňuje zadávat kritéria do samostatné oblasti buněk. Můžeš tak vytvářet složité podmínky, které si uložíš a můžeš znovu použít.
Jako IT specialista musíš rozumět algoritmům řazení na implementační úrovni a umět je používat efektivně.
def bubble_sort(seznam):
"""Bubble Sort - O(n²)"""
n = len(seznam)
for i in range(n):
for j in range(0, n - i - 1):
if seznam[j] > seznam[j + 1]:
seznam[j], seznam[j + 1] = seznam[j + 1], seznam[j]
return seznam
def quick_sort(seznam):
"""Quick Sort - O(n log n) průměrně"""
if len(seznam) <= 1:
return seznam
pivot = seznam[len(seznam) // 2]
mensi = [x for x in seznam if x < pivot]
stejne = [x for x in seznam if x == pivot]
vetsi = [x for x in seznam if x > pivot]
return quick_sort(mensi) + stejne + quick_sort(vetsi)
def merge_sort(seznam):
"""Merge Sort - O(n log n) vždy"""
if len(seznam) <= 1:
return seznam
stred = len(seznam) // 2
leva = merge_sort(seznam[:stred])
prava = merge_sort(seznam[stred:])
return merge(leva, prava)
def merge(leva, prava):
vysledek = []
i = j = 0
while i < len(leva) and j < len(prava):
if leva[i] < prava[j]:
vysledek.append(leva[i])
i += 1
else:
vysledek.append(prava[j])
j += 1
vysledek.extend(leva[i:])
vysledek.extend(prava[j:])
return vysledek
# Python používá Timsort - hybridní algoritmus O(n log n)
cisla = [5, 2, 8, 1, 9]
cisla.sort() # In-place řazení
print(cisla) # [1, 2, 5, 8, 9]
# sorted() vrací nový seznam
serazene = sorted([5, 2, 8, 1, 9])
# Řazení sestupně
cisla.sort(reverse=True)
# Řazení podle klíče
studenti = [
{'jmeno': 'Jan', 'vek': 20},
{'jmeno': 'Eva', 'vek': 18},
{'jmeno': 'Petr', 'vek': 22}
]
# Podle věku
podle_veku = sorted(studenti, key=lambda x: x['vek'])
# Podle jména
podle_jmena = sorted(studenti, key=lambda x: x['jmeno'])
# Vícenásobné řazení (nejdřív podle příjmení, pak jména)
from operator import itemgetter
lide = sorted(lide, key=itemgetter('prijmeni', 'jmeno'))
# List comprehension - nejčastější způsob
cisla = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Sudá čísla
suda = [x for x in cisla if x % 2 == 0]
# Větší než 5
vetsi = [x for x in cisla if x > 5]
# Kombinace podmínek
vysledek = [x for x in cisla if x > 3 and x < 8]
# Filtrování objektů
produkty = [
{'nazev': 'Notebook', 'cena': 25000, 'kategorie': 'IT'},
{'nazev': 'Myš', 'cena': 500, 'kategorie': 'IT'},
{'nazev': 'Stůl', 'cena': 3000, 'kategorie': 'Nábytek'},
]
# IT produkty dražší než 1000 Kč
it_drahe = [p for p in produkty
if p['kategorie'] == 'IT' and p['cena'] > 1000]
# filter() funkce
suda = list(filter(lambda x: x % 2 == 0, cisla))
import time
import random
def zmer_cas(funkce, data):
start = time.time()
funkce(data.copy())
return time.time() - start
# Generuj náhodná data
velikosti = [100, 1000, 5000]
for n in velikosti:
data = [random.randint(1, 10000) for _ in range(n)]
cas_bubble = zmer_cas(bubble_sort, data)
cas_quick = zmer_cas(quick_sort, data)
cas_python = zmer_cas(sorted, data)
print(f"n={n:5d}: Bubble={cas_bubble:.4f}s, "
f"Quick={cas_quick:.4f}s, Python={cas_python:.6f}s")
Pokračujeme v projektu Evidence studentů. V této kapitole se naučíš UPDATE, DELETE a řazení/filtrování v SQL.
USE skola;
-- Aktualizace jednoho záznamu
UPDATE studenti
SET email = 'novak.jan@skola.cz'
WHERE id = 1;
-- Aktualizace více polí
UPDATE studenti
SET trida = '9.B', email = 'novy@email.cz'
WHERE id = 2;
-- Hromadná aktualizace
UPDATE studenti
SET trida = '9.C'
WHERE trida = '9.B' AND datum_narozeni < '2008-06-01';
-- Aktualizace s výpočtem
UPDATE studenti s
SET prumer = (
SELECT ROUND(AVG(z.znamka), 2)
FROM znamky z
WHERE z.student_id = s.id
);
-- ⚠️ POZOR! Bez WHERE se aktualizuje VŠE!
-- UPDATE studenti SET trida = '9.X'; -- ŠPATNĚ!
-- Smazání jednoho záznamu
DELETE FROM studenti WHERE id = 5;
-- Smazání podle podmínky
DELETE FROM znamky WHERE datum < '2024-01-01';
-- Smazání s JOIN (studenti bez známek)
DELETE s FROM studenti s
LEFT JOIN znamky z ON s.id = z.student_id
WHERE z.id IS NULL;
-- ⚠️ POZOR! Bez WHERE se smaže VŠE!
-- DELETE FROM studenti; -- ŠPATNĚ!
-- Bezpečnější: TRUNCATE (rychlejší, ale smaže vše)
-- TRUNCATE TABLE znamky;
-- Top 5 nejlepších studentů
SELECT s.jmeno, s.prijmeni, ROUND(AVG(z.znamka), 2) as prumer
FROM studenti s
JOIN znamky z ON s.id = z.student_id
GROUP BY s.id
ORDER BY prumer ASC
LIMIT 5;
-- Stránkování (10 záznamů na stránku)
-- Stránka 1
SELECT * FROM studenti ORDER BY prijmeni LIMIT 10 OFFSET 0;
-- Stránka 2
SELECT * FROM studenti ORDER BY prijmeni LIMIT 10 OFFSET 10;
-- Stránka 3
SELECT * FROM studenti ORDER BY prijmeni LIMIT 10 OFFSET 20;
-- Řazení podle více sloupců
SELECT * FROM studenti
ORDER BY trida ASC, prijmeni ASC, jmeno ASC;
-- LIKE - vyhledávání v textu
SELECT * FROM studenti WHERE prijmeni LIKE 'Nov%'; -- Začíná na Nov
SELECT * FROM studenti WHERE email LIKE '%@skola.cz'; -- Končí na @skola.cz
SELECT * FROM studenti WHERE jmeno LIKE '_an'; -- 3 znaky, končí na "an"
-- IN - více hodnot
SELECT * FROM studenti WHERE trida IN ('9.A', '9.B');
-- BETWEEN - rozsah
SELECT * FROM studenti
WHERE datum_narozeni BETWEEN '2008-01-01' AND '2008-06-30';
-- IS NULL / IS NOT NULL
SELECT * FROM studenti WHERE email IS NULL;
SELECT * FROM studenti WHERE email IS NOT NULL;
-- Kombinace s AND, OR, NOT
SELECT * FROM studenti
WHERE (trida = '9.A' OR trida = '9.B')
AND email IS NOT NULL
AND NOT prijmeni LIKE 'Test%';
-- Transakce zajistí, že se buď provedou všechny změny, nebo žádná
START TRANSACTION;
-- Přidej studenta
INSERT INTO studenti (jmeno, prijmeni, trida)
VALUES ('Test', 'Student', '9.A');
-- Přidej jeho známky
INSERT INTO znamky (student_id, predmet_id, znamka, datum)
VALUES (LAST_INSERT_ID(), 1, 2, CURDATE());
-- Pokud vše OK, potvrď
COMMIT;
-- Pokud něco špatně, vrať změny
-- ROLLBACK;
queries.sql a commitni do Gitu.V další kapitole: Naučíš se indexy a optimalizaci dotazů.