I denna handledning kommer vi att utforska likheterna och skillnaderna mellan tupler och listor i Python. Vi kommer även att undersöka situationer där användningen av en tupel är att föredra.
Både listor och tupler är grundläggande datastrukturer i Python. De används för att lagra samlingar av element.
Trots att de båda stödjer indexering, slicing och kan innehålla blandade datatyper, kan det vara svårt att välja mellan tupler och listor. Genom att förstå deras likheter och skillnader kan du fatta välgrundade beslut om vilken datastruktur som är mest lämplig i en given situation.
Låt oss börja med att utforska detta.
👩🏽💻 För att följa med i den här handledningen kan du antingen starta en Python REPL eller använda en online Python-editor som adminvista.com.
Skillnader och likheter: Python Tupler kontra Listor
Låt oss börja med att jämföra likheterna mellan listor och tupler med hjälp av praktiska exempel.
#1. Python Itererbara Objekt
Listor i Python definieras med hakparenteser, medan tupler omges av parenteser. En tupel kan också skapas genom att separera värden med kommatecken, utan parenteser.
Båda är itererbara, vilket innebär att du kan gå igenom dem med en for-loop.
Nedan visas ett kodexempel som illustrerar hur man itererar genom en lista.
nums = [2,6,7,10]
print(f"Typen av nums är {type(nums)}")
for num in nums:
print(num)
# Output
Typen av nums är <class 'list'>
2
6
7
10
På liknande sätt kan vi iterera genom en tupel med hjälp av en loop, vilket följande exempel visar:
nums = (2,6,7,10)
# Obs: nums = 2,6,7,10 är också en giltig tupel. Verifiera om det behövs!
print(f"Typen av nums är {type(nums)}")
for num in nums:
print(num)
# Output
Typen av nums är <class 'tuple'>
2
6
7
10
#2. Skapande från Sekvenser
En annan likhet är att både listor och tupler kan skapas från befintliga sekvenser som strängar.
sample_str = "Kodning!"
Följande kod visar hur `list(sträng)` returnerar en lista, där varje listelement är ett tecken från strängen.
list_from_str = list(sample_str) print(list_from_str) # Output ['K', 'o', 'd', 'n', 'i', 'n', 'g', '!']
På liknande sätt kan vi använda `tuple(sekvens)` för att skapa en tupel från en sträng eller annan sekvens. Följande kod illustrerar detta:
tuple_from_str = tuple(sample_str)
print(tuple_from_str)
# Output
('K', 'o', 'd', 'n', 'i', 'n', 'g', '!')
#3. Indexering och Skivning
Python använder nollbaserad indexering, där det första elementet har index 0, det andra index 1, och så vidare. Negativ indexering är också möjlig, med -1 för det sista elementet, -2 för det näst sista, och så vidare.
list_from_str = ['K', 'o', 'd', 'n', 'i', 'n', 'g', '!'] print(list_from_str[1]) # o
Elementet med index -2 är det näst sista, ’g’.
tuple_from_str = ('K', 'o', 'd', 'n', 'i', 'n', 'g', '!')
print(tuple_from_str[-2])
# g
Skivning används för att extrahera delar av en lista eller tupel. `lista[start:slut]` returnerar en del av listan från `start`-indexet upp till (men inte inklusive) `slut`-indexet. Standardvärdet för `start` är 0 och standardvärdet för `slut` är det sista elementet.
Tupler kan skivas med samma syntax. Låt oss skapa delar av listan och tuplerna vi skapade tidigare.
list_from_str = ['K', 'o', 'd', 'n', 'i', 'n', 'g', '!'] print(list_from_str[0:5]) ['K', 'o', 'd', 'n', 'i']
Utöver start- och slutvärden kan vi även ange ett stegvärde med syntaxen `tuple[start:slut:steg]`. Detta returnerar en del av tuplen, från `start` till `slut`-1, med steg i `steg`.
tuple_from_str = ('K', 'o', 'd', 'n', 'i', 'n', 'g', '!')
print(tuple_from_str[::2])
('K', 'd', 'i', 'g')
I detta exempel har vi satt stegvärdet till 2, vilket resulterar i att vartannat element ingår i resultatet.
#4. Samlingar av Blandade Datatyper
I de tidigare exemplen har elementen i listorna och tuplerna varit av samma datatyp.
Det är dock fullt möjligt att lagra värden av olika datatyper i en och samma lista eller tupel.
I kodexemplet nedan innehåller `student_list` en elevs namn (sträng), ålder (heltal) och betyg (flyttal).
student_list = ["John",22,96.5]
for item in student_list:
print(f"{item} är av typen {type(item)}")
# Output
John är av typen <class 'str'>
22 är av typen <class 'int'>
96.5 är av typen <class 'float'>
Vi kan skapa ett liknande exempel för en tupel:
student_tuple = ("Jane",23,99.5)
for item in student_tuple:
print(f"{item} är av typen {type(item)}")
# Output
Jane är av typen <class 'str'>
23 är av typen <class 'int'>
99.5 är av typen <class 'float'>
#5. Stöd för Medlemstest
Både listor och tupler låter dig kontrollera om ett visst objekt finns med i samlingen. Detta görs med operatorn `in`.
Uttrycket `objekt in itererbart` utvärderas till `True` om det itererbara objektet innehåller det specificerade objektet, annars `False`.
"Alex" in student_list # False "Jane" in student_tuple # True
Hittills har vi utforskat likheterna mellan listor och tupler i Python. Låt oss nu undersöka de viktigaste skillnaderna mellan dessa datastrukturer.
Skillnaderna: Python Tupler kontra Listor
#1. Föränderlighet
Den mest grundläggande skillnaden mellan listor och tupler är att tupler är oföränderliga. Det betyder att du inte kan ändra en tupel när den väl har skapats.
▶️ Här är ett exempel:
tuple1 = ("Java","Python","C++")
tuple1[0] = "Rust"
# Output
----> 2 tuple1[0] = "Rust"
TypeError: 'tuple' objekt stöder inte tilldelning av element
Listor däremot är föränderliga. Vi kan alltså ändra listan genom att tilldela nya värden till element på specifika index, som visas i följande kodexempel:
list1 = ["Java","Python","C++"] list1[0] = "Rust" print(list1) # Output ['Rust', 'Python', 'C++']
#2. Variabel kontra Fast Längd
Python-listor är datastrukturer med variabel längd. Du kan enkelt:
- Lägga till element i slutet av listan.
- Lägga till element från en annan lista i slutet av den aktuella listan.
- Ta bort element från en specifik position i listan.
list1 = [2,3,4,5] # Lägg till ett element i slutet list1.append(9) print(list1) # Lägg till element från list2 i slutet av list1 list2 = [0,7] list1.extend(list2) print(list1) # Ta bort ett element från list1 list1.pop(0) print(list1)
▶️ Utskriften av koden ovan blir:
# Output [2, 3, 4, 5, 9] [2, 3, 4, 5, 9, 0, 7] [3, 4, 5, 9, 0, 7]
Tupler är datastrukturer med fast längd. Du kan inte lägga till eller ta bort element från en befintlig tupel. Däremot kan du omdefiniera en tupel med nya element.
tuple1 = (2,4,6,8) tuple1 = (1,8,9) print(tuple1) # Output (1, 8, 9)
#3. Minnesanvändning
Som vi nämnde är listor datastrukturer med variabel längd.
När en lista definieras allokeras en viss mängd minne för den. När en lista ändras med metoderna `append()` eller `extend()` kan ytterligare minne behöva allokeras för att lagra de nya elementen. Denna allokering görs ofta med lite extra utrymme än vad som faktiskt behövs.
Därför behöver systemet hålla reda på antalet element i listan samt den allokerade minnesstorleken. Dessutom, eftersom listor kan ha variabel längd, används en pekare för att spåra minnesadressen för listelementen. Detta leder till att listor med längd *k* tar upp mer minne än en tupel med samma *k* element.
Här är en enkel illustration.
Du kan använda den inbyggda metoden `sys.getsizeof()` för att ta reda på storleken på ett Python-objekt i minnet.
import sys
list1 = [4,5,9,14]
list_size = sys.getsizeof(list1)
print(f"Storleken på listan:{list_size}")
tuple1 = (4,5,9,14)
tuple_size = sys.getsizeof(tuple1)
print(f"Storleken på tuplen:{tuple_size}")
En lista tar upp mer minne än en tupel för samma antal element, vilket bekräftas av utskriften nedan.
# Output Storleken på listan:104 Storleken på tuplen:88
När ska man använda en Tupel?
Baserat på likheterna och skillnaderna mellan listor och tupler, vet du att du ska använda en lista om du behöver en föränderlig samling.
Men när är det bäst att använda en tupel istället?
Låt oss gå igenom några typiska användningsfall.
#1. Skrivskyddad Samling
Om du behöver en samling som inte ska ändras, bör du använda en tupel. Tänk dig att `färg = (243,55,103)` är en tupel som innehåller RGB-värden för en viss färg. Genom att använda en tupel säkerställs att dessa värden inte kan modifieras.
Generellt, om du behöver en skrivskyddad samling vars värden inte ska ändras, bör du överväga att använda en tupel för att undvika oavsiktliga ändringar.
#2. Nycklar i Ordböcker
Anta att du vill skapa en ordbok med listobjekt i `key_list` som nycklar. Du kan använda `dict.fromkeys()` för att skapa en ordbok från en lista.
key_list = list("ABCD")
dict.fromkeys(key_list)
{'A': None, 'B': None, 'C': None, 'D': None}
Låt oss säga att du ändrar listan så att ’D’ blir det första elementet (index 0) – innan du skapar ordboken.
Vad händer nu med ordboksnyckeln ’A’?
Om du nu försöker skapa en ordbok från `key_list` och komma åt värdet som motsvarar nyckeln ’A’, får du ett `KeyError`.
key_list[0] = 'D' dict.fromkeys(key_list)['A'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-31-c90392acc2cf> in <module>() ----> 1 dict.fromkeys(key_list)['A'] KeyError: 'A'
Nycklarna i en ordbok måste vara unika, så du kan inte ha två nycklar med värdet ’D’.
dict.fromkeys(key_list)
{'B': None, 'C': None, 'D': None} # A finns inte längre.
Om du istället använder en tupel är en sådan modifiering omöjlig, vilket minskar risken för fel. Därför är det bra att använda en tupel för att skapa ordboksnycklar.
key_tuple = tuple("ABCD")
dict.fromkeys(key_tuple)
{'A': None, 'B': None, 'C': None, 'D': None}
key_tuple[0] = 'D'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-2cecbefa7db2> in <module>()
----> 1 key_tuple[0] = 'D'
TypeError: 'tuple' objekt stöder inte tilldelning av element
#3. Funktionsargument
Tuplers oföränderlighet gör dem också lämpliga att använda som funktionsargument.
Tänk dig följande funktion `find_volume()` som returnerar volymen av en kuboid, givet dess dimensioner (längd, bredd och höjd).
def find_volume(dimensions): l,b,h = dimensions return l*b*h
Anta att dimensionerna är lagrade i en lista som heter `dimensions`. Om du anropar `find_volume()` med `dimensions` som argument returneras volymen.
dimensions = [2,8,5] find_volume(dimensions) 80
Du kan alltid ändra dimensionerna som är lagrade i listan.
dimensions = [20,8,5] find_volume(dimensions) 800
Men ibland vill du att värden ska vara konstanta och inte kunna ändras. Då är det bra att lagra argumenten i en tupel och använda den i funktionsanropet.
#4. Returvärden från Funktioner
I Python stöter man ofta på tupler i returvärden från funktioner. När en funktion returnerar flera värden, returnerar Python dem implicit som en tupel.
Tänk på följande funktion `return_even()`:
def return_even(num): even = [i for i in range(num) if (i%2==0)] return even,len(even)
- Den tar ett tal `num` som argument.
- Den returnerar listan med jämna tal i intervallet [0,`num`) och längden på den listan.
Låt oss sätta värdet på `num` till 20 och anropa funktionen.
num = 20
Anropet till `return_even()` returnerar de två värdena i en tupel. Du kan använda `type()` för att verifiera att det verkligen är en tupel.
type(return_even(num)) # <class 'tuple'>
Du kan skriva ut returvärdet för att verifiera att det är en tupel som innehåller listan med jämna tal som det första elementet och längden på listan som det andra elementet.
print(return_even(num)) ([0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10)
Eftersom tuplen innehåller två element, kan du packa upp dessa i två variabler, som visas nedan.
even_nums, count = return_even(num) print(even_nums) print(count) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10
Sammanfattning
Jag hoppas att denna handledning har gett dig en tydlig jämförelse mellan Python-tupler och listor.
Låt oss avsluta handledningen med en snabb sammanfattning:
- Listor och tupler är inbyggda datastrukturer i Python.
- Likheter: Itererbara, stödjer indexering, slicing, blandade datatyper och medlemskapstestning.
- Huvudskillnaden: Listor är föränderliga och tupler är oföränderliga.
- Andra skillnader: Fast längd på tupler, variabel längd på listor, mindre minnesanvändning för tupler.
- När ska man använda en tupel? För oföränderliga samlingar, ordboksnycklar och funktionsargument.
För vidare inlärning, utforska Python-projekt för att öva. Du kan också lära dig metoder för att ta bort dubbletter från Python-listor. Lycka till med kodningen! 👩🏽💻