Python-tuple
Python Tuple
In dit artikel leer je alles over Python-tupels. Meer specifiek, wat zijn tuples, hoe je ze maakt, wanneer je ze moet gebruiken en verschillende methoden waarmee je bekend moet zijn.
Video:Python-lijsten en tupels
Een tuple in Python is vergelijkbaar met een lijst. Het verschil tussen de twee is dat we de elementen van een tuple niet kunnen wijzigen als deze eenmaal is toegewezen, terwijl we de elementen van een lijst wel kunnen wijzigen.
Een tuple maken
Een tuple wordt gemaakt door alle items (elementen) tussen haakjes () . te plaatsen , gescheiden door comma's. De haakjes zijn optioneel, maar het is een goede gewoonte om ze te gebruiken.
Een tuple kan een willekeurig aantal items hebben en ze kunnen van verschillende typen zijn (integer, float, list, 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, 'Hello', 3.4)
('mouse', [8, 4, 6], (1, 2, 3)) Een tupel 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, 'dog') 3 4.6 dog
Een tuple maken met één element is een beetje lastig.
Het hebben van één element tussen haakjes is niet genoeg. We hebben een komma nodig om aan te geven dat het in feite een tuple is.
my_tuple = ("hello")
print(type(my_tuple)) # <class 'str'>
# Creating a tuple having one element
my_tuple = ("hello",)
print(type(my_tuple)) # <class 'tuple'>
# Parentheses is optional
my_tuple = "hello",
print(type(my_tuple)) # <class 'tuple'> Uitvoer
<class 'str'> <class 'tuple'> <class 'tuple'>
Toegang tot Tuple-elementen
Er zijn verschillende manieren waarop we toegang kunnen krijgen tot de elementen van een tuple.
1. Indexeren
We kunnen de indexoperator [] . gebruiken om toegang te krijgen tot een item in een tuple, waarbij de index begint bij 0.
Dus een tuple met 6 elementen heeft indices van 0 tot 5. Als u probeert toegang te krijgen tot een index buiten het tuple-indexbereik (6,7,... in dit voorbeeld) zal een IndexError worden gegenereerd. .
De index moet een geheel getal zijn, dus we kunnen geen float of andere typen gebruiken. Dit resulteert in TypeError .
Op dezelfde manier 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
p t s 4
2. Negatieve indexering
Python staat negatieve indexering toe voor zijn sequenties.
De index van -1 verwijst naar het laatste item, -2 naar het een na laatste 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
t p
3. Snijden
We kunnen toegang krijgen tot een reeks items in een tupel door de slice-operator dubbele punt : 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') Snijden kan het beste worden gevisualiseerd door de index te beschouwen als tussen de elementen, zoals hieronder weergegeven. Dus als we toegang willen tot een bereik, hebben we de index nodig die het deel van de tuple zal snijden.
Een tuple wijzigen
In tegenstelling tot lijsten zijn tuples 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 toewijzen (hertoewijzing).
# 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 kunnen + . gebruiken operator om twee tupels te combineren. Dit heet aaneenschakeling .
We kunnen ook herhalen de elementen in een tuple voor een bepaald aantal keren met behulp van de * telefoniste.
Beide + en * bewerkingen resulteren in een nieuwe tuple.
# Concatenation
# Output: (1, 2, 3, 4, 5, 6)
print((1, 2, 3) + (4, 5, 6))
# Repeat
# Output: ('Repeat', 'Repeat', 'Repeat')
print(("Repeat",) * 3) Uitvoer
(1, 2, 3, 4, 5, 6)
('Repeat', 'Repeat', 'Repeat') Een tuple verwijderen
Zoals hierboven besproken, kunnen we de elementen in een tupel niet wijzigen. Dit betekent dat we geen items uit een tuple kunnen verwijderen.
Het volledig verwijderen van een tuple is echter mogelijk met het trefwoord 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) Uitvoer
Traceback (most recent call last): File "<string>", line 12, in <module> NameError: name 'my_tuple' is not defined
Tuple-methoden
Methoden die items toevoegen of verwijderen zijn niet beschikbaar met tuple. Alleen de volgende twee methoden zijn beschikbaar.
Enkele voorbeelden van Python-tupelmethoden:
my_tuple = ('a', 'p', 'p', 'l', 'e',)
print(my_tuple.count('p')) # Output: 2
print(my_tuple.index('l')) # Output: 3 Uitvoer
2 3
Andere Tuple-bewerkingen
1. Tuple-lidmaatschapstest
We kunnen testen of een item in een tuple bestaat of niet, met behulp van het trefwoord 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) Uitvoer
True False True
2. Itereren door een tuple
We kunnen een for . gebruiken loop om elk item in een tupel te doorlopen.
# Using a for loop to iterate through a tuple
for name in ('John', 'Kate'):
print("Hello", name) Uitvoer
Hello John Hello Kate
Voordelen van Tuple boven lijst
Omdat tuples veel op lijsten lijken, worden ze allebei in vergelijkbare situaties gebruikt. Er zijn echter bepaalde voordelen aan het implementeren van een tuple boven een lijst. Hieronder staan enkele van de belangrijkste voordelen:
- Over het algemeen gebruiken we tupels voor heterogene (verschillende) gegevenstypen en lijsten voor homogene (vergelijkbare) gegevenstypen.
- Omdat tupels onveranderlijk zijn, is itereren door een tupel sneller dan met een lijst. Er is dus een lichte prestatieverbetering.
- Tuples die onveranderlijke elementen bevatten, kunnen worden gebruikt als sleutel voor een woordenboek. Met lijsten is dit niet mogelijk.
- Als je gegevens hebt die niet veranderen, zal de implementatie ervan als tuple garanderen dat ze beveiligd blijven tegen schrijven.
Python