Als we het hebben over datastructuren, is het concept van tupel. Deze term, die veel wordt gebruikt in de wiskunde, programmeren en databases, is de sleutel tot het begrijpen van hoe moderne talen groepen informatie beheren. In dit artikel gaan we diepgaand ontdekken wat een tuple is, de kenmerken ervan en hoe ze worden gebruikt in verschillende programmeertalen zoals Python, Visual Basic en zelfs in relationele databases.
Een tupel is in essentie a geordende reeks waarden. In tegenstelling tot andere soorten verzamelingen, zoals lijsten, heeft het echter een bijzonderheid die het in bepaalde scenario's behoorlijk nuttig maakt: het is onveranderlijkheid. Dit betekent dat, zodra ze zijn gemaakt, de elementen waaruit het tupel bestaat, niet meer kunnen worden gewijzigd. Deze functie is vooral effectief als we ervoor willen zorgen dat gegevens niet per ongeluk of opzettelijk worden gewijzigd. Maar voordat we ons verdiepen in het gebruik en de kenmerken ervan, is het nuttig om de oorsprong ervan en de reden voor de terminologie ervan te begrijpen.
Oorsprong en generalisatie van tupels
De term tupel is afgeleid van een wiskundige generalisatie van termen zoals duo (twee elementen), Drievoudig (drie elementen), enzovoort. Van daaruit werd vastgesteld dat een reeks van n elementen (n is een geheel getal) wordt a genoemd n-tupel, als een manier om cijfers of gegevens te groeperen. Deze naam werd uitgebreid naar het gebruik ervan in programmeren en wiskunde, omdat tuples het mogelijk maken om met een eindig aantal elementen te werken, waarbij hun eigenschappen behouden blijven. orde en structuur.
In de wiskunde is de tupels Ze kunnen ook worden gezien als een uitwerking van geordende paren, waarbij een reeks invoer kan worden gedefinieerd door verschillende groeperingslagen. Op deze manier kan een n-tupel met meer dan twee elementen kan het worden weergegeven als een geordend paar van zijn eerste invoer en een sub-tuple die de rest van de invoer bevat. Dit idee van organisatie is overgebracht naar de wereld van programmeren, waar tupels Ze zijn een uiterst krachtig en flexibel hulpmiddel.
Belangrijkste kenmerken van Tuples
De tupels Ze worden gedefinieerd door een reeks kenmerken die ze uniek maken in vergelijking met andere datastructuren:
- Onveranderlijkheid: Eenmaal aangemaakt, is het niet meer mogelijk om de elementen van een tuple te wijzigen. Dit betekent dat we een waarde niet opnieuw kunnen toewijzen aan een specifieke positie binnen het tupel. Als een tupel bijvoorbeeld de waarde 3 in zijn eerste element bevat, zal het die waarde gedurende zijn hele levensduur behouden.
- Orde: De elementen in een tupel worden in een specifieke volgorde opgeslagen. In tegenstelling tot veel andere verzamelingen, zoals sets, is de volgorde waarin elementen worden ingevoerd niet willekeurig. De volgorde is belangrijk en wordt gerespecteerd wanneer we met de tuple omgaan.
- Verschillende soorten: In tegenstelling tot andere gegevenstypen, zoals arrays, kunnen tupels elementen van verschillende typen bevatten. Het is volkomen acceptabel dat een tuple zowel gehele getallen, strings als booleans bevat.
- Toegang via indexen: Net als lijsten bieden tupels toegang tot hun individuele elementen via indexen. Deze indices beginnen over het algemeen vanaf het getal 0. Bovendien zijn er tupels vergelijkbaar, is het mogelijk om de relaties daartussen te verifiëren op basis van de waarde van hun elementen.
Deze kenmerken maken de tupels Ze zijn ideaal voor situaties waarin we heterogene gegevens moeten groeperen en ervoor moeten zorgen dat deze niet per ongeluk veranderen tijdens de uitvoering van een programma. Een tupel zou bijvoorbeeld de juiste keuze zijn om coördinaten (x, y) in een vlak op te slaan, aangezien die waarden niet mogen worden gevarieerd nadat ze zijn gedefinieerd.
Gebruik van tupels in programmeertalen
Tupels in Python
In Python wordt de tupels Ze zijn een zeer veelzijdige en veelgebruikte datastructuur. Ze worden gedefinieerd met behulp van haakjes () en scheid de elementen met komma's. Een bijzonderheid van tupels in Python is dat ze, naast hun onveranderlijkheid, elementen van verschillende typen kunnen bevatten:
>>> t = (1, 'dos', 3)In dit voorbeeld hebben we a tupel met drie elementen: een geheel getal, een tekststring en nog een geheel getal. Als we proberen een van de elementen ervan te wijzigen, zoals het opnieuw toewijzen van de waarde van het eerste getal, zal Python een foutmelding retourneren:
>>> t[0] = 'uno'Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: 'tuple' object does not support item assignmentDe onmogelijkheid om tupels te wijzigen maakt ze zeer nuttige elementen als we onze gegevens willen beschermen tegen onbedoelde wijzigingen.
Bewerkingen met tupels in Python
Sommige van de bewerkingen die we met tupels in Python kunnen uitvoeren, zijn vergelijkbaar met de bewerkingen die we met lijsten kunnen uitvoeren:
- Toegang via indexen: We hebben toegang tot de elementen van een tupel met behulp van de bijbehorende index. Zoals reeds vermeld is de index in Python beginnen ze vanaf 0.
- Snijden of snijden: Het is mogelijk om delen van een tuple te extraheren met behulp van deze methode plak. We kunnen bijvoorbeeld een sub-tupel verkrijgen met de elementen op posities 1 en 2 van het tupel dat we eerder hebben gemaakt:
>>> t[1:3]Het resultaat is een nieuw tupel met de elementen:
('twee', 3)
Tupel-manipulatie: Hoewel tupels onveranderlijk zijn en we hun elementen niet rechtstreeks kunnen veranderen, is het mogelijk om de tupel opnieuw toe te wijzen aan een nieuwe variabele of meerdere tupels te combineren om een nieuwe te creëren. We kunnen bijvoorbeeld twee tupels optellen met behulp van de operator +:
>>> t = (1, 2) + (3, 4)>>> t(1, 2, 3, 4)Tupels in relationele databases
Op het gebied van databases is a tupel is een rij in een relationele databasetabel. Elke kolom in de tabel bevat een waarde die verband houdt met de tuple.
In een tabel met videogamespelers kan elke rij bijvoorbeeld een tupel vertegenwoordigen met de volgende structuur:
(Jugador: 'Luis', Puntuación: 25)
Hier bevat het tupel twee waarden: de naam van de speler en zijn score. In deze context zijn tuples erg handig omdat ze het mogelijk maken dat verschillende soorten gegevens (zoals strings en gehele getallen, zoals we hebben gezien) op een consistente manier met elkaar worden geassocieerd.
Geavanceerde Tuple-voorbeelden
In sommige programmeertalen, zoals Visual Basic, kunnen tupels eenvoudig worden gemaakt met behulp van haakjes en een reeks door komma's gescheiden waarden. Bovendien staat Visual Basic het gebruik van genaamd tupels, wat ons de flexibiliteit geeft om namen toe te wijzen aan elk element binnen een tupel.
Bijvoorbeeld een tupel met twee elementen kan een Booleaanse waarde en een teksttekenreeks zijn:
Dim holiday = (#07/04/2017#, "Independence Day", True)In dit geval is er een tupel met drie elementen gemaakt, waarbij de eerste een datum is, de tweede een tekenreeks en de derde een Booleaanse waarde.
Tuples en hun efficiëntie
Een ander aspect om in gedachten te houden is dat tupels, omdat ze onveranderlijk zijn, relatief efficiënter zijn in termen van tijd en geheugen dan lijsten. Dit komt omdat de programmeertaal, omdat deze onveranderd blijft, zijn interne structuur niet op dezelfde manier hoeft te beheren als bij een veranderlijke lijst. Dit is de reden waarom tupels de voorkeur verdienen wanneer grotere efficiëntie vereist is of wanneer de gegevens niet worden gewijzigd.
Converteren tussen lijsten en tupels
Tenslotte is het in veel programmeertalen mogelijk om een lijst om te zetten naar een tupel en omgekeerd. In Python kan dit eenvoudig worden gedaan met behulp van vooraf gedefinieerde functies tupel () y lijst().
>>> l = [1, 2, 3]>>> t = tuple(l)>>> t(1, 2, 3)Op dezelfde manier kunnen we een tupel naar een lijst converteren:
>>> t = (1, 2, 3)>>> l = list(t)>>> l[1, 2, 3]Deze flexibiliteit stelt ons in staat om de datastructuur te gebruiken die in elk geval het meest geschikt is, afhankelijk van de behoeften van het programma.
Kortom, tupels Ze zijn een essentieel hulpmiddel bij het programmeren en verwerken van complexe gegevens. Dankzij hun onveranderlijkheid en hun vermogen om heterogene gegevens te groeperen, zijn ze een uiterst nuttige structuur in een verscheidenheid aan contexten, van algoritme-optimalisatie tot gegevensrepresentatie in relationele databases. Als u een gegevenstype nodig heeft dat tijdens de uitvoering van uw programma onveranderd blijft, is de tupel een uitstekende keuze.