V Pythonu se setkáme s datovým typem zvaným n-tice (tuple), který slouží k uchovávání uspořádané sady dat. Funguje podobně jako seznam, avšak s tím rozdílem, že n-tice jsou obecně rychlejší.
Nicméně, z důvodu určitých omezení, jsou seznamy v některých situacích vhodnější volbou. V tomto článku se podíváme na vše, co je potřeba vědět, abyste mohli efektivně n-tice používat.
Co je to n-tice?
Jak již bylo řečeno, n-tice je jedním z vestavěných datových typů v Pythonu, určeným k ukládání kolekcí dat. Podobně jako seznam, i n-tice uchovává data v iterovatelném formátu, připomínajícím pole. Klíčovým rozdílem je, že n-tice jsou neměnné. To znamená, že jakmile je jednou vytvořena, nelze její obsah modifikovat.
Nelze do ní přidávat nové prvky ani odebírat stávající. N-tice se proto skvěle hodí pro ukládání dat, která se nemají měnit. Může jít dokonce o soubor dat různých typů. V následujících sekcích prozkoumáme různé způsoby, jak n-tice v Pythonu vytvářet.
Jak vytvořit n-tici v Pythonu?
Existuje několik způsobů, jak v Pythonu n-tici vytvořit. V této části si představíme tři nejběžnější metody, s nimiž se pravděpodobně setkáte při čtení kódu i ve vlastní tvorbě.
Pro spuštění následujících příkladů kódu je nutné mít nainstalovaný Python. Pokud jej ještě nemáte, můžete se podívat na návod, jak Python nainstalovat. Alternativně můžete kód spustit v online prostředí Pythonu, jako je například Google Colab.
#1. Použití n-ticového literálu (kulaté závorky)
Nejčastějším způsobem, jak definovat n-tici v Pythonu, je vložit sadu hodnot do kulatých závorek. Jednotlivé hodnoty se oddělují čárkami. Následující příklad tuto metodu demonstruje:
# Vytvoření n-tice vložením hodnot mezi závorky values = (1, 2, 3) # Výpis n-tice na obrazovku print(values) # Výpis datového typu proměnné values print(type(values))
Po spuštění tohoto kódu získáme následující výstup:
Jak je vidět z výstupu, n-tice obsahuje hodnoty, kterými jsme ji inicializovali a její typ je
Při vytváření n-tic v Pythonu nejsou kulaté závorky nezbytné. Proto je zápis `values = 1, 2, 3` stejně platný jako `values = (1, 2, 3)`. Doporučuje se však závorky používat, aby byl váš kód čitelnější.
Vytváření n-tic s jedním prvkem v Pythonu vyžaduje specifický postup. Nestačí pouze vložit jeden prvek do závorek, je nutné za něj přidat i koncovou čárku. Zde je příklad pro ilustraci:
# Bez koncové čárky nevznikne n-tice not_a_tuple = (1) # S koncovou čárkou vznikne n-tice a_tuple = (1,) # Výpis not_a_tuple print(not_a_tuple) # Výpis datového typu not_a_tuple print(type(not_a_tuple)) # Výpis a_tuple print(a_tuple) # Výpis datového typu a_tuple print(type(a_tuple))
Spuštěním výše uvedeného kódu zjistíte, že `not_a_tuple` se stane celým číslem (int) s hodnotou 1. Je důležité si toto uvědomit při vytváření n-tic.
#2. Použití konstruktoru
Druhá metoda pro vytváření n-tic v Pythonu využívá konstruktor n-tic. V tomto případě zavoláte funkci a předáte jí iterovatelný objekt, jako je například seznam, jako argument. Ten bude poté převeden na n-tici. Zde je příklad:
# Vytvoření n-tice ze seznamu hodnot values = tuple([1, 2, 3]) # Výpis hodnot print(values) # Výpis datového typu proměnné values print(type(values))
Jak vidíte, použití konstruktoru dosahuje stejného výsledku jako použití literálu. Konstruktor vám však umožňuje vytvářet n-tice na základě dynamických hodnot, například seznamu, jehož obsah je znám až za běhu programu. U první metody byste při psaní kódu museli znát hodnoty nebo proměnné, které tvoří vaši n-tici.
#3. Vytvoření prázdné n-tice
Při práci s n-ticemi v kódu může nastat situace, kdy je potřeba vytvořit prázdnou n-tici. Prázdné n-tice se vytvářejí intuitivně. Můžete použít buď konstruktor, nebo literál. Následující příklad ukazuje použití obou metod:
# Použití n-ticového literálu empty_tuple_1 = () # Použití konstruktoru empty_tuple_2 = tuple()
Prázdné n-tice jsou užitečné například pro reprezentaci prázdné množiny výsledků. Zvažte následující funkci:
def create_range(start, end):
return tuple(range(start, end))
Tato funkce vytvoří n-tici s hodnotami od počáteční do koncové hodnoty, které jí předáte. Pokud byste chtěli iterovat výsledky funkce, použili byste něco takového:
my_values = create_range(0, 5)
for value in my_values:
pass
Pokud byste funkci `create_range` předali hodnoty 5 a 5, výsledkem by byla prázdná n-tice. A pokud byste ji chtěli iterovat, jednoduše byste neprovedli žádnou iteraci a kód by normálně pokračoval dál.
Na druhou stranu, kdyby prázdné n-tice neexistovaly a místo toho by se vracela hodnota `None`, pokus o iteraci by vyvolal chybu. Aby se program nezhroutil, museli byste ošetřit situaci, kdy funkce `create_range` vrací `None` nebo jinou hodnotu indikující prázdný výsledek.
To by vedlo ke složitějšímu kódu. V ideálním případě byste se chtěli vyhnout speciálním případům, jak jen to je možné. To znamená, že návratová hodnota všech funkcí by měla mít jednotné rozhraní, aby váš kód fungoval co nejvíce v obecném režimu. V tomto konkrétním případě to znamená vracet n-tici, i když by měla být občas prázdná.
Jak přistupovat k prvkům
Existují dva hlavní způsoby, jak získat přístup k prvkům n-tice v Pythonu. První metodou je indexování a druhá metoda je rozbalení prvků. Nejprve prozkoumáme, jak k prvkům přistupovat pomocí indexu.
Přístup k prvkům pomocí indexu
Přístup k prvkům pomocí indexu je podobný jako u seznamu. Používá se notace s hranatými závorkami. N-tice používají indexování od nuly, což znamená, že první prvek má index 0, druhý index 1 a tak dále až do posledního prvku.
Následující příklad ukazuje, jak k prvkům přistupovat pomocí indexu:
# Vytvoření n-tice values = (1, 2, 3, 4) # Přístup k prvnímu prvku first_element = values[0] # Přístup ke čtvrtému prvku (index 3) fourth_element = values[3]
Můžete také používat záporné indexy. Prvek s indexem -1 je poslední prvek a prvek s indexem -2 je předposlední prvek.
# Vytvoření n-tice values = (1, 2, 3, 4) # Přístup k poslednímu prvku last_element = values[-1] # Přístup k předposlednímu prvku second_from_last_element = values[-2]
Kromě toho můžete získat i podčásti prvků z n-tice jejím „rozřezáním“ (slicing). Zápis je následující: `
# Vytvoření n-tice values = (1, 2, 3, 4, 5, 6, 7) # Získání prvních tří prvků values[1:3] # Získání každého druhého prvku values[::2]
Iterace přes prvky
N-tice jsou iterovatelné objekty v Pythonu. Proto můžete jejich prvky procházet pomocí cyklu for, jak je ukázáno v následujícím příkladu:
values = (1, 2, 3, 4)
for value in values:
print(value)
Tento způsob přístupu k prvkům je ideální, pokud chcete zpracovat všechny prvky v n-tici.
Přístup k prvkům pomocí rozbalení (destructuring)
Pro ilustraci rozbalování zvažte následující situaci, kdy chceme získat různé prvky z n-tice.
# Vytvoření n-tice pro záznam informací o uživateli person_record = (1, 'John Doe', '[email protected]') # Přístup k různým prvkům n-tice pro použití v našem kódu id = person_record[1] name = person_record[2] email = person_record[3]
Python nám umožňuje používat pohodlnější metodu pro přístup k hodnotám, jak je znázorněno níže:
# Vytvoření n-tice pro záznam informací o uživateli person_record = (1, 'John Doe', '[email protected]') id, name, email = person_record
Tomuto se říká rozbalení (destructuring). To znamená, že první proměnné, v tomto případě `id`, bude přiřazena první hodnota z n-tice, druhé proměnné druhý prvek atd. až do konce n-tice. Výše uvedený příklad je ekvivalentní tomuto:
id, name, email = (1, 'John Doe', '[email protected]')
V tomto případě, místo uložení n-tice do proměnné, ji hned rozbalujeme. Když to zkombinujete se znalostí, že při vytváření n-tic nemusíte používat závorky, můžete kód zapsat takto:
id, name, email = 1, 'John Doe', '[email protected]'
Výsledkem je, že proměnné `id`, `name` a `email` budou obsahovat hodnoty 1, ‚John Doe‘ a ‚[email protected]‚. Jedná se o pohodlný a stručný způsob vytváření proměnných v Pythonu, s nímž se setkáte v produkčním kódu. Je dobré vědět, že jádrem této elegantní syntaxe je koncept n-tic.
Rozdíly mezi n-ticí a seznamem
Ačkoli jsou si tyto dva datové typy podobné, některé klíčové rozdíly určují, který z nich se více hodí pro konkrétní situaci. Pochopení těchto rozdílů vám pomůže zvolit nejvhodnější datový typ a napsat lepší a efektivnější kód.
| Aspekt | N-tice | Seznam |
| Ukládání do paměti | Uloženo v souvislé paměti | Uloženo v různých částech paměti |
| Modifikovatelnost | Neměnné (nelze měnit) | Měnitelné (lze měnit) |
| Rychlost přístupu | Rychlejší | Pomalejší |
| Datový typ | Obvykle ukládá data různých typů | Obvykle ukládá data stejného typu |
| Případy použití | Ukládání kolekce hodnot, které se nemění | Ukládání kolekce hodnot, které se mohou měnit |
Výhody n-tice
#1. Je rychlejší
Protože jsou hodnoty n-tice uloženy v souvislé oblasti paměti, je přístup k nim rychlejší ve srovnání se seznamem. Nicméně, vzhledem k tomu, že jednou vytvořené n-tice nelze měnit, nejsou vždy nejlepší datovou strukturou pro uchovávání kolekcí hodnot.
Jejich ideálním případem použití je ukládání velkého množství dat, která se nemění, ale bude se k nim opakovaně přistupovat během běhu programu. V takovém případě váš program výrazně získá ze zvýšeného výkonu n-tic.
#2. Vrácení více hodnot
N-tice lze použít pro vrácení více hodnot z funkce a následné rozbalení výsledku. Například:
from random import randint
def create_two_numbers():
first_num = randint(0, 9)
second_num = randint(0, 9)
return first_num, second_num
first_num, second_num = create_two_numbers()
V tomto příkladu máme funkci, která vygeneruje dvě náhodná čísla a vrátí je obě v n-tici. Příkaz `return first_num, second_num` je ekvivalentní zápisu `return (first_num, second_num)`. Závorky při vytváření n-tic jsou totiž volitelné. Pro získání hodnot následně rozbalíme výsledek.
#3. Hodnoty jsou chráněny proti zápisu
N-tice jsou po vytvoření neměnné. Jsou proto ideální pro ukládání dat, která se nemají během běhu programu měnit. Zajišťují, že nedojde k náhodnému přepsání dat někde jinde v kódu.
#4. Uložení více datových typů
N-tice umožňují ukládat hodnoty různých datových typů. To vám umožňuje vytvářet záznamy dat, jako je ukládání detailů uživatele do n-tice. Můžete ukládat i komplexnější prvky jako funkce, slovníky, další n-tice nebo dokonce i seznamy.
Běžné metody n-tice
#1. `count()`
Objekt n-tice má metodu `count()`, která spočítá, kolikrát se daný prvek v n-tici vyskytuje. Například:
# Vytvoření n-tice s několika čísly values = (1, 2, 3, 4, 5, 4, 4, 6) # Spočítání počtu výskytů čísla 4 n_fours = values.count(4) # Výpis počtu výskytů čísla 4 print(n_fours)
Z tohoto příkladu vidíme, že číslo 4 se v naší n-tici vyskytuje třikrát.
#2. `index()`
Metoda `index()` se používá k nalezení indexu prvního výskytu zadané hodnoty v n-tici. Pokud hodnota neexistuje, vyvolá se výjimka `ValueError`. Zde je ukázka kódu, který ilustruje, jak metoda `index()` funguje:
# Vytvoření n-tice s několika čísly
values = (1, 2, 3, 4, 5, 4, 4, 6)
# Hledání indexu čísla 4
index_of_four = values.index(4)
print("Index of four:", index_of_four)
# Hledání indexu čísla 9
index_of_nine = values.index(9)
print("Index of nine:", index_of_nine)
A když spustíme výše uvedený kód, získáme tento výstup:
V tomto případě je index čísla 4 roven 3 a kód proběhl bez problémů. Ale při pokusu o nalezení indexu čísla 9 program vyvolal výjimku. Při psaní programů v Pythonu, které používají metodu `index()`, je důležité tyto výjimky ošetřit.
#3. `len()`
Stejně jako všechny iterovatelné objekty v Pythonu, i n-tice mají vlastnost délky, ke které získáte přístup, když n-tici předáte jako argument funkci `len()`.
# Vytvoření n-tice values = (1, 2, 3, 4) # Získání délky n-tice length = len(values) # Výpis délky n-tice print(length)
Toto je výsledek spuštění výše uvedeného kódu.
#4. `min()` a `max()`
Metody `min()` a `max()` fungují tak, že iterují přes všechny prvky a porovnávají, zda je prvek větší, nebo menší než předchozí. Nakonec `max()` vrátí největší prvek v iterovatelném objektu, zatímco `min()` vrátí nejmenší.
U čísel je operace zřejmá. U řetězců Python použije abecední pořadí. Nejmenší slovo, vrácené pomocí `min()`, je první slovo v abecedním pořadí. Největší slovo je poslední slovo v abecedním pořadí. Pokud iterovatelný objekt obsahuje kombinaci různých datových typů, obě operace selžou, protože Python neví, jak porovnávat různé datové typy.
Zde je příklad kódu:
# Vytvoření n-tice s hodnotami values = (1, 2, 3, 4, 5) # Získání největší hodnoty largest = max(values) # Získání nejmenší hodnoty smallest = min(values) # Výpis výsledků print(largest) print(smallest)
#5. `sorted()`
Funkce `sorted()` v Pythonu přijímá iterovatelný objekt a vrací seznam seřazených prvků. Můžete zavolat funkci `sorted()`, předat jí n-tici a získat prvky n-tice seřazené v seznamu. Pro převod seřazeného seznamu zpět na n-tici lze použít konstruktor n-tice. Zde je příklad:
# Vytvoření n-tice s hodnotami v náhodném pořadí values = (1, 5, 3, 3, 2, 4) # Seřazení hodnot do seznamu pomocí funkce sorted sorted_list = sorted(values) # Převod seznamu na n-tici sorted_tuple = tuple(sorted_list) # Výpis výsledku print(sorted_tuple)
#6. Sčítání a násobení n-tic
Operace sčítání na dvou n-ticích je jednoduše spojí dohromady. Operace násobení opakuje prvky n-tice tolikrát, kolikrát je hodnota, kterou jste násobili. Zde je příklad pro ilustraci obou operací.
# Vytvoření n-tice s několika hodnotami
values = (1, 2, 3, 4, 5)
# Vytvoření nové n-tice pomocí sčítání
added = values + values
# Vytvoření nové n-tice pomocí násobení
multiplied = values * 2
print("values + values =", added)
print("values * 2 =", multiplied)
Závěrečná slova
V tomto článku jste se dozvěděli, že:
- N-tice jsou objekty podobné seznamům a používají se pro uchovávání kolekcí hodnot.
- Na rozdíl od seznamů jsou n-tice neměnné.
- Jsou rychlejší a efektivnější než seznamy.
- Mohou být vytvořeny pomocí kulatých závorek a oddělováním hodnot čárkami.
- Mohou být také vytvořeny pomocí konstruktoru n-tice.
- K jednotlivým hodnotám lze přistupovat pomocí indexového systému založeného na nule.
- Můžete také rozbalovat hodnoty z n-tice.
- Hodnoty můžete procházet pomocí cyklu for.
- Různé metody, které můžete s n-ticemi používat.
Dále byste se možná chtěli podívat na další materiály týkající se Pythonu, například na metody seznamů v Pythonu a metody slovníků v Pythonu.