Představ si, že máš spoustu hraček. Aby sis pamatoval, kde co máš, a abys je snadno našel, uděláš si seznam. Nebo si je roztřídíš do krabic a každou krabici popíšeš. Přesně k tomu slouží evidence dat. Je to způsob, jak si dělat pořádek v informacích, abychom je neztratili a mohli je kdykoli použít. A co když se do našeho seznamu vloudí chyba? I to se stává a naučíme se, jak ji najít a opravit!
Evidence dat je jako tvůj osobní digitální deníček nebo seznam, kde si zaznamenáváš důležité informace. Díky ní máš přehled a můžeš se rychle podívat, co potřebuješ.
Evidence dat je systematické shromažďování, uspořádání a ukládání informací o něčem (např. o lidech, věcech, událostech) tak, aby byly snadno dostupné a použitelné.
Evidence dat je super, protože nám pomáhá:
Vytvořit si vlastní evidenci dat je snadné. Můžeš použít papír a tužku, nebo počítačový program (např. Excel nebo Google Tabulky).
Nejdřív si řekni, o čem chceš mít přehled. O knížkách? O kamarádech? O úkolech?
Teď si rozmysli, co je pro tebe důležité vědět o každém úkolu. To budou tvoje sloupce v tabulce.
Můžeš si ji nakreslit na papír, nebo použít počítač. V počítači je to lepší, protože pak můžeš data snadno řadit a filtrovat (jak jsme se učili v minulé kapitole).
| Předmět | Popis úkolu | Termín odevzdání | Hotovo |
|---|---|---|---|
| Matematika | Vypočítat příklady na str. 25 | 15. 10. | Ne |
| Čeština | Napsat slohovou práci | 20. 10. | Ne |
Teď už jen stačí vyplnit tabulku. Každý úkol bude jeden řádek.
I když se snažíme být pečliví, chyby se stávají. Můžeme se splést při psaní, něco zapomenout, nebo se informace změní.
Chyby v evidenci dat mohou způsobit problémy:
Když víme, že chyby se stávají, je důležité umět je najít a opravit.
Vedení evidence dat je základní dovedností pro život v digitálním světě. Pomáhá nám udržovat pořádek nejen v práci, ale i v osobním životě. Schopnost najít a opravit chyby v datech nás učí být pečlivými a zodpovědnými. Učíme se, že data nejsou neměnná a že je důležité je udržovat aktuální a správná, aby nám dobře sloužila.
Když se tvoje evidence rozroste – stovky nebo tisíce záznamů – Excel přestává stačit. Pro větší objemy dat se používají databázové systémy.
Nejrozšířenější typ databází. Data jsou uložena v tabulkách, které jsou propojené pomocí klíčů. Když máš tabulku zákazníků a tabulku objednávek, propojíš je tak, že každá objednávka obsahuje ID zákazníka.
Příklady relačních databází: MySQL (nejpoužívanější pro webové aplikace), PostgreSQL (pokročilé funkce), SQLite (jednoduchá, ideální pro mobilní aplikace), Microsoft SQL Server (firemní prostředí).
Novější přístup pro specifické případy. Místo pevných tabulek používají flexibilnější struktury – například dokumenty (jako JSON). Příklad: MongoDB nebo Firebase (oblíbený pro mobilní aplikace).
Ať už používáš Excel nebo databázi, všechny operace s daty lze shrnout do čtyř základních:
SQL (Structured Query Language) je jazyk pro komunikaci s databází. I když nebudeš programátor, základní znalost SQL se hodí:
-- Zobraz všechny studenty starší 18 let
SELECT * FROM studenti WHERE vek > 18;
-- Přidej nového studenta
INSERT INTO studenti (jmeno, vek) VALUES ('Jan', 19);
-- Změň věk studenta Jana na 20
UPDATE studenti SET vek = 20 WHERE jmeno = 'Jan';
-- Smaž studenta Jana
DELETE FROM studenti WHERE jmeno = 'Jan';
Databáze nabízejí nástroje pro automatickou kontrolu správnosti dat:
Profesionální návrh evidence je systematický proces. Nelze jen tak začít vytvářet tabulky – nejdřív musíš pochopit, co přesně potřebuješ evidovat.
Nejdůležitější fáze! Ptáš se: Co chceme evidovat? (entity – zákazníci, produkty, objednávky) Jaké informace o tom potřebujeme? (atributy – jméno, cena, datum) Kdo bude systém používat? (role – admin, prodejce, zákazník)
Vytvoříš vizuální model pomocí ER diagramu:
Převádíš ER diagram do skutečných tabulek. Přidáváš primární klíče (ID), cizí klíče (Zakaznik_ID v tabulce objednávek) a normalizuješ – odstraňuješ duplicity.
Zadávat data přímo do tabulky je náchylné k chybám. Proto se používají formuláře – uživatelsky přívětivá rozhraní s kontrolami.
Excel má vestavěný formulář pro jednoduché evidence. Jak ho použít:
Pro sběr dat od více lidí jsou ideální online formuláře. Vytvoříš formulář s otázkami, sdílíš odkaz a odpovědi se automaticky ukládají do tabulky. Skvělé pro průzkumy, registrace, objednávky.
Pokud často opakuješ stejné úkony (formátování, výpočty, export), můžeš je automatizovat.
Makro je záznam sekvence akcí, které můžeš kdykoli přehrát:
Nástroj od Microsoftu pro automatizaci mezi aplikacemi. Příklad: Když přijde email s přílohou od konkrétního odesílatele, automaticky ulož přílohu na OneDrive a pošli notifikaci.
Jako IT specialista budeš vytvářet databázové aplikace. Naučíš se propojit Python s databází a vytvářet CRUD operace.
import sqlite3
from datetime import datetime
class EvidenceKontaktu:
def __init__(self, db_nazev='kontakty.db'):
self.conn = sqlite3.connect(db_nazev)
self.conn.row_factory = sqlite3.Row
self.vytvor_tabulky()
def vytvor_tabulky(self):
self.conn.executescript('''
CREATE TABLE IF NOT EXISTS kontakty (
id INTEGER PRIMARY KEY AUTOINCREMENT,
jmeno TEXT NOT NULL,
prijmeni TEXT NOT NULL,
email TEXT UNIQUE,
telefon TEXT,
kategorie_id INTEGER,
vytvoreno TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (kategorie_id) REFERENCES kategorie(id)
);
CREATE TABLE IF NOT EXISTS kategorie (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nazev TEXT UNIQUE NOT NULL
);
''')
self.conn.commit()
def pridej_kontakt(self, jmeno, prijmeni, email=None, telefon=None, kategorie=None):
"""Přidá nový kontakt."""
kategorie_id = None
if kategorie:
kategorie_id = self.ziskej_nebo_vytvor_kategorii(kategorie)
self.conn.execute('''
INSERT INTO kontakty (jmeno, prijmeni, email, telefon, kategorie_id)
VALUES (?, ?, ?, ?, ?)
''', (jmeno, prijmeni, email, telefon, kategorie_id))
self.conn.commit()
return self.conn.execute("SELECT last_insert_rowid()").fetchone()[0]
def ziskej_nebo_vytvor_kategorii(self, nazev):
cursor = self.conn.execute(
"SELECT id FROM kategorie WHERE nazev = ?", (nazev,)
)
row = cursor.fetchone()
if row:
return row['id']
else:
self.conn.execute("INSERT INTO kategorie (nazev) VALUES (?)", (nazev,))
self.conn.commit()
return self.conn.execute("SELECT last_insert_rowid()").fetchone()[0]
def vsechny_kontakty(self):
return self.conn.execute('''
SELECT k.*, kat.nazev as kategorie
FROM kontakty k
LEFT JOIN kategorie kat ON k.kategorie_id = kat.id
ORDER BY prijmeni, jmeno
''').fetchall()
def hledej(self, vyhledavani):
return self.conn.execute('''
SELECT * FROM kontakty
WHERE jmeno LIKE ? OR prijmeni LIKE ? OR email LIKE ?
''', (f'%{vyhledavani}%',) * 3).fetchall()
def aktualizuj(self, id, **data):
pole = ', '.join(f"{k} = ?" for k in data.keys())
hodnoty = list(data.values()) + [id]
self.conn.execute(f"UPDATE kontakty SET {pole} WHERE id = ?", hodnoty)
self.conn.commit()
def smaz(self, id):
self.conn.execute("DELETE FROM kontakty WHERE id = ?", (id,))
self.conn.commit()
# Použití
evidence = EvidenceKontaktu()
evidence.pridej_kontakt("Jan", "Novák", "jan@email.cz", "123456789", "Práce")
evidence.pridej_kontakt("Eva", "Svobodová", "eva@email.cz", None, "Rodina")
for kontakt in evidence.vsechny_kontakty():
print(f"{kontakt['jmeno']} {kontakt['prijmeni']} - {kontakt['kategorie']}")
import csv
import json
def export_csv(kontakty, nazev_souboru):
"""Export do CSV."""
with open(nazev_souboru, 'w', newline='', encoding='utf-8') as f:
writer = csv.writer(f)
writer.writerow(['Jméno', 'Příjmení', 'Email', 'Telefon'])
for k in kontakty:
writer.writerow([k['jmeno'], k['prijmeni'], k['email'], k['telefon']])
def export_json(kontakty, nazev_souboru):
"""Export do JSON."""
data = [dict(k) for k in kontakty]
with open(nazev_souboru, 'w', encoding='utf-8') as f:
json.dump(data, f, ensure_ascii=False, indent=2)
def import_csv(nazev_souboru, evidence):
"""Import z CSV."""
with open(nazev_souboru, 'r', encoding='utf-8') as f:
reader = csv.DictReader(f)
for row in reader:
evidence.pridej_kontakt(row['Jméno'], row['Příjmení'],
row.get('Email'), row.get('Telefon'))
Pokračujeme v projektu Evidence studentů. V této kapitole propojíš Python s MySQL.
pip install mysql-connector-python
# db/connection.py
import mysql.connector
from mysql.connector import Error
class DatabaseConnection:
"""Správa připojení k MySQL databázi."""
def __init__(self, host='localhost', user='root',
password='heslo', database='skola'):
self.config = {
'host': host,
'user': user,
'password': password,
'database': database
}
self.connection = None
def connect(self):
"""Připojí se k databázi."""
try:
self.connection = mysql.connector.connect(**self.config)
if self.connection.is_connected():
print("✅ Připojeno k MySQL databázi")
return self.connection
except Error as e:
print(f"❌ Chyba připojení: {e}")
return None
def disconnect(self):
"""Odpojí se od databáze."""
if self.connection and self.connection.is_connected():
self.connection.close()
print("👋 Odpojeno od MySQL")
def execute(self, query, params=None):
"""Provede SQL dotaz."""
cursor = self.connection.cursor(dictionary=True)
cursor.execute(query, params or ())
return cursor
def fetchall(self, query, params=None):
"""Vrátí všechny výsledky."""
cursor = self.execute(query, params)
return cursor.fetchall()
def fetchone(self, query, params=None):
"""Vrátí jeden výsledek."""
cursor = self.execute(query, params)
return cursor.fetchone()
def commit(self):
"""Potvrdí transakci."""
self.connection.commit()
# models/student_db.py
from db.connection import DatabaseConnection
class StudentDB:
"""CRUD operace pro studenty."""
def __init__(self):
self.db = DatabaseConnection()
self.db.connect()
def vsichni(self):
"""Vrátí všechny studenty."""
return self.db.fetchall("SELECT * FROM studenti ORDER BY prijmeni")
def najdi(self, id):
"""Najde studenta podle ID."""
return self.db.fetchone(
"SELECT * FROM studenti WHERE id = %s", (id,)
)
def pridej(self, jmeno, prijmeni, email, trida):
"""Přidá nového studenta."""
query = """
INSERT INTO studenti (jmeno, prijmeni, email, trida)
VALUES (%s, %s, %s, %s)
"""
cursor = self.db.execute(query, (jmeno, prijmeni, email, trida))
self.db.commit()
return cursor.lastrowid
def aktualizuj(self, id, **data):
"""Aktualizuje studenta."""
pole = ', '.join(f"{k} = %s" for k in data.keys())
hodnoty = list(data.values()) + [id]
query = f"UPDATE studenti SET {pole} WHERE id = %s"
self.db.execute(query, hodnoty)
self.db.commit()
def smaz(self, id):
"""Smaže studenta."""
self.db.execute("DELETE FROM studenti WHERE id = %s", (id,))
self.db.commit()
def vyhledej(self, dotaz):
"""Vyhledá studenty."""
query = """
SELECT * FROM studenti
WHERE jmeno LIKE %s OR prijmeni LIKE %s OR email LIKE %s
"""
return self.db.fetchall(query, (f'%{dotaz}%',) * 3)
def statistiky(self):
"""Vrátí statistiky."""
return self.db.fetchone("""
SELECT
COUNT(*) as pocet,
COUNT(DISTINCT trida) as pocet_trid
FROM studenti
""")
# Použití
if __name__ == "__main__":
db = StudentDB()
# Přidej studenta
id = db.pridej("Test", "Student", "test@skola.cz", "9.A")
print(f"Přidán student s ID: {id}")
# Zobraz všechny
for s in db.vsichni():
print(f"{s['jmeno']} {s['prijmeni']} - {s['trida']}")
# Statistiky
stat = db.statistiky()
print(f"Celkem {stat['pocet']} studentů v {stat['pocet_trid']} třídách")
# ❌ ŠPATNĚ - SQL Injection!
query = f"SELECT * FROM studenti WHERE jmeno = '{jmeno}'"
# ✅ SPRÁVNĚ - Parametrizovaný dotaz
query = "SELECT * FROM studenti WHERE jmeno = %s"
cursor.execute(query, (jmeno,))
db/connection.py s třídou DatabaseConnection.models/student_db.py s CRUD operacemi.V další kapitole: Vytvoříš CLI interface pro aplikaci.