pondělí 4. května 2026

Python: Datové typy I

Programovací jazyk Python je celkem snadno naučitelný programovací jazyk. Přispívá k tomu jeho samotná struktura i logické komponenty jazyka, tím myslím snadno pochopitelné a přívětivě definované datové typy, které Python používá pro zadávání hodnot proměnných.

V článku představím základní vestavěné datové typy v Pythonu.

Co jsou datové typy?

V Pythonu existuje několik základních datových typů, které určují, jaký druh hodnoty proměnná obsahuje. Patří mezi ně čísla, řetězce, logické hodnoty, seznamy, n-tice, množiny a slovníky. Každý typ má své vlastnosti, chování a typické použití.

Advice
Datový typ nám prozrazuje, co můžeme od proměnné daného typu očekávat, a co s nimi můžeme dělat.

Základní datové typy v Pythonu

Číselné typy (numbers)

  • int - celá čísla
    Např: 5, -12, 10000
    Nemají limit velikosti (jediným limitem je velikost paměti).
  • float - desetinná čísla
    Např: 3,14, 0,0001, -2,5
    Ukládají se v binárním formátu, mohou mít zaokrouhlovací chyby.
  • complex - komplexní čísla
    Např: 3+4j
    Používá se hlavně v matematice a vědě.

Řetězce (str)

  • Text uzavřený v ' ' nebo " ".
    Např. "Ahoj", 'Python'
  • Jsou neměnitelné (immutable) — nelze změnit znak na určité pozici.
  • Podporují indexování a slicing:
    text[0], text[1:4]

Logické hodnoty (bool)

  • Pouze dvě hodnoty:
    True a False
  • Používají se v podmínkách, porovnávání, cyklech.

Seznam (list)

  • Zapisuje se pomocí hranatých závorek:
    [1, 2, 3], ["a", "b", "c"]
  • Měnitelný (mutable) — lze přidávat, mazat, měnit prvky.
  • Může obsahovat různé typy najednou.

N-tice (tuple)

  • Zapisuje se pomocí kulatých závorek:
    (1, 2, 3)
  • Neměnitelná (immutable)
  • Vhodná pro data, která se nemají měnit.

Množina (set)

  • Zapisuje se pomocí složených závorek:
    {1, 2, 3}
  • Neobsahuje duplicity.
  • Pořadí není garantováno.
  • Hodí se pro operace jako průnik, sjednocení, rozdíl.

Slovník (dict)

  • Klíč–hodnota:
    {"jmeno": "Michal", "vek": 46}
  • Klíče musí být neměnitelné typy (str, int, tuple…)
  • Hodnoty mohou být libovolné.

Jak Python pracuje s typy

Python je dynamicky typovaný — typ proměnné se určuje až za běhu. Typ lze zjistit pomocí příkazu type():

x = 10
print(type(x))  # <class 'int'>

Přehled typů v tabulce

Typ Příklad Měnitelný Typické použití
int 42 ne Počítání
float 3,14 ne Měření, výpočty
str "text" ne Práce s textem
bool True ne Podmínky
list [1,2,3] ano Kolekce dat
tuple (1,2,3) ne Neměnná data
set {1,2,3} ano Unikátní hodnoty
dict {"a":1} ano Strukturovaná data

Příklady datových typů

int – celé číslo

a = 42
b = -7
c = 1000000

float – desetinné číslo

pi = 3.14159
teplota = -2.5

complex – komplexní číslo

z = 3 + 4j

str – řetězec

text = "Ahoj světe"
jmeno = 'Michal'
prvni_znak = text[0]      # 'A'
podretezec = text[0:4]    # 'Ahoj'

bool – logická hodnota

x = True
y = False

print(5 > 3)   # True
print(2 == 7)  # False

list – seznam

seznam = [1, 2, 3, 4]
mix = [1, "text", 3.14, True]

seznam.append(5)   # [1,2,3,4,5]
seznam[0] = 99     # [99,2,3,4,5]

tuple – N-tice

t = (10, 20, 30)
# t[0] = 99  # Chyba – tuple je neměnitelný

set – množina

m = {1, 2, 3, 3, 2}
print(m)   # {1, 2, 3} – duplicity se odstraní

m.add(4)

dict – slovník

osoba = {
    "jmeno": "Michal",
    "vek": 30,
    "aktivni": True
}

print(osoba["jmeno"])  # Michal
osoba["vek"] = 31

Dynamické typování

Zde malá ukázka dynamického typování, tedy možnosti měnit datový typ proměnné v různých částech programu za běhu.

x = 10       # int
x = "text"   # str
x = [1,2,3]  # list

Co znamená immutable

Immutable = neměnitelný. Jakmile objekt vytvoříme, nelze změnit jeho obsah. Jakákoliv „změna“ vytvoří nový objekt v paměti.

Typické immutable typy:

  • int
  • float
  • bool
  • str
  • tuple
  • frozenset

x = 10
print(id(x))   # např. 14012345 = adresa v paměti

x = x + 1
print(id(x))   # jiná adresa v paměti

Hodnota se nezměnila — vznikl nový objekt.

Co znamená mutable

Mutable = měnitelný. Objekt můžeš upravit na místě, bez vytváření nového objektu.

Typické mutable typy:

  • list
  • dict
  • set
  • vlastní objekty (třídy)

seznam = [1, 2, 3]
print(id(seznam))   # např. 15000000

seznam.append(4)
print(id(seznam))   # stejná adresa

Objekt zůstává stejný — změnil se obsah.

Proč na tom záleží?

1. Přiřazení proměnných

a = [1, 2, 3]
b = a
b.append(4)

print(a)  # [1, 2, 3, 4]  ← změna se projeví i v a

U mutable typů sdílí proměnné stejný objekt.

U immutable typů tohle nenastane:

a = 10
b = a
b += 1

print(a)  # 10
print(b)  # 11

1. Předávání do funkcí

Mutable typy se mohou uvnitř funkce změnit:

def uprav(lst):
    lst.append(99)

x = [1, 2]
uprav(x)
print(x)  # [1, 2, 99]

Immutable typy se nikdy nezmění:

def zvys(n):
    n += 1

x = 10
zvys(x)
print(x)  # 10

1. Použití jako klíče ve slovníku

Klíče musí být immutable.

str, int, tuple
list, dict, set 

d = { (1,2): "OK" }   # funguje
d = { [1,2]: "NE" }   # chyba

To by pro dnešek asi stačilo, příště se můžeme podívat na nějaké příklady použití.

Vystavil v
Štítky: ,