Úvod do Tuples v Pythonu
Z matematického hlediska lze n-tici definovat jako konečný uspořádaný seznam prvků. Nebo můžeme říci, že n-tice je uspořádaná kolekce, která se nemění. V pythonu význam zůstává stejný, v pythonových n-tách jsou odděleny čárkami a uzavřeny v závorkách např. (1, 3, 4, 'Sam', 9). V pythonu jsou n-tice a seznamy podobné pouze s 1 velkým rozdílem a 1 malým rozdílem. Hlavním rozdílem je to, že n-tice jsou neměnné (nelze je po vytvoření jednou změnit), zatímco seznamy jsou proměnlivé (lze je změnit po vytvoření), menší rozdíl je závorka (ne nutně: budeme diskutovat dále v článku) se používají k definování n-tic a pro seznam, používáme hranaté závorky.
Co je Tuple?
Pojďme pochopit, odkud jsme dostali tento pojmenovaný tuple:
Tento termín „tuple“ je v podstatě vytvořen pro abstrakci sekvence jako 1 je jednoduchá, 2 je dvojitá, 3 je trojitá, 4 je čtyřnásobná, 5 je pětinásobná, 6 je šestinásobná, 7 je pětinásobná, 7 je pětinásobná, … a tak dne…, n ‑ tuple, …, zde se jako předpony používají číslice z latinských názvů a n-tice se přidává jako přípona. Teď víme, jak vznikl termín n-tice.
Jak se v Pythonu používají n-tice?
Nyní pojďme diskutovat o tom, jak se v pythonu používají n-tice. Zábavný fakt; 0-tuple je vyslovován jako null tuple:
Jak již bylo zmíněno dříve, pythonové n-tice a seznamy jsou podobné dvěma základním rozdílům. První z nich je n-tice jsou neměnné, tj. Jakmile jsou vytvořeny, nemůžeme provádět žádné změny. Dá se říci, že se jedná o základní vlastnost, která je příčinou existence n-tic v pythonu, jinak jsou všechny ostatní funkce stejné pro n-tice i seznamy. Druhá závorka (probereme v další části).
Co je v Tuples neměnné?
Níže jsou uvedeny následující body, které nelze v tuplích změnit:
- Po vytvoření nelze n-tice přidat do n-tice. Nelze připojit ani rozšířit n-tice.
- Jakmile je jednou vytvořeno, nelze z n-tice odebrat položky. Tuples nemají žádnou metodu odstranění.
- Jeden jistě najde položky v n-tice, protože nalezení jakékoli položky nezmění n-tici.
Jaký je význam neměnitelnosti?
Níže jsou uvedeny body k čemu je význam neměnitelnosti:
- Immutability dělá Tuples rychleji než seznamy: Například pokud jeden definuje sadu konstantních hodnot. Je lepší iterovat pomocí n-tice místo seznamu.
- Díky zaměnitelnosti n-tic je kód bezpečnější: Pokud chceme „chránit data“ a neměnit je . Jeden by měl používat n-tici na místě seznamu. Použití n-tice znamená asertivní tvrzení, že poskytnuté údaje jsou konstantní a nelze je měnit.
- Dá se použít, jak se v Pythonu používají n-tice, Nelze použít Seznamy jako klíče slovníku, důvodem je, že seznamy jsou zaměnitelné.
Typy a vytváření n-tic
Nelze kategorizovat n-tice místo toho můžeme provádět řadu operací s n-ticemi. V této části budeme diskutovat o tom, jak vytvořit n-tici, a také budeme diskutovat o několika operacích, které lze na n-tách provádět:
1. Definujte n-tice dvěma způsoby
1. Chcete-li vytvořit n-tici, přiřaďte jednu proměnnou s více hodnotami oddělenými čárkami v závorkách.
Kód:
type1 = (1, 3, 4, 5, 'test')
print (type1)
Výstup:
2. Chcete-li vytvořit n-tici, přiřaďte jednu proměnnou s více hodnotami oddělenými čárkami bez závorek. Viz úvodní drobný rozdíl.
Kód:
type2= 1, 4, 6, 'exam', 'rate'
print(type2)
Výstup:
Můžeme definovat prázdnou n-tici:
Kód:
a = ( )
print(a)
Výstup:
2. Přístup k položkám v n-tici
K prvkům n-tice lze přistupovat několika způsoby, například indexováním, negativním indexováním, rozsahem atd.
Kód:
access_tuple = ('a', 'b', 1, 3, (5, 'x', 'y', 'z'))
print(access_tuple(0))
print(access_tuple(4)(1))
Výstup:
V případě, že hodnota indexu je mimo rozsah n-tice, provede se následující chyba.
Kód:
print(access_tuple(5))
Výstup:
Můžeme najít použití negativního indexování na n-ticích.
Kód:
access_tuple = ('a', 'b', 1, 3)
print(access_tuple(-1))
Výstup:
Můžeme najít řadu n-tic.
Kód:
access_tuple = ('a', 'b', 1, 3, 5, 'x', 'y', 'z')
print(access_tuple(2:5))
Výstup:
3. Zřetězení operace na n-tice
Zřetězení jednoduše znamená spojení věcí dohromady. Můžeme spojit n-tice dohromady. Zde si všimněte jedné věci, kterou můžeme provádět různé operace s n-ticemi bez změny vlastní definice.
Kód:
Tuple1 = (1, 3, 4)
Tuple2 = ('red', 'green', 'blue')
print (Tuple1 + Tuple2)
Výstup:
4. Hnízdní operace na Tuples
Vnoření jednoduše znamená místo nebo uloží jeden nebo více uvnitř druhého.
Kód:
Tuple1 = (1, 3, 4)
Tuple2 = ('red', 'green', 'blue')
Tuple3 = (Tuple1, Tuple2)
print (Tuple3)
Výstup:
5. Krájení na n-tice
Protože n-tice jsou neměnné, můžeme si vzít plátky jednoho n-tice a můžeme je umístit do jiného n-tice.
Kód:
Tuple1 = (1, 3, 4, 'test', 'red')
Sliced=(Tuple1(2:))
print (Sliced)
Výstup:
6. Nalezení délky n-tic
Najdeme délku n-tice, abychom zjistili, kolik hodnot je n-tice.
Kód:
Tuple1 = (1, 3, 4, 'test', 'red')
print(len(Tuple1))
Výstup:
7. Změna tuple
Jak víme, n-tice jsou neměnné. To znamená, že položky definované v n-tice nelze po vytvoření n-tice změnit.
Kód:
Tuple1 = (1, 3, 4, 'test', 'red')
Tuple1(1) =4
Výstup:
Zde máme jeden případ, pokud je položka v n-tice sama o sobě proměnným datovým typem, jako je seznam, lze vnořené položky změnit.
Kód:
tuple1 = (1, 2, 3, (4, 5))
tuple1(3)(0) = 7
print(tuple1)
Výstup:
8. Odstranění n-tice
Jak jsme již diskutovali dříve, nemůžeme měnit položky v n-tici. což také naznačuje, že nemůžeme odstranit položky z n-tice.
Kód:
Tuple1 = (1, 3, 4, 'test', 'red')
del (Tuple1(1))
Výstup:
Ale n-tici lze odstranit pomocí klíčového slova del () s n-ticí.
Kód:
Tuple1 = (1, 3, 4, 'test', 'red')
del (Tuple1)
print (Tuple1)
Výstup:
9. Členská zkouška na n-tice
To lze otestovat, zda položka existuje v n-tice nebo ne, klíčové slovo pro ni je.
Kód:
Tuple1 = (1, 3, 4, 'test', 'red')
print (1 in Tuple1)
print (5 in Tuple1)
Výstup:
10. Vestavěné funkce pro n-tice
Python má některé vestavěné funkce, které lze provádět přímo na n-ticích. Např. Max (), min (), len (), suma (), seřazené () atd.
max (tuple): Udává maximální hodnotu z tuple, zde je podmínkou, že tuple by neměla obsahovat hodnoty řetězce.
Kód:
tuple1 = (1, 2, 3, 6)
print(max(tuple1))
Výstup:
min (n-tice): Udává minimální hodnotu z n-tice, zde je podmínkou, že n-tice by neměla obsahovat hodnoty řetězce.
Kód:
tuple1 = (1, 2, 3, 6)
print(max(tuple1))
Výstup:
součet (tuple): Prvky v tuplu by měly být celá čísla pouze pro tuto operaci. Součet poskytne součet všech prvků v n-tici.
Kód:
tuple1 = (1, 2, 3, 6)
print(sum(tuple1))
Výstup:
sort (tuple): Pokud prvky nejsou uspořádány v pořadí, můžeme použít tříděnou vestavěnou funkci.
Kód:
tuple2= (1, 4, 3, 2, 1, 7, 6)
print(sorted(tuple2))
Výstup:
11. Použití Tuples jako klíčů ve slovnících
Víme, že n-tice jsou schopny hashovat (zůstává stejná po celou dobu životnosti) a seznam není. Jako klíče bychom měli používat n-tice k vytvoření složeného klíče a použít je ve slovníku.
Kód:
tuplekey = ()
tuplekey(('blue', 'sky')) = 'Good'
tuplekey(('red', 'blood')) = 'Bad'
print(tuplekey)
Výstup:
12. Tuple Packing and Unpacking
Při balení přiřazujeme hodnoty novému n-tici.
Kód:
person = ("Salman", '5 ft', "Actor")
print(person)
Při rozbalení extrahujeme hodnoty dostupné v n-tici zpět do proměnných. Zde je třeba mít na paměti jednu věc, přičemž se musí extrahovat, že počet rozbalovacích proměnných se musí rovnat počtu položek v n-tici.
Kód:
person = ("Salman", '5 ft', "Actor")
(name, height, profession) = person
print(name)
print(height)
print(profession)
13. Iterovat přes Tuple
Můžeme vytvořit iterační smyčku s n-ticemi.
Kód:
my_tuple = ("red", "Orange", "Green", "Blue")
# iterating over tuple elements
for colour in my_tuple:
print(colour)
Výstup:
14. tuple () Konstruktor
Jeden může vytvořit n-tice pomocí konstruktoru n-tice. Zde je třeba poznamenat, že k definování potřebujeme dvojité závorky.
Kód:
Constructortuple = tuple((1, 5, 8, 10))
print (Constructortuple)
Výstup:
Závěr - Tuples v Pythonu
Stručně řečeno, můžeme říci, že n-tice je v podstatě typ datové struktury, která je uspořádanou kolekcí a po vytvoření nemůže být změněna. Tuple s výjimkou neměnitelnosti a závorek se chová stejně jako seznam typů datových struktur v pythonu. V tomto článku jsme se zabývali různými operacemi týkajícími se n-tic, jak jsou vytvářeny a jaké operace lze na n-tách provádět. Tuples jsou jistě rychlejší než seznamy a zvyšují bezpečnost kódu.
Doporučené články
Toto je průvodce Tuplesem v Pythonu. Zde diskutujeme různé operace n-tic, jak jsou vytvářeny a co lze s n-ticemi dělat. Další informace naleznete také v dalších souvisejících článcích -
- Ukazatele v Pythonu
- Editory Pythonu
- Abstraktní třída v Pythonu
- Operace se soubory Python
- Proměnné v JavaScriptu
- Průvodce abstraktní třídou v C # s příkladem