V tomto článku se dozvíte vše o n-ticích Pythonu. Přesněji řečeno, co jsou to n-tice, jak je vytvořit, kdy je použít a jaké různé metody byste měli znát.
Video: Seznamy a n-tice Pythonu
N-tice v Pythonu je podobná seznamu. Rozdíl mezi těmito dvěma je v tom, že nemůžeme změnit prvky n-tice, jakmile je přiřazena, zatímco můžeme změnit prvky seznamu.
Vytvoření n-tice
N-tice je vytvořena umístěním všech položek (prvků) do závorek ()oddělených čárkami. Závorky jsou volitelné, je však dobré je používat.
Tuple může mít libovolný počet položek a může být různých typů (integer, float, list, string atd.).
# Different types of tuples # Empty tuple my_tuple = () print(my_tuple) # Tuple having integers my_tuple = (1, 2, 3) print(my_tuple) # tuple with mixed datatypes my_tuple = (1, "Hello", 3.4) print(my_tuple) # nested tuple my_tuple = ("mouse", (8, 4, 6), (1, 2, 3)) print(my_tuple)
Výstup
() (1, 2, 3) (1, 'Hello', 3.4) ('mouse', (8, 4, 6), (1, 2, 3))
Tuple lze také vytvořit bez použití závorek. Toto se nazývá balení n-tice.
my_tuple = 3, 4.6, "dog" print(my_tuple) # tuple unpacking is also possible a, b, c = my_tuple print(a) # 3 print(b) # 4.6 print(c) # dog
Výstup
(3, 4,6, „pes“) 3 4,6 psa
Vytvoření n-tice s jedním prvkem je trochu složité.
Mít jeden prvek v závorkách nestačí. Budeme potřebovat koncovou čárku, abychom naznačili, že se ve skutečnosti jedná o n-tici.
my_tuple = ("hello") print(type(my_tuple)) # # Creating a tuple having one element my_tuple = ("hello",) print(type(my_tuple)) # # Parentheses is optional my_tuple = "hello", print(type(my_tuple)) #
Výstup
Získejte přístup k prvkům n-tice
Existuje několik způsobů, jak můžeme přistupovat k prvkům n-tice.
1. Indexování
Můžeme použít operátor indexu ()pro přístup k položce v n-tici, kde index začíná od 0.
Takže n-tice, která má 6 prvků, bude mít indexy od 0 do 5. Pokus o přístup k indexu mimo rozsah indexu n-tice (6,7, … v tomto příkladu) vyvolá an IndexError.
Index musí být celé číslo, takže nemůžeme použít float nebo jiné typy. Výsledkem bude TypeError.
Podobně se k vnořeným n-ticím přistupuje pomocí vnořeného indexování, jak je znázorněno v níže uvedeném příkladu.
# Accessing tuple elements using indexing my_tuple = ('p','e','r','m','i','t') print(my_tuple(0)) # 'p' print(my_tuple(5)) # 't' # IndexError: list index out of range # print(my_tuple(6)) # Index must be an integer # TypeError: list indices must be integers, not float # my_tuple(2.0) # nested tuple n_tuple = ("mouse", (8, 4, 6), (1, 2, 3)) # nested index print(n_tuple(0)(3)) # 's' print(n_tuple(1)(1)) # 4
Výstup
body 4
2. Negativní indexování
Python umožňuje negativní indexování svých sekvencí.
Index -1 se vztahuje k poslední položce, -2 k druhé poslední položce atd.
# Negative indexing for accessing tuple elements my_tuple = ('p', 'e', 'r', 'm', 'i', 't') # Output: 't' print(my_tuple(-1)) # Output: 'p' print(my_tuple(-6))
Výstup
tp
3. Krájení
K řadě položek v n-tici můžeme přistupovat pomocí dvojtečky operátoru krájení :.
# Accessing tuple elements using slicing my_tuple = ('p','r','o','g','r','a','m','i','z') # elements 2nd to 4th # Output: ('r', 'o', 'g') print(my_tuple(1:4)) # elements beginning to 2nd # Output: ('p', 'r') print(my_tuple(:-7)) # elements 8th to end # Output: ('i', 'z') print(my_tuple(7:)) # elements beginning to end # Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z') print(my_tuple(:))
Výstup
('r', 'o', 'g') ('p', 'r') ('i', 'z') ('p', 'r', 'o', 'g', 'r ',' a ',' m ',' i ',' z ')
Krájení lze nejlépe vizualizovat zvážením indexu mezi prvky, jak je znázorněno níže. Takže pokud chceme získat přístup k rozsahu, potřebujeme index, který rozdělí část z n-tice.
Řezání prvků v Pythonu
Změna n-tice
Na rozdíl od seznamů jsou n-tice neměnné.
To znamená, že prvky n-tice nelze po přiřazení změnit. Pokud je však prvek sám o sobě proměnlivým datovým typem, jako je seznam, lze jeho vnořené položky změnit.
Můžeme také přiřadit n-tici různým hodnotám (nové přiřazení).
# Changing tuple values my_tuple = (4, 2, 3, (6, 5)) # TypeError: 'tuple' object does not support item assignment # my_tuple(1) = 9 # However, item of mutable element can be changed my_tuple(3)(0) = 9 # Output: (4, 2, 3, (9, 5)) print(my_tuple) # Tuples can be reassigned my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z') # Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z') print(my_tuple)
Výstup
(4, 2, 3, (9, 5)) ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
Můžeme použít +operátor ke kombinaci dvou n-tic. Tomu se říká zřetězení .
Můžeme také opakovat prvky v n-tici pro daný počet opakování pomocí *operátoru.
Obě +a *operace vést k novým tice.
# Concatenation # Output: (1, 2, 3, 4, 5, 6) print((1, 2, 3) + (4, 5, 6)) # Repeat # Output: ('Repeat', 'Repeat', 'Repeat') print(("Repeat",) * 3)
Výstup
(1, 2, 3, 4, 5, 6) ('Opakovat', 'Opakovat', 'Opakovat')
Odstranění n-tice
Jak bylo diskutováno výše, nemůžeme změnit prvky v n-tici. To znamená, že nemůžeme mazat nebo odstraňovat položky z n-tice.
Úplné odstranění n-tice je však možné pomocí klíčového slova del.
# Deleting tuples my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z') # can't delete items # TypeError: 'tuple' object doesn't support item deletion # del my_tuple(3) # Can delete an entire tuple del my_tuple # NameError: name 'my_tuple' is not defined print(my_tuple)
Výstup
Traceback (poslední hovor poslední): Soubor "", řádek 12, v NameError: název 'my_tuple' není definován
Metody n-tice
Metody, které přidávají nebo odebírají položky, nejsou u n-tice k dispozici. K dispozici jsou pouze následující dvě metody.
Několik příkladů metod řazené kolekce členů Pythonu:
my_tuple = ('a', 'p', 'p', 'l', 'e',) print(my_tuple.count('p')) # Output: 2 print(my_tuple.index('l')) # Output: 3
Výstup
2 3
Další operace n-tice
1. Tuple Membership Test
Můžeme pomocí klíčového slova otestovat, zda položka existuje v n-tici nebo ne in.
# Membership test in tuple my_tuple = ('a', 'p', 'p', 'l', 'e',) # In operation print('a' in my_tuple) print('b' in my_tuple) # Not in operation print('g' not in my_tuple)
Výstup
Pravda Nepravda Pravda
2. Iterace n-ticí
Můžeme použít forsmyčku k iteraci každou položkou v n-tici.
# Using a for loop to iterate through a tuple for name in ('John', 'Kate'): print("Hello", name)
Výstup
Ahoj John Ahoj Kate
Výhody řazené kolekce členů oproti seznamu
Vzhledem k tomu, že n-tice jsou docela podobné seznamům, obě se používají v podobných situacích. Existují však určité výhody implementace n-tice přes seznam. Níže jsou uvedeny některé z hlavních výhod:
- Obecně používáme n-tice pro heterogenní (různé) datové typy a seznamy pro homogenní (podobné) datové typy.
- Protože n-tice jsou neměnné, iterace n-ticí je rychlejší než u seznamu. Dochází tedy k mírnému zvýšení výkonu.
- Tice, které obsahují neměnné prvky, lze použít jako klíč pro slovník. U seznamů to není možné.
- Pokud máte data, která se nezmění, implementace jako n-tice zaručí, že zůstane chráněna proti zápisu.
