Datové typy a jejich využití

Základním prvkem programování je práce s daty. Data si udržujeme v proměnných a datových strukturách. Pro tento účel máme v Pythonu různé datové typy a každý z nich má své specifické způsoby použití. Základnímu notaci a označení v Pythonu se věnuje téma přehled datových typů.

Procvičování na Umíme se soustředí na nejvíce používané datové typy:

• Číselné typy (int, float) pokrývá základní téma proměnné a číselné výrazy.
• Logický typ (bool) souvisí úzce s tématem logické výrazy.
• Řetězce jsou sekvence znaků, které oproti číslům přidávají navíc především princip indexování.
• Seznamy jsou obecnější než řetězce, mimo jiné tím, že jsou dynamicky měnitelné a mohou obsahovat prvky různých typů.
• Slovníky umožňují indexování nejen čísly, ale třeba i řetězci.

S datovými typy pak souvisí obecnější téma objektů, které už patří k pokročilejším a zde pokrýváme jen úplné základy.

Přehled typů

Základní datové typy v Pythonu jsou:

Python nabízí i další typy, např. complex (komplexní čísla), tuple (entice, neměnitelná sekvence), set (množina).

Měnitelnost a neměnitelnost

Typy rozlišujeme podle toho, zda jejich hodnoty můžeme měnit:

• měnitelné (mutable) typy jsou list, set, dict,
• neměnitelné (immutable) typy jsou int, float, bool, str, tuple.

Toto rozlišení je důležité například při využití slovníků – slovníky můžeme indexovat pouze neměnitelnými typy.

Přetypování

Názvy typů jsou současně názvy vestavěných funkcí, které provedou přetypování. Typy proměnných jsou velice důležité. Ovlivňují například význam operátorů. Typický příklad je přetypování čísla na řetězec:

x = 15

print(x)    # vypíše 15

print(3*x)  # vypíše 45

x = str(x)  # přetypování na řetězec, x nyní obsahuje "15"

print(x)    # vypíše 15 (zde se rozdíl typu neprojeví)

print(3*x)  # vypíše 151515 (protože x je nyní řetězec a operace * pro řetězec

            # znamená opakované zřetězení)

Zápis řetězců

Řetězce zapisujeme do uvozovek nebo apostrofů. V Pythonu 3 mohou řetězce obsahovat i znaky s diakritikou.

a = "Toto je řetězec"

b = 'Toto je taky řetězec'

print(a, b)

Indexování

K jednotlivým znakům řetězce přistupujeme pomocí indexování hranatými závorkami. Pozor, indexujeme od nuly. Python (na rozdíl od většiny jiných programovacích jazyků) umožňuje indexovat i od konce pomocí záporných čísel.

text = "prase"

text[0]     # první písmeno => 'p'

text[1]     # druhé písmeno => 'r'

text[4]     # páté, poslední písmeno => 'e'

text[-1]    # poslední písmeno => 'e'

text[-2]    # předposlední písmeno => 's'

Pomocí dvojtečky můžeme indexovat podřetězec.

text = "panoramata"

print(text[2:6])  # od 2. po 6. pozici => nora

print(text[:3])   # první 3 znaky => pan

print(text[-4:])  # poslední 4 znaky => mata

Pokročilejším prvkem pak je využití dvou dvojteček, kde třetí hodnota udává délku skoku:

text = "Běží-liška-k-táboru"

print(text[5:15:2])  # od 5. po 14. pozici, ob 2 => lšakt

print(text[::3])     # od začátku do konce, ob 3 => Bíia-bu

print(text[::-1])    # pozpátku => urobát-k-akšil-ížěB

Iterování přes řetězec

Jednotlivé znaky řetězce můžeme snadno procházet pomocí for cyklu.

text = "koniklec"

for letter in text:

    print("písmeno:", letter)

Neměnitelnost řetězců

Řetězce jsou v Python neměnitelný datový typ. To je jeden z výrazných rysů, ve kterých se liší od seznamů. Neměnitelnost znamená, že nemůžeme změnit dílčí písmeno v znaku. Musíme vytvořit nový řetězec, ve kterém bude příslušné písmeno změněno.

text = "kopec"

text[2] = "n"                 # TypeError - řetězec neumožňuje změnu znaku

text = text[:2]+"n"+text[3:]  # vytvoříme nový, upravený řetězec

print(text)

Operace s řetězci

Řetězce můžeme sčítat (= zřetězit). Řetězce můžeme také násobit celým číslem (= opakovaně zřetězit). Mezi další užitečné operace patří zjištění délky (len) či test na přítomnost podřetězce (in).

text = "petr"

text + "klíč"  # => petrklíč

3*text         # => petrpetrpetr

len(text)      # => 4

"e" in text    # => True

Řetězce jsou objekty, které mají k dispozici řadu užitečných metod, které voláme pomocí tečkové notace. Příklady jsou převod na velká/malá písmena (upper, lower), rozdělení řetězce podle zadaného znaku (split), nebo nahrazování podřetězce (replace):

text = "Liberec"

text.upper()               # => LIBEREC

text.lower()               # => liberec

text.split("e")            # => ['Lib', 'r', 'c']

text.replace("ber", "dej") # => Lidejec

Všimněte si, že zde využíváme takzvanou tečkovou notaci: píšeme text.upper(), nikoliv běžné volání funkce tvaru upper(text). To souvisí s tím, že řetězce jsou reprezentovány jako objekty.

Operace se znaky

Při práci s řetězci se občas hodí i operace pro manipulaci s jednotlivými znaky, především funkce ord a chr, které převádí znaky na celá čísla a zpět:

• ord(c) vrátí pořadové číslo znaku c,
• chr(i) vrátí znak s pořadovým číslem i.

Pod „pořadové číslo“ se rozumí číslo v kódování Unicode. Pro základní programátorské úlohy stačí vědět, že písmena jsou v tomto kódování abecedně za sebou (bohužel to však platí jen pro písmena anglické abecedy). Takto tedy můžeme vypsat písmena anglické abecedy:

start = ord('A')

for i in range(26):

    print(chr(start + i))

Seznam (list) je uspořádaná kolekce hodnot libovolného typu.

Vytvoření seznamu

Seznamy zapisujeme pomocí hranatých závorek:

s = []           # prázdný seznam

s = [8, 3, 45]   # seznam tří čísel

Seznam můžeme také vytvořit pomocí klíčového slova list.

s = list("prase")   # vytvoří seznam ['p', 'r', 'a', 's', 'e']

Indexování

K jednotlivým prvkům seznamu přistupujeme pomocí indexování hranatými závorkami. Pozor, indexujeme od nuly. Zápornými čísly můžeme indexovat odzadu:

s = ["pes", "prase", "ovce", "koza"]

s[0]      # první prvek seznamu => "pes"

s[1]      # druhý prvek seznamu => "prase"

s[-1]     # poslední prvek seznamu => "koza"

s[-2]     # předposlední prvek seznamu => "ovce"

Pomocí dvojtečky můžeme indexovat část seznamu:

numbers = [37, 99, 42, 7, 13, 1, 1000]

print(numbers[2:5])  # => [42, 7, 13]

print(numbers[:3])   # => [37, 99, 42]

print(numbers[-2:])  # => [1, 1000]

Operace se seznamy

Užitečné funkce se seznamy:

s = [8, 3, 45]

a = len(s)    # délka seznamu

s.append(7)   # přidání prvku do seznamu

s.sort()      # seřazení prvků v seznamu

t = sorted(s) # seřadí prvky v s a tento nový seznam přiřadí do t

              # s se nezmění

Všimněte si, že zde využíváme takzvanou tečkovou notaci: píšeme s.sort(), nikoliv běžné volání funkce tvaru sort(s). To souvisí s tím, že seznamy jsou reprezentovány jako objekty.

Seznamy a for cyklus

Pomocí for cyklu můžeme procházet prvky seznamu:

s = [8, 3, 45]

for x in s:

    print(x)

Alternativně můžeme procházet prvky seznamu takto (tento zápis je bližší tomu, jak procházíme seznamy v jiných programovacích jazycích):

for i in range(len(s)):

    print(s[i])

Slovník (dictionary, dict) udává mapování klíčů na hodnoty. Můžeme si třeba pamatovat počty kusů ovoce na skladě.

Vytvoření slovníku

Slovník vytváříme v Pythonu pomocí složených závorek.

fruits = {"apple": 5,

          "banana": 10,

          "orange": 2}



empty_dictionary = {}    # prázdný slovník

Přístup k položkám

K položkám slovníku přistupujeme pomocí indexování hranatými závorkami. Podobně můžeme do slovníku položku přidat.

print(fruits["apple"])

fruits["pear"] = 3

Pokud se pokusíme přistoupit k položce, která ve slovníku není, dostaneme chybu. Bezpečný přístup provedeme pomocí get:

print(fruits["plum"])    # => KeyError: 'plum'

print(fruits.get("plum", 0))   # pokud položka ve slovníku není,

                               # vrátí zadanou hodnotu (0)

Práce se slovníky

Další užitečné funkce pro práci se slovníky:

len(fruits)        # počet klíčů ve slovníku

fruits.keys()      # klíče ve slovníku, tj. 'pear', 'orange', 'banana', 'apple'

fruits.values()    # hodnoty ve slovníku, tj. 10, 2, 3, 5

"apple" in fruits  # test na přítomnost ve slovníku

Python, stejně jako většina dalších moderních programovacích jazyků, podporuje objektově orientované programování. To už je poměrně pokročilé programátorské téma. Zde si shrneme jen některé základní pojmy.

Objekt (object) je kolekce dat (proměnných) a metod (funkcí), které s těmito daty pracují. V Pythonu jsou téměř všechna data, se kterými se setkáme, objekty (čísla, řetězce, seznamy, …).

Objekty jsou speciální instance tříd (class). Třídu můžeme chápat jako obecný vzor, podle kterého se tvoří objekty.

Příklad definice třídy:

class Person:

    def __init__(self, name, age):

        self.name = name

        self.age = age

        

    def introduce(self):

        print("My name is ", self.name)

        print("I am ", self.age, "years old")

A takto vytvoříme objekty (instance třídy) a použijeme je:

homer = Person("Homer Simpson", 39)

bart = Person("Bart Simpson", 10)

homer.introduce()

bart.introduce()

V tomto příkladě:

• Person je třída,
• homer a bart jsou objekty,
• name a age jsou datové atributy,
• introduce() je metoda,
• __init__ je inicializační metoda, která se automaticky volá při vytváření objektu.