I Python finns en inbyggd datatyp som kallas tupler, vilken används för att organisera och lagra data i samlingar. De påminner om listor, men utmärker sig genom sin snabbhet. Trots detta, finns situationer där listor är mer fördelaktiga. I denna artikel kommer jag att redogöra för allt du behöver veta för att börja använda tupler.
Vad är en tupel?
En tupel, som tidigare nämnts, är en av de integrerade datatyperna i Python för hantering av datasamlingar. Den är lik en Python-lista, då den lagrar data i ett itererbart, arrayliknande format. En viktig skillnad är dock att en tupel är oföränderlig. Detta innebär att när en tupel väl har skapats, kan dess innehåll inte ändras.
Det går inte att lägga till fler element eller ta bort existerande. En tupel är därför idealisk för att lagra information som inte ska förändras. Den kan även innehålla en blandning av olika datatyper. I nästa avsnitt ska vi undersöka olika sätt att skapa tupler i Python.
Hur skapar man en tupel i Python?
Det finns flera sätt att skapa tupler i Python. I det här avsnittet kommer vi att granska tre vanliga metoder som du sannolikt kommer att använda och se när du läser andras kod.
För att köra följande kodexempel behöver du Python installerat. Om du inte redan har Python installerat, finns det guider online som hjälper dig med installationen. Alternativt kan du köra din kod i en online Python-miljö som Google Colab.
#1. Använda tupelliteraler (parenteser)
Det vanligaste sättet att se tupler definieras i Python är att placera en uppsättning värden inom parenteser. Dessa värden separeras med kommatecken. Här följer ett exempel som illustrerar metoden:
# Skapar en tupel genom att placera värden inom parenteser värden = (1, 2, 3) # Skriver ut tupeln på skärmen print(värden) # Skriver ut datatypen för variabeln värden print(type(värden))
När du kör koden ovan får du följande resultat:
Som utskriften visar, lagrar tupeln de värden som vi initialiserade den med. Den är också av typen <class ’tuple’>.
När du skapar tupler i Python är parenteser egentligen inte obligatoriska. Alltså är `värden = 1, 2, 3` lika korrekt som `värden = (1, 2, 3)`. Det rekommenderas dock att använda parenteser för att göra din kod mer lättläst.
Att skapa tupler med endast ett element är lite annorlunda. Istället för att bara placera ett element inom parenteser, måste du även lägga till ett avslutande kommatecken. Här är ett exempel för att illustrera detta:
# Utan kommatecken i slutet, skapas inte en tupel inte_en_tupel = (1) # Med kommatecken i slutet skapas en tupel en_tupel = (1,) # Skriver ut inte_en_tupel print(inte_en_tupel) # Skriver ut datatypen för inte_en_tupel print(type(inte_en_tupel)) # Skriver ut en_tupel print(en_tupel) # Skriver ut datatypen för en_tupel print(type(en_tupel))
När du kör den här koden kommer du att se att `inte_en_tupel` blir en integer med värdet 1. Detta är viktigt att notera när man skapar tupler.
#2. Använda konstruktorfunktionen
Den andra metoden för att skapa tupler i Python är att använda tuple-konstruktorfunktionen. Här anropar du funktionen och skickar in ett itererbart objekt, till exempel en lista, som argument. Det itererbara objektet omvandlas sedan till en tupel. Här är ett exempel:
# Skapar en tupel från en lista med värden värden = tuple([1, 2, 3]) # Skriver ut värdena print(värden) # Skriver ut datatypen för variabeln värden print(type(värden))
Som du kan se får du samma resultat som när du använder literaler. Funktionen ger dig dock möjligheten att skapa en tupel baserat på ett dynamiskt värde, till exempel en lista vars värden bara är kända vid körning. Med den första metoden måste du veta vilka värden eller identifierare som ingår i din tupel när du skriver koden.
#3. Skapa en tom tupel
När du arbetar med tupler i din kod kan du ibland behöva skapa tomma tupler. Det gör du på ett ganska självklart sätt. Du kan använda antingen tuple-konstruktorn eller literaler. Här är ett exempel som visar hur du använder båda metoderna:
# Använder tuple-literalen tom_tupel_1 = () # Använder konstruktorn tom_tupel_2 = tuple()
Tomma tupler är användbara när du vill representera en tom uppsättning av resultat. Tänk dig följande funktion:
def skapa_intervall(start, slut): return tuple(range(start, slut))
Denna funktion skapar en tupel med värden från `start` till, men inte inklusive `slut`. Om du ville iterera över resultatet av funktionen skulle du kunna göra något i stil med detta:
mina_värden = skapa_intervall(0, 5) for värde in mina_värden: pass
Om du skickade in 5 och 5 till `skapa_intervall`-funktionen skulle resultatet bli en tom tupel. Och om du försökte iterera över den, skulle du bara ha noll iterationer och din kod skulle fortsätta som vanligt.
Å andra sidan, om det inte fanns tomma tupler, och du istället fick värdet `None`, skulle det leda till ett fel om du försökte iterera över det. För att förhindra att programmet kraschar måste du lägga till ett test för att hantera det speciella fallet att funktionen `skapa_intervall` returnerar `None` eller något annat värde som representerar en tom tupel.
Detta skulle göra koden onödigt komplicerad. Helst vill man undvika specialfall så mycket som möjligt. Det innebär att returvärdet för alla funktioner bör ha ett liknande gränssnitt, så att koden fungerar på ett generellt sätt. I det här fallet betyder det att du returnerar en tupel hela tiden, även om den ibland kan vara tom.
Hur man får åtkomst till element
Det finns två metoder för att komma åt element i en tupel i Python. Den första är med index och den andra är genom att destrukturera elementen. Låt oss först granska hur man kommer åt element med hjälp av index.
Åtkomst till element via index
Att komma åt element via index liknar hur man får åtkomst till listelement. Man använder sig av hakparenteser. Tupler använder ett nollbaserat indexeringssystem, vilket innebär att det första elementet har index 0, det andra elementet har index 1, och så vidare.
Exemplet nedan visar hur du kommer åt element via index:
# Skapar en tupel värden = (1, 2, 3, 4) # Hämtar det första elementet första_elementet = värden[0] # Hämtar det fjärde elementet (index 3) fjärde_elementet = värden[3]
Du kan även använda negativ indexering. Elementet med index -1 är det sista elementet, och elementet med index -2 är det näst sista elementet.
# Skapar en tupel värden = (1, 2, 3, 4) # Hämtar det sista elementet sista_elementet = värden[-1] # Hämtar det näst sista elementet näst_sista_elementet = värden[-2]
Du kan också komma åt delar av element i en tupel genom att använda slicing. Det liknar hur du skulle dela upp en lista. Syntaxen är `[
# Skapar en tupel värden = (1, 2, 3, 4, 5, 6, 7) # Hämtar de tre första elementen värden[0:3] # Hämtar vartannat element värden[::2]
Itererar över element
En tupel är ett itererbart objekt i Python. Därför kan du iterera över dess element med en for-loop, som i följande exempel:
värden = (1, 2, 3, 4) for värde in värden: print(värde)
Denna metod för att komma åt element är bra när du vill nå alla element i tupeln.
Åtkomst till element genom att destrukturera
För att förklara destrukturering, tänk dig följande scenario där vi vill få ut de olika elementen i en tupel.
# Skapar en tupel med en användares information person_data = (1, 'John Doe', '[email protected]') # Hämtar de olika elementen i tupeln för att använda dem i koden id = person_data[0] namn = person_data[1] email = person_data[2]
Python ger oss ett smidigare sätt att komma åt värdena, som illustreras nedan:
# Skapar en tupel med en användares information person_data = (1, 'John Doe', '[email protected]') id, namn, email = person_data
Detta kallas destrukturering. Den första variabeln, `id` i detta fall, tilldelas det första värdet i tupeln, och den andra variabeln tilldelas det andra värdet. Detta fortsätter tills alla värden i tupeln har tilldelats. Exemplet ovan motsvarar följande:
id, namn, email = (1, 'John Doe', '[email protected]')
I det här fallet, istället för att spara tupeln i en variabel, destrukturerar vi den direkt. När du kombinerar detta med vetskapen om att du inte behöver använda parenteser när du skapar tupler, kan du skriva koden så här.
id, namn, email = 1, 'John Doe', '[email protected]'
Efter allt detta kommer du att ha variablerna `id`, `namn` och `email` med värdena 1, `John Doe` och `[email protected]`. Detta är ett smidigt och kortfattat sätt att skapa variabler i Python, som du kommer att se i produktionskod. Det är bra att veta att kärnan i denna eleganta syntax är konceptet tupler.
Skillnader mellan tupel och lista
Även om de två är lika, gör några viktiga skillnader att varje typ passar bättre för specifika användningsfall. Att förstå dessa skillnader hjälper dig att välja rätt datatyp och skriva bättre och mer effektiv kod.
| Aspekt | Tupel | Lista |
| Minneslagring | Lagras i sammanhängande minne | Lagras i olika delar av minnet |
| Förändringsbar | Oföränderlig (kan inte ändras) | Föränderlig (kan ändras) |
| Hastighet | Snabbare åtkomst | Långsammare åtkomst |
| Datatyp | Lagrar vanligtvis data av olika typer | Lagrar vanligtvis data av samma typ |
| Användningsfall | Används ofta för att lagra samlingar av t.ex. en persons namn och ålder. | Används ofta för att lagra samlingar med liknande värden, t.ex. poäng. |
Fördelar med en tupel
#1. Det är snabbare
Eftersom en tupels värden lagras i sammanhängande minne går det snabbare att komma åt dem, jämfört med en lista. Men eftersom de inte kan ändras efter att de väl har skapats är tupler inte alltid det bästa valet för att lagra samlingar av värden.
Det idealiska användningsfallet för tupler är att lagra stora mängder data i minnet som inte kommer att ändras, men som kommer att användas flera gånger under programmets körning. I sådana fall kommer ditt program att gynnas av prestandaförbättringen som tupler ger.
#2. Returnera flera värden
Du kan använda tupler för att returnera flera värden från en funktion och sedan destrukturera resultatet. Exempelvis:
from random import randint def skapa_två_tal(): första_tal = randint(0, 9) andra_tal = randint(0, 9) return första_tal, andra_tal första_tal, andra_tal = skapa_två_tal()
I detta exempel har vi en funktion som skapar två slumpmässiga tal och returnerar båda i en tupel. Uttrycket `return första_tal, andra_tal` motsvarar att skriva `return (första_tal, andra_tal)`. Detta beror på att parenteser är valfria när du skapar tupler. För att få ut resultatet destrukturerar vi det.
#3. Värden är skrivskyddade
Tupler är oföränderliga när de väl har skapats. De är därför perfekta för att lagra data i minnet som inte ska ändras under programmets körning. Det säkerställer att du inte av misstag råkar skriva över data någon annanstans i din kod.
#4. Lagra flera datatyper
Tupler tillåter dig att lagra värden av olika datatyper. Det gör att du kan skapa poster av data, som att lagra information om en användare i en tupel. Du kan även lagra mer komplexa objekt som funktioner, ordböcker, andra tupler och till och med listor.
Vanliga tuple-metoder
#1. count()
Tuple-objektet har en `count`-metod som räknar hur många gånger ett visst element förekommer. Till exempel:
# Skapar en tupel med flera tal värden = (1, 2, 3, 4, 5, 4, 4, 6) # Räknar antalet fyror antal_fyror = värden.count(4) # Skriver ut antalet fyror print(antal_fyror)
Från det här exemplet ser vi att talet 4 förekommer exakt tre gånger i vår tupel.
#2. index()
Metoden `index` kan användas för att hitta indexet för den första förekomsten av ett visst värde i en tupel. Om värdet inte finns kommer ett `ValueError`-undantag att kastas. Här är lite kod som illustrerar hur `index`-metoden fungerar:
# Skapar en tupel med flera tal
värden = (1, 2, 3, 4, 5, 4, 4, 6)
# Söker efter index för talet 4
index_för_fyra = värden.index(4)
print("Index för fyra:", index_för_fyra)
# Söker efter index för talet 9
index_för_nio = värden.index(9)
print("Index för nio:", index_för_nio)
Och när vi kör koden ovan får vi följande utskrift:
I detta fall är indexet för 4 lika med 3, och koden kördes utan problem. Men när det kom till att hitta indexet för 9, uppstod ett undantag. Det är viktigt att hantera sådana undantag när du skriver Python-program som använder `index`-metoden.
#3. len()
Precis som alla itererbara objekt i Python, har tupler en längdegenskap som du kan få fram genom att skicka in tupeln som argument till funktionen `len()`.
# Skapar en tupel värden = (1, 2, 3, 4) # Hämtar längden längd = len(värden) # Skriver ut längden print(längd)
Detta är resultatet av att köra koden ovan.
#4. min() och max()
Metoderna `min` och `max` fungerar genom att gå igenom varje element i ett itererbart objekt och jämföra om det är större eller mindre än det föregående elementet. `max` returnerar i slutändan det största elementet i det itererbara objektet, medan `min` returnerar det minsta.
När det gäller tal är funktionen ganska uppenbar. Med strängar använder Python alfabetisk ordning. Det minsta ordet, returnerat av `min`, är det första ordet om strängarna hade sorterats alfabetiskt. Det största ordet är då det sista ordet. Om det itererbara objektet innehåller en blandning av olika datatyper kommer båda operationerna att misslyckas, eftersom Python inte kan jämföra olika datatyper.
Här är ett kodexempel:
# Skapar en tupel med tal värden = (1, 2, 3, 4, 5) # Hämtar det största talet största = max(värden) # Hämtar det minsta talet minsta = min(värden) # Skriver ut resultaten print(största) print(minsta)
#5. sorted()
Funktionen `sorted` i Python tar ett itererbart objekt och returnerar en lista med de sorterade elementen. Du kan anropa funktionen `sorted`, skicka in en tupel som argument, och få elementen i tupeln sorterade i en lista. För att konvertera den sorterade listan till en tupel, kan du använda konstruktorfunktionen. Här är ett exempel:
# Skapar en tupel med värden i slumpmässig ordning värden = (1, 5, 3, 3, 2, 4) # Använder sorted för att sortera värdena i en lista sorterad_lista = sorted(värden) # Konverterar listan till en tupel sorterad_tupel = tuple(sorterad_lista) # Skriver ut resultatet print(sorterad_tupel)
#6. Lägga till och multiplicera tupler
Additionsoperationen på två tupler slår helt enkelt ihop dem. Multiplikationsoperationen upprepar elementen i en tupel det antal gånger som värdet du multiplicerar med. Här är ett exempel som illustrerar båda operationerna.
# Skapar en tupel med några värden
värden = (1, 2, 3, 4, 5)
# Skapar en ny tupel med addition
adderad = värden + värden
# Skapar en ny tupel med multiplikation
multiplicerad = värden * 2
print("värden + värden =", adderad)
print("värden * 2 =", multiplicerad)
Slutord
I den här artikeln har du lärt dig att:
- Tupler är listliknande objekt som används för att lagra samlingar av värden.
- Till skillnad från listor är de oföränderliga.
- De är snabbare och mer effektiva än listor.
- De kan skapas med hjälp av parenteser där man separerar värdena med kommatecken.
- De kan också skapas med hjälp av konstruktorfunktionen `tuple`.
- Du kan komma åt enskilda värden med hjälp av ett nollbaserat indexeringssystem.
- Du kan också destrukturera värden från tupeln.
- Du kan också iterera över värden med en for-loop.
- Det finns olika metoder du kan använda med en tupel.
Härnäst kanske du vill läsa mer om andra Python-funktioner som Listmetoder och Metoder för Python-ordböcker.