Tuple är en inbyggd datatyp i Python som används för att lagra en samling data. Det liknar en lista men är något snabbare.
Dess begränsningar gör dock listor mer önskvärda i vissa situationer. I den här artikeln kommer jag att förklara allt du behöver veta för att komma igång med att använda tupler.
Innehållsförteckning
Vad är en Tuple?
Som nämnts tidigare är en tupel en av de inbyggda datatyperna i Python som används för att lagra datasamlingar. Den liknar en Python-lista genom att den lagrar data i ett iterabelt, arrayliknande format. Till skillnad från en lista är dock en tupel oföränderlig. Det vill säga, när de väl har skapats kan dess värden inte ändras.
Ytterligare element kan inte läggas till och befintliga element kan inte tas bort. En tuppel är därför idealisk när du lagrar data som inte förändras. Det kan till och med vara en samling data av olika typer. I nästa avsnitt kommer vi att diskutera de olika sätten att skapa tupler i Python.
Hur skapar man en Tuple i Python?
Det finns minst tre sätt att skapa tupler i Python. I det här avsnittet kommer vi att täcka tre av de vanligaste metoderna som du förmodligen kommer att använda och se när du läser kod från andra.
För att köra följande kodexempel måste du ha Python installerat. Om du inte redan har Python installerat, här är en användbar guide för att installera Python. Alternativt kan du köra din kod i en online Python-runtime som Google Colab.
#1. Använda Tuple Literal (parenteser)
Det vanligaste sättet att se tupler definierade i Python är genom att placera en samling värden mellan parenteser. Dessa värden separeras med kommatecken. Följande exempel illustrerar denna metod:
# Creates a tuple by placing values between parentheses values = (1, 2, 3) # Printing out the tuple to the screen print(values) # Printing out the type of values variable print(type(values))
Att köra denna kod kommer att producera följande:
Som du kan se från utgången håller tupeln värdena som vi initierade den med. Det är också av typen
När du skapar tupler i Python är parenteser inte nödvändiga. Därför är dessa värden = 1, 2, 3 lika giltiga som dessa värden = (1, 2, 3). Det rekommenderas dock att du använder parenteser för att göra din kod mer begriplig.
Att skapa tuplar med ett element i Python är lite knepigt. Istället för att bara placera ett element mellan parenteser måste du också lägga till ett avslutande kommatecken. Här är ett exempel för att illustrera:
# Without trailing comma, this won't create a tuple not_a_tuple = (1) # With trailing comma, this will create a tuple a_tuple = (1,) # Printing not_a_tuple print(not_a_tuple) # Printing not_a_tuple's data type print(type(not_a_tuple)) # Printing a_tuple print(a_tuple) # Printing a_tuple's data type print(type(a_tuple))
När du kör koden ovan kommer du att se att not_a_tuple blir en int av värde 1. Detta är viktigt att ha i åtanke när du skapar tupler.
#2. Använda konstruktörsfunktionen
Den andra metoden för att skapa tupler i Python använder tupelkonstruktorfunktionen. I den här metoden anropar du funktionen och skickar ett iterbart objekt som en lista som ett argument. Detta kommer att omvandlas till en tuppel. Här är ett exempel:
# Creating tuple from a list of values values = tuple([1, 2, 3]) # Printing out the values print(values) # Printing out the data type of the values identifier print(type(values))
Som du kan se uppnår du samma resultat som att använda den bokstavliga. Funktionen gör det dock möjligt för dig att skapa en tupel baserat på ett dynamiskt värde, till exempel en lista vars värden bara är kända under körning. Med den första metoden måste du känna till värdena eller identifierarna som utgör din tupel när du skriver koden.
#3. Skapa en tom tuppel
När du arbetar med tupler i din kod kan du behöva skapa tomma tupler. Tomma tupler skapas som du kan förvänta dig. Du kan använda antingen tuppelkonstruktorn eller bokstavlig till när du skapar dem. Här är ett exempel som visar hur man använder båda metoderna:
# Using the tuple literal empty_tuple_1 = () # Using the constructor empty_tuple_2 = tuple()
Tomma tuplar är användbara när du representerar en tom uppsättning resultat. Tänk på följande funktion:
def create_range(start, end):
return tuple(range(start, end))
Den här funktionen skapar en tupel med värden från början, upp till det slutvärde du skickar in. Om du ville iterera över resultatet av funktionen skulle du använda något i stil med detta:
my_values = create_range(0, 5)
for value in my_values:
pass
Om du angav 5 och 5 till create_range-funktionen skulle resultatet bli en tom tupel. Och om du försökte iterera över det, skulle du bara ha noll iterationer, och din kod skulle fortsätta som vanligt.
Å andra sidan, om det inte fanns några tomma tuplar, 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 implementera ett test för kantfallet att funktionen create_range returnerar None eller något annat värde som representerar en tom tupel.
Detta skulle leda till rörig kod. Helst skulle du vilja undvika speciella fall så mycket som möjligt. Detta innebär att returvärdet för alla funktioner bör ha ett identiskt gränssnitt så att din kod fungerar i det allmänna fallet så mycket som möjligt. I det här fallet innebär det att du returnerar en tuppel hela tiden, även om den ibland kommer att vara tom.
Hur man får åtkomst till element
Det finns två sätt att komma åt en tupels element i Python. Den första metoden är genom index, och den andra är genom att destrukturera elementen. Först kommer vi att undersöka hur man kommer åt element efter index.
Åtkomst till element via index
Att komma åt element via index liknar hur du skulle komma åt listelement efter index. Detta görs med notation med hakparenteser. Tuples använder ett nollbaserat indexeringssystem vilket betyder att det första elementet är index 0, och det efter är index 1 tills det sista elementet.
Exemplet nedan visar hur man kommer åt element efter index:
# Creating a tuple values = (1, 2, 3, 4) # Accessing the first element first_element = values[0] # Accessing the fourth element(index 3) fourth_element = values[3]
Du kan också använda negativ indexering. Elementet med index -1 är det sista elementet, och elementet med index -2 är det andra från det sista elementet.
# Creating the tuple values = (1, 2, 3, 4) # Accessing the last element last_element = values[-1] # Accessing the second from last element second_from_last_element = values[-2]
Dessutom kan du också komma åt undersamlingar av element från en tuppel genom att skära den. Det här liknar hur du skulle dela upp en lista. Notationen är som följer
# Creating the tuple values = (1, 2, 3, 4, 5, 6, 7) # Getting the first three elements values[1: 3] # Getting every other element values[::2]
Itererar över element
En tupel är ett iterbart objekt i Python. Därför kan du iterera över dess element med hjälp av en for-loop, som visas i följande exempel:
values = (1, 2, 3, 4)
for value in values:
print(value)
Denna metod för att komma åt element är idealisk när du vill komma åt alla element i tupeln.
Åtkomst till element genom att destrukturera
För att förklara destrukturering, överväg följande scenario där vi försöker få de olika elementen i en tupel.
# Creating the tuple to record a user's information person_record = (1, 'John Doe', '[email protected]') # Accessing the different elements in the tuple to use in our code id = person_record[1] name = person_record[2] email = person_record[3]
Python låter oss använda en mer bekväm metod för att komma åt värdena, som illustreras nedan:
# Creating the tuple to record a user's information person_record = (1, 'John Doe', '[email protected]') id, name, email = person_record
Detta kallas destrukturering. Det är den första variabeln, id i detta fall, kommer att tilldelas det första värdet i tupeln och den andra variabeln till det andra elementet. Detta fortsätter till slutet av tupeln. Ovanstående exempel motsvarar detta:
id, name, email = (1, 'John Doe', '[email protected]')
I det här fallet, istället för att lagra tupeln i en variabel, destrukturerar vi den omedelbart. När du kombinerar detta med vetskapen om att du inte behöver använda parenteser när du skapar tupler, då kan du skriva koden så här.
id, name, email = 1, 'John Doe', '[email protected]'
I slutet av allt detta kommer du att ha id-, namn- och e-postvariabler med värdena 1, ’John Doe’ och ’[email protected]’. Detta är ett bekvämt och kortfattat sätt att skapa variabler i Python som du kommer att se i produktionskoden. Det hjälper att veta att kärnan i denna eleganta syntax är begreppet tupler.
Skillnader mellan Tuple och List
Även om de två är lika, gör några viktiga skillnader var och en mer lämpad för ett visst användningsfall. Att förstå dessa skillnader hjälper dig att bestämma den bästa datatypen att använda och skriva bättre och effektivare kod.
AspectTupleListMemory StorageLagrade i sammanhängande minne Lagra i olika delar av minnet Förändringsbar (kan inte ändras) Föränderlig (kan ändras)SpeedAccess är snabbare Access är långsammareDatatyp Vanligtvis lagrar data av olika typer Vanligtvis lagrar data av samma typAnvändningsfall Används vanligtvis för att lagra en samling av t.ex. Används vanligtvis för att lagra en samling liknande värden såsom märken.
Fördelar med en Tuple
#1. Det är snabbare
På grund av hur värdena för en tuppel lagras i angränsande minne, går det snabbare att komma åt värdena jämfört med en lista. Men eftersom de väl har skapats kan de inte ändras, är tupler inte alltid den bästa datastrukturen att använda för att lagra samlingar av värden.
Deras idealiska användningsfall är att lagra massor av data i minnet som inte ändras men som kommer att nås flera gånger under programmets körning. I det här fallet kommer ditt program att gynnas enormt av prestandaökningen av tupler.
#2. Returnera flera värden
Du kan använda tupler för att returnera flera värden från en funktion och destrukturera resultatet. Till exempel:
from random import randint
def create_two_numbers():
first_num = randint(0, 9)
second_num = randint(0, 9)
return first_num, second_num
first_num, second_num = create_two_numbers()
I det här exemplet har vi en funktion som skapar två slumptal och returnerar dem båda i en tupel. Satsen return first_num, second_num motsvarar att skriva retur (första_num, andra_num). Detta beror på att parenteser är valfria när du skapar tupler. För att komma åt resultatet, destrukturerar vi det.
#3. Värden är skrivskyddade
Tuples är oföränderliga när de väl har skapats. De är därför idealiska för att lagra data i minnet som inte ändras under programkörning. De ser till att du inte av misstag skriver över data någon annanstans i din kod.
#4. Lagra flera datatyper
Tuples låter dig lagra värden av flera datatyper. Detta gör att du kan skapa register över data, som att lagra en användares uppgifter i en tupel. Du kan också lagra mer komplicerade objekt som funktioner, ordböcker, andra tupler och till och med listor.
Vanliga Tuple-metoder
#1. räkna()
Tupelobjektet innehåller räknemetoden, som räknar antalet gånger ett element förekommer. Till exempel:
# Creating a tuple with several numbers values = (1, 2, 3, 4, 5, 4, 4, 6) # Counting the number of fours n_fours = values.count(4) # Prining out the number of fours print(n_fours)
Från detta exempel kan vi se att siffran 4 förekommer exakt tre gånger i vår tupel.
#2. index()
Indexmetoden kan användas för att hitta indexet för den första förekomsten av ett värde i en tupel. Om värdet inte finns, kommer ett ValueError-undantag att kastas. Här är lite kod för att illustrera hur indexmetoden fungerar:
# Creating a tuple with several numbers
values = (1, 2, 3, 4, 5, 4, 4, 6)
# Search for index of 4
index_of_four = values.index(4)
print("Index of four:", index_of_four)
# Search for index of 9
index_of_nine = values.index(9)
print("Index of nine:", index_of_nine)
Och när vi kör koden ovan är detta utdata:
I det här fallet är indexet 4 3, och koden körde utan problem. Men när det gällde att hitta indexet 9 tog programmet upp ett undantag. Det är viktigt att hantera sådana undantag när du skriver Python-program som använder indexmetoden.
#3. len()
Som alla itererbara objekt i Python har tuples en length-egenskap som du kan komma åt när du skickar in tuplen som ett argument till len()-funktionen.
# Creating a tuple values = (1, 2, 3, 4) # Getting the length length = len(values) # Print the output print(length)
Detta är resultatet av att köra ovanstående kod.
#4. min() och max()
Min- och maxmetoderna fungerar genom att loopa igenom varje element i en iterabel och jämföra om den är större eller mindre än den före den. I slutändan kommer max att returnera det största elementet i iterabeln medan min returnerar det minsta.
Med siffror är operationen uppenbar. Med strängar kommer Python att använda alfabetisk ordning. Det minsta ordet, returnerat av min, är det första ordet om strängarna skrevs i alfabetisk ordning. Medan det största ordet är det sista ordet. Om den iterable innehåller en blandning av olika datatyper, kommer båda operationerna att misslyckas eftersom Python inte vet hur man jämför olika datatyper.
Här är ett kodexempel:
# Creating tuple with values values = (1, 2, 3, 4, 5) # Getting the largest value largest = max(values) # Getting the smallest value smallest = min(values) # Output the results print(largest) print(smallest)
#5. sorterad()
Den sorterade funktionen i Python tar in ett itererbart objekt och returnerar en lista över de sorterade elementen. Du kan anropa den sorterade funktionen, skicka in en tupel som ett 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:
# Creating a tuple with values in random order values = (1, 5, 3, 3, 2, 4) # Using sorted to sort the values into a list sorted_list = sorted(values) # Converting the list into a tuple sorted_tuple = tuple(sorted_list) # Printing the output print(sorted_tuple)
#6. Lägga till och multiplicera tupler
Adderingsoperationen på två tuplar sammanfogar dem helt enkelt. Multiplikationsoperationen upprepar elementen i en tupel lika många gånger som värdet du multiplicerat med. Här är ett exempel för att illustrera de två exemplen.
# Create a tuple with some values
values = (1, 2, 3, 4, 5)
# Create a new tuple using addition
added = values + values
# Create a new tuple using multiplication
multiplied = values * 2
print("values + values =", added)
print("values * 2 =", multiplied)
Slutord
I den här artikeln lärde du dig att:
- Tuples ä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 effektivare än listor.
- De kan konstrueras med hjälp av parenteser och separera värdena med kommatecken.
- De kan också konstrueras med hjälp av tupelkonstruktorfunktionen.
- Du kan komma åt enskilda värden med hjälp av ett nollbaserat indexsystem.
- Du kan också destrukturera värden från tupeln.
- Du kan också iterera över värden med en for-loop.
- De olika metoderna som du kan använda med en tuppel.
Därefter kanske du vill kolla in mer Python-innehåll, som Python List Methods och Python Dictionary Methods.