In dit artikel leer je alles over Python-tuples. Meer specifiek, wat zijn tupels, hoe u ze kunt maken, wanneer u ze moet gebruiken en welke methoden u moet kennen.
Video: Python-lijsten en Tuples
Een tuple in Python is vergelijkbaar met een lijst. Het verschil tussen de twee is dat we de elementen van een tupel niet kunnen wijzigen als deze eenmaal is toegewezen, terwijl we de elementen van een lijst kunnen wijzigen.
Een tupel maken
Een tuple wordt gemaakt door alle items (elementen) tussen haakjes te plaatsen (), gescheiden door komma's. De haakjes zijn optioneel, maar het is een goede gewoonte om ze te gebruiken.
Een tuple kan een willekeurig aantal items bevatten en ze kunnen van verschillende typen zijn (integer, float, lijst, string, etc.).
# 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)
Uitvoer
() (1, 2, 3) (1, 'Hallo', 3.4) ('muis', (8, 4, 6), (1, 2, 3))
Een tuple kan ook worden gemaakt zonder haakjes te gebruiken. Dit staat bekend als tuple-verpakking.
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
Uitvoer
(3, 4.6, 'hond') 3 4.6 hond
Het maken van een tuple met één element is een beetje lastig.
Eén element tussen haakjes hebben is niet voldoende. We hebben een komma nodig om aan te geven dat het in feite een tupel is.
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)) #
Uitvoer
Toegang tot Tuple Elements
Er zijn verschillende manieren waarop we toegang kunnen krijgen tot de elementen van een tupel.
1. Indexering
We kunnen de indexoperator gebruiken ()om toegang te krijgen tot een item in een tuple, waarbij de index begint bij 0.
Een tuple met 6 elementen heeft dus indices van 0 tot 5. Als je probeert toegang te krijgen tot een index buiten het tuple-indexbereik (6,7,… in dit voorbeeld), wordt een IndexError.
De index moet een geheel getal zijn, dus we kunnen geen float of andere typen gebruiken. Dit zal resulteren in TypeError.
Evenzo worden geneste tupels benaderd met behulp van geneste indexering, zoals weergegeven in het onderstaande voorbeeld.
# 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
Uitvoer
punten 4
2. Negatieve indexering
Python staat negatieve indexering toe voor zijn sequenties.
De index van -1 verwijst naar het laatste item, -2 naar het voorlaatste item enzovoort.
# 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))
Uitvoer
tp
3. Snijden
We hebben toegang tot een reeks items in een tuple door de dubbele punt van de slicing-operator te gebruiken :.
# 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(:))
Uitvoer
('r', 'o', 'g') ('p', 'r') ('i', 'z') ('p', 'r', 'o', 'g', 'r ',' a ',' m ',' i ',' z ')
Het snijden kan het beste worden gevisualiseerd door te kijken of de index tussen de elementen ligt, zoals hieronder wordt weergegeven. Dus als we toegang willen krijgen tot een bereik, hebben we de index nodig die het deel van het tupel zal snijden.
Element snijden in Python
Een tupel veranderen
In tegenstelling tot lijsten zijn tupels onveranderlijk.
Dit betekent dat elementen van een tuple niet kunnen worden gewijzigd nadat ze zijn toegewezen. Maar als het element zelf een veranderlijk gegevenstype is, zoals een lijst, kunnen de geneste items worden gewijzigd.
We kunnen ook een tuple aan verschillende waarden toekennen (herindeling).
# 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)
Uitvoer
(4, 2, 3, (9, 5)) ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
We can use + operator to combine two tuples. This is called concatenation.
We can also repeat the elements in a tuple for a given number of times using the * operator.
Both + and * operations result in a new tuple.
# Concatenation # Output: (1, 2, 3, 4, 5, 6) print((1, 2, 3) + (4, 5, 6)) # Repeat # Output: ('Repeat', 'Repeat', 'Repeat') print(("Repeat",) * 3)
Output
(1, 2, 3, 4, 5, 6) ('Repeat', 'Repeat', 'Repeat')
Deleting a Tuple
As discussed above, we cannot change the elements in a tuple. It means that we cannot delete or remove items from a tuple.
Deleting a tuple entirely, however, is possible using the keyword 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)
Output
Traceback (most recent call last): File "", line 12, in NameError: name 'my_tuple' is not defined
Tuple Methods
Methods that add items or remove items are not available with tuple. Only the following two methods are available.
Some examples of Python tuple methods:
my_tuple = ('a', 'p', 'p', 'l', 'e',) print(my_tuple.count('p')) # Output: 2 print(my_tuple.index('l')) # Output: 3
Output
2 3
Other Tuple Operations
1. Tuple Membership Test
We can test if an item exists in a tuple or not, using the keyword 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)
Output
True False True
2. Iterating Through a Tuple
We can use a for loop to iterate through each item in a tuple.
# Using a for loop to iterate through a tuple for name in ('John', 'Kate'): print("Hello", name)
Output
Hello John Hello Kate
Advantages of Tuple over List
Since tuples are quite similar to lists, both of them are used in similar situations. However, there are certain advantages of implementing a tuple over a list. Below listed are some of the main advantages:
- Over het algemeen gebruiken we tupels voor heterogene (verschillende) datatypes en lijsten voor homogene (vergelijkbare) datatypes.
- Omdat tupels onveranderlijk zijn, gaat het doorlopen van een tupel sneller dan met een lijst. Er is dus een lichte prestatieverbetering.
- Tuples die onveranderlijke elementen bevatten, kunnen als sleutel voor een woordenboek worden gebruikt. Bij lijsten is dit niet mogelijk.
- Als u gegevens heeft die niet veranderen, kunt u deze als tuple implementeren om te garanderen dat ze tegen schrijven beveiligd blijven.
