Inleiding tot Tuples in Python
Vanuit wiskundig oogpunt kan een tuple worden gedefinieerd als een eindige geordende lijst met elementen. Of we kunnen zeggen dat tuple een geordende verzameling is die niet kan worden gewijzigd. In python blijft de betekenis hetzelfde, in python worden tupels gescheiden door komma's en omsloten door haakjes voor bijvoorbeeld (1, 3, 4, 'Sam', 9). In python zijn tupels en lijsten alleen vergelijkbaar met 1 groot verschil en 1 klein verschil. Het belangrijkste verschil is dat tupels onveranderlijk zijn (kan niet worden gewijzigd nadat ze zijn gemaakt), terwijl lijsten muteerbaar zijn (kunnen worden gewijzigd na het maken), het kleine verschil is haakjes (niet noodzakelijk: we zullen later in het artikel bespreken) worden gebruikt om tupels te definiëren en voor een lijst, we gebruiken vierkante haken.
Wat is Tuple?
Laten we begrijpen waar we dit met de naam tuple vandaan hebben:
Deze term 'tuple' is in principe ontstaan voor de abstractie van de reeks zoals 1 is enkel, 2 is dubbel, 3 is drievoudig, 4 is viervoudig, 5 is vijfvoudig, 6 is zesvoudig, 7 is zevenvoudig, 8 is achtvoudig, … en zo op …, n ‑tuple, …, hier worden cijfers van Latijnse namen gebruikt als voorvoegsels en tuple wordt toegevoegd als een achtervoegsel. Dus nu weten we hoe de term tuple is ontstaan.
Hoe Tuples worden gebruikt in Python?
Laten we nu bespreken hoe tupels worden gebruikt in python. Leuk weetje; een 0-tuple wordt uitgesproken als een nul-tuple:
Zoals eerder besproken in python zijn tupels en lijsten vergelijkbaar met twee basisverschillen. De eerste is dat tupels onveranderlijk zijn, dat wil zeggen dat we na het maken geen wijzigingen kunnen aanbrengen. Je kunt zeggen dat dit de basiseigenschap is, die de oorzaak is van het bestaan van tupels in python, anders zijn alle andere functies hetzelfde voor zowel tupels als lijsten. Tweede haakje (we zullen dit in de volgende sectie bespreken).
Wat is onveranderlijk in Tuples?
Hieronder staan de volgende punten voor onveranderlijk in tupels:
- Men kan geen items aan een tuple toevoegen nadat deze is gemaakt. Tuples kunnen niet worden toegevoegd of uitgebreid.
- Men kan geen items uit een tuple verwijderen nadat deze is gemaakt. Tuples hebben geen verwijderingsmethode.
- Je kunt zeker items in een tuple vinden, omdat het vinden van een item geen wijzigingen in de tuple aanbrengt.
Wat is de betekenis van onveranderlijkheid?
Hieronder staan de punten voor Wat is de betekenis van onveranderlijkheid:
- Onveranderlijkheid maakt Tuples sneller dan de lijsten: bijvoorbeeld als men een set constante waarden definieert. Het is beter om door tuple te bladeren in plaats van een lijst.
- De onveranderlijkheid van tupels maakt iemands code veiliger: als iemand de gegevens wil "schrijven beschermen" en niet wil worden gewijzigd. Men moet een tupel gebruiken op de plaats van een lijst. Het gebruik van tuple impliceert een assertieve verklaring dat de verstrekte gegevens constant zijn en niet kunnen worden gewijzigd.
- Men kan gebruiken hoe tupels worden gebruikt in python, men kan geen lijsten gebruiken als woordenboeksleutels, de reden is dat de lijsten veranderlijk zijn.
Typen en Tuples maken
We kunnen tuples niet categoriseren. In plaats daarvan kunnen we een aantal bewerkingen met tuples uitvoeren. In deze sectie zullen we bespreken hoe een tuple te maken, en ook zullen we een aantal bewerkingen bespreken die op tuples kunnen worden uitgevoerd:
1. Definieer Tuples op twee manieren
1. Om een tuple te maken, wijst u een enkele variabele toe met meerdere waarden gescheiden door komma's tussen haakjes.
Code:
type1 = (1, 3, 4, 5, 'test')
print (type1)
Output:
2. Om een tuple te maken, wijst u een enkele variabele toe met meerdere waarden gescheiden door komma's zonder haakjes. Zie introductie klein verschil.
Code:
type2= 1, 4, 6, 'exam', 'rate'
print(type2)
Output:
We kunnen lege tupels definiëren:
Code:
a = ( )
print(a)
Output:
2. Toegang tot items in een Tuple
Men kan op verschillende manieren toegang krijgen tot de elementen van een tuple, zoals indexering, negatieve indexering, bereik, etc.
Code:
access_tuple = ('a', 'b', 1, 3, (5, 'x', 'y', 'z'))
print(access_tuple(0))
print(access_tuple(4)(1))
Output:
In het geval dat de indexwaarde buiten het bereik van tuple valt, zal dit de volgende fout veroorzaken.
Code:
print(access_tuple(5))
Output:
We kunnen het gebruik van negatieve indexering op tupels vinden.
Code:
access_tuple = ('a', 'b', 1, 3)
print(access_tuple(-1))
Output:
We kunnen een aantal tupels vinden.
Code:
access_tuple = ('a', 'b', 1, 3, 5, 'x', 'y', 'z')
print(access_tuple(2:5))
Output:
3. Aaneenschakeling op Tuples
Samenvoeging betekent eenvoudigweg dingen aan elkaar koppelen. We kunnen tupels samenvoegen. Let hier op één ding dat we verschillende bewerkingen op tuples kunnen uitvoeren zonder de eigen definitie te wijzigen.
Code:
Tuple1 = (1, 3, 4)
Tuple2 = ('red', 'green', 'blue')
print (Tuple1 + Tuple2)
Output:
4. Nestbewerking op Tuples
Nesten betekent eenvoudigweg de plek of de een of meer in de andere opslaan.
Code:
Tuple1 = (1, 3, 4)
Tuple2 = ('red', 'green', 'blue')
Tuple3 = (Tuple1, Tuple2)
print (Tuple3)
Output:
5. Slicing-bewerking op Tuples
Omdat tupels onveranderlijk zijn, maar we kunnen plakjes van één tuple nemen en die plakjes in een andere tuple plaatsen.
Code:
Tuple1 = (1, 3, 4, 'test', 'red')
Sliced=(Tuple1(2:))
print (Sliced)
Output:
6. De lengte van Tuples vinden
We kunnen de lengte van de tuple vinden om te zien hoeveel waarden er in een tuple zijn.
Code:
Tuple1 = (1, 3, 4, 'test', 'red')
print(len(Tuple1))
Output:
7. Een Tuple veranderen
Zoals we weten dat de tupels onveranderlijk zijn. Dit betekent dat items die in een tuple zijn gedefinieerd, niet meer kunnen worden gewijzigd nadat de tuple is gemaakt.
Code:
Tuple1 = (1, 3, 4, 'test', 'red')
Tuple1(1) =4
Output:
Hier hebben we één geval, als het item in tuple zelf een veranderlijk gegevenstype zoals lijst is, kunnen de geneste items worden gewijzigd.
Code:
tuple1 = (1, 2, 3, (4, 5))
tuple1(3)(0) = 7
print(tuple1)
Output:
8. Een Tuple verwijderen
Zoals we eerder hebben besproken, kunnen we de items in een tuple niet wijzigen. wat ook suggereert dat we geen items uit de tuple kunnen verwijderen.
Code:
Tuple1 = (1, 3, 4, 'test', 'red')
del (Tuple1(1))
Output:
Maar men kan een tuple verwijderen door het sleutelwoord del () met een tuple te gebruiken.
Code:
Tuple1 = (1, 3, 4, 'test', 'red')
del (Tuple1)
print (Tuple1)
Output:
9. Lidmaatschapstest op Tuples
Dit kan worden getest of een item bestaat in een tuple of niet, het trefwoord hiervoor staat in.
Code:
Tuple1 = (1, 3, 4, 'test', 'red')
print (1 in Tuple1)
print (5 in Tuple1)
Output:
10. Ingebouwde functies voor Tuples
Python heeft een aantal ingebouwde functies die rechtstreeks op de tupels kunnen worden uitgevoerd. Voor bijvoorbeeld max (), min (), len (), sum (), gesorteerd () etc.
max (tuple): het geeft de maximale waarde van de tuple, hier moet de voorwaarde tuple geen stringwaarden bevatten.
Code:
tuple1 = (1, 2, 3, 6)
print(max(tuple1))
Output:
min (tuple): het geeft de minimumwaarde van de tuple, hier moet de voorwaarde tuple geen stringwaarden bevatten.
Code:
tuple1 = (1, 2, 3, 6)
print(max(tuple1))
Output:
sum (tuple): de elementen in een tuple mogen alleen gehele getallen zijn voor deze bewerking. De som geeft een samenvatting van alle elementen in de tuple.
Code:
tuple1 = (1, 2, 3, 6)
print(sum(tuple1))
Output:
gesorteerd (tuple): als de elementen niet in volgorde zijn gerangschikt, kunnen we de gesorteerde ingebouwde functie gebruiken.
Code:
tuple2= (1, 4, 3, 2, 1, 7, 6)
print(sorted(tuple2))
Output:
11. Gebruik van Tuples als sleutels in Woordenboeken
We weten dat tuples hash-staat zijn (blijft hetzelfde gedurende de hele levensduur), en de lijst is dat niet. We moeten tupels als sleutels gebruiken om een samengestelde sleutel te maken en deze in een woordenboek gebruiken.
Code:
tuplekey = ()
tuplekey(('blue', 'sky')) = 'Good'
tuplekey(('red', 'blood')) = 'Bad'
print(tuplekey)
Output:
12. Tuple verpakken en uitpakken
Bij het verpakken wijzen we de waarden toe aan een nieuwe tuple.
Code:
person = ("Salman", '5 ft', "Actor")
print(person)
Bij het uitpakken extraheren we de beschikbare waarden in een tuple terug in variabelen. Hier moet één ding in gedachten worden gehouden terwijl wordt geëxtraheerd dat het aantal uitpakkende variabelen gelijk moet zijn aan het aantal items in de tuple.
Code:
person = ("Salman", '5 ft', "Actor")
(name, height, profession) = person
print(name)
print(height)
print(profession)
13. Doorloop een Tuple
We kunnen een itererende lus vormen met tupels.
Code:
my_tuple = ("red", "Orange", "Green", "Blue")
# iterating over tuple elements
for colour in my_tuple:
print(colour)
Output:
14. tuple () Constructor
Je kunt tupels maken met een tuple-constructor. Hier moet één ding worden opgemerkt dat we dubbele haakjes nodig hebben om te definiëren.
Code:
Constructortuple = tuple((1, 5, 8, 10))
print (Constructortuple)
Output:
Conclusie Tuples in Python
Kort samengevat kunnen we zeggen dat een tuple in feite een soort gegevensstructuur is die een geordende verzameling is en niet kan worden gewijzigd nadat deze is gemaakt. Een tuple behalve onveranderbaarheid en haakjes gedraagt zich hetzelfde als het lijsttype van gegevensstructuur in python. In dit artikel hebben we verschillende bewerkingen behandeld die betrekking hebben op tupels, hoe ze worden gemaakt en welke bewerkingen op de tupels kunnen worden uitgevoerd. Tuples zijn zeker sneller dan de lijsten en maken de code veiliger.
Aanbevolen artikelen
Dit is een gids voor Tuples in Python. Hier bespreken we verschillende tuples-bewerkingen, hoe ze worden gevormd en wat er op de tuples kan worden gedaan. U kunt ook onze andere gerelateerde artikelen doornemen voor meer informatie -
- Aanwijzingen in Python
- Python-editors
- Abstracte klasse in Python
- Python-bestandsbewerkingen
- Variabelen in JavaScript
- Handleiding voor abstracte klasse in C # met voorbeeld