I denne veiledningen lærer du likhetene og forskjellene mellom Python-tupler og lister. Du vil også forstå når du bør bruke en tuppel.
List og tuples er begge innebygde datastrukturer i Python. De kan brukes til å lagre en samling av elementer.
Fra støtte for indeksering og skjæring til å inneholde heterogene datatyper, kan tupler og lister se ut til å ha lignende funksjonalitet. Derfor kan det å forstå likhetene og forskjellene mellom de to hjelpe deg med å bestemme hvilken datastruktur du skal bruke.
La oss begynne.
👩🏽💻 Du kan starte en Python REPL og følge med på denne opplæringen. Du kan også bruke tipsbilk.nets nettbaserte Python-editor for å kode med.
Innholdsfortegnelse
Python Tuple vs List: Hva er likhetene?
La oss starte med å lære likhetene mellom lister og tupler. For å legge til rette for bedre læring presenterer vi eksempler på både lister og tupler.
#1. Python Iterables
I Python er lister omsluttet av et par firkantede parenteser, mens tupler er omsluttet i parentes. Du kan også lage en tuppel som et sett med verdier atskilt med komma – uten parentes.
De er begge iterable; slik at du kan gå gjennom dem ved å bruke en for-løkke.
Kodecellen nedenfor viser hvordan du itererer gjennom en liste.
nums = [2,6,7,10]
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'list'>
2
6
7
10
Som forklart nedenfor, kan du også iterere gjennom en tuppel ved hjelp av en løkke
nums = (2,6,7,10)
# Note: nums = 2,6,7,10 is a valid tuple as well. If needed, run a quick check!
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'tuple'>
2
6
7
10
#2. Støtte for skapelse fra andre sekvenser
Den neste likheten mellom lister og tupler er at de kan lages fra eksisterende sekvenser som strenger.
sample_str = "Coding!"
Følgende kodecelle viser hvordan liste(streng) returnerer en liste, hvis listeelementer er tegnene i strengen.
list_from_str = list(sample_str) print(list_from_str) # Output ['C', 'o', 'd', 'i', 'n', 'g', '!']
På samme måte kan en tuppel lages fra en streng eller annen sekvens ved å bruke tuppel (sekvens). Kodecellen nedenfor viser hvordan du kan gjøre det.
tuple_from_str = tuple(sample_str)
print(tuple_from_str)
# Output
('C', 'o', 'd', 'i', 'n', 'g', '!')
#3. Støtte for indeksering og skjæring
Python støtter nullindeksering der det første elementet er på indeks null, det andre ved indeks én, og så videre. Python støtter også negativ indeksering, der det siste elementet er på indeks -1, det nest siste elementet er på indeks -2, og så videre.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[1]) # o
Elementet ved indeks -2 er det nest siste elementet, «g».
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[-2])
# g
Du kan bruke skjæring når du vil jobbe med en liten del av listen eller tuppelen. liste[start:end] returnerer en del av listen som starter ved indeksstart og strekker seg opp til slutt – 1. Standardverdien for en start er 0, og slutten er det siste elementet i den iterable.
Du kan skjære tupler ved å bruke samme syntaks. La oss lage deler av listen og tuppelen som vi laget tidligere.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[0:5]) ['C', 'o', 'd', 'i', 'n']
I tillegg til start- og sluttverdiene kan du også angi en trinnverdi. tuple(start:slutt:trinn) returnerer en del av tuppelen fra start til slutt – 1, i trinnvis.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[::2])
('C', 'd', 'n', '!')
Her setter vi trinnverdien til 2. Så skiven inneholder hvert andre element.
#4. Samlinger av flere datatyper
I eksemplene vi har vurdert, var alle elementene på listen og tuplene av samme datatype.
Du kan imidlertid lagre verdier av forskjellige datatyper innenfor en enkelt liste eller en tuppel.
Kodebiten under student_list inneholder en elevs navn som en streng, alder som et heltall og markeringer sikret som en flyte.
student_list = ["John",22,96.5]
for item in student_list:
print(f"{item} is of type {type(item)}")
# Output
John is of type <class 'str'>
22 is of type <class 'int'>
96.5 is of type <class 'float'>
Vi kan komme med et lignende eksempel for en tuppel.
student_tuple = ("Jane",23,99.5)
for item in student_tuple:
print(f"{item} is of type {type(item)}")
# Output
Jane is of type <class 'str'>
23 is of type <class 'int'>
99.5 is of type <class 'float'>
#5. Støtte for medlemstesting
Både lister og tupler lar deg utføre medlemskapstesting for tilstedeværelsen av visse gjenstander. Hvis du vil sjekke om et spesifikt element finnes i en liste eller en tuppel, kan du bruke in-operatoren.
Uttrykket element i iterable evalueres til True hvis iterable inneholder elementet; annet, falskt.
"Alex" in student_list # False "Jane" in student_tuple # True
Så langt har du lært likhetene mellom lister og tuples i Python. La oss deretter lære de viktigste forskjellene mellom de to datastrukturene.
Python Tuple vs List: Hva er forskjellene?
#1. Mulighet av lister og uforanderlighet av tuples i Python
Den mest avgjørende forskjellen mellom en liste og en tuppel i Python er at en tuppel er uforanderlig. Dette betyr at du ikke kan endre en tuppel på plass.
▶️ Her er et eksempel.
tuple1 = ("Java","Python","C++")
tuple1[0] = "Rust"
# Output
----> 2 tuple1[0] = "Rust"
TypeError: 'tuple' object does not support item assignment
En liste er en foranderlig datastruktur, så vi kan modifisere listen ved å endre et element ved en bestemt indeks, som i følgende kodecelle.
list1 = ["Java","Python","C++"] list1[0] = "Rust" print(list1) # Output ['Rust', 'Python', 'C++']
#2. Lister med variabel lengde vs tupler med fast lengde
Python-listen er en datastruktur med variabel lengde.
Du kan gjøre følgende:
- Legg til et element på slutten av listen
- Legg til elementer fra en annen liste til slutten av gjeldende liste
- Fjern elementer fra en bestemt indeks fra listen
list1 = [2,3,4,5] # add an item to the end list1.append(9) print(list1) # add items from list2 to the end of list1 list2 = [0,7] list1.extend(list2) print(list1) # remove an item from list1 list1.pop(0) print(list1)
▶️ Utdata fra kodebiten ovenfor.
# Output [2, 3, 4, 5, 9] [2, 3, 4, 5, 9, 0, 7] [3, 4, 5, 9, 0, 7]
Tuples er datastrukturer med fast lengde. Så du kan ikke legge til eller fjerne elementer fra en eksisterende tuppel. Men du kan omdefinere tuppelen til å inneholde forskjellige elementer.
tuple1 = (2,4,6,8) tuple1 = (1,8,9) print(tuple1) # Output (1, 8, 9)
#3. Størrelse i minnet
Vi skal nå bygge på toppen av det vi lærte i forrige del: listen er en datastruktur med variabel lengde.
Når du først definerer listen, tildeles den en bestemt størrelse i minnet. Nå, når du endrer en liste ved hjelp av metodene append() eller extend(), bør ekstra minne tildeles for å lagre de tilføyde elementene. Denne tildelingen gjøres nesten alltid mer enn antallet elementer du legger til.
Så det er behov for å holde styr på antall elementer på listen og den tildelte plassen. I tillegg, siden lister har variabel lengde, er det en peker som peker til adressen til listeelementene. Som et resultat tar lister med lengde k opp mer minne enn en tuppel med de samme k elementene.
Her er en enkel illustrasjon.
Du kan bruke den innebygde sys-modulens getsizeof()-metode på et Python-objekt for å få størrelsen på et objekt i minnet.
import sys
list1 = [4,5,9,14]
list_size = sys.getsizeof(list1)
print(f"Size of list:{list_size}")
tuple1 = (4,5,9,14)
tuple_size = sys.getsizeof(tuple1)
print(f"Size of tuple:{tuple_size}")
En liste tar opp mer minne enn en tuppel for samme antall og verdi av elementer, som bekreftet i utdataene nedenfor.
# Output Size of list:104 Size of tuple:88
Når bør du bruke en Python Tuple?
Fra forskjellene og likhetene mellom Python-lister og tuples, vet du at hvis du trenger en mutbar samling, bør du bruke en liste.
Men når bør du bruke en tuppel i stedet?
Vi vil gå over det i denne delen.
#1. Skrivebeskyttet samling
Når du vil at en samling skal være uforanderlig, bør du definere den som en tuppel. Anta at farge = (243,55,103) en tuppel som inneholder RGB-verdiene som tilsvarer en fargenyanse. Å definere farge som en tuppel sikrer at den ikke kan endres.
I hovedsak, når du trenger at en samling skal være skrivebeskyttet: verdier bør ikke endres under programmet, bør du vurdere å bruke en tuppel. Dette vil forhindre utilsiktede endringer av verdiene.
#2. Ordboknøkler
Du oppretter for eksempel en ordbok ved å bruke listeelementene key_list som tastene. Du kan bruke dict.fromkeys()-metoden til å lage en ordbok fra en liste.
key_list = list("ABCD")
dict.fromkeys(key_list)
{'A': None, 'B': None, 'C': None, 'D': None}
Anta at du endrer listen slik at den inneholder «D» som det første elementet (indeks 0) – før du oppretter ordboken.
Nå, hva skjer med ordboknøkkelen «A»?
Hvis du prøver å lage en ordbok fra key_list og få tilgang til verdien som tilsvarer nøkkelen «A», får du en 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'
Nøklene til en ordbok skal være unike. Så du kan ikke ha en andre «D» som nøkkel.
dict.fromkeys(key_list)
{'B': None, 'C': None, 'D': None} # A is no longer a key.
Hvis du i stedet bruker en tuppel, er en slik modifikasjon umulig, og det er mindre sannsynlig at du støter på feil. Derfor bør du foretrekke å lage en ordbok ved å bruke elementene til en tuppel som nøkler.
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' object does not support item assignment
#3. Funksjonsargumenter
Uforanderligheten til tupler gjør dem også egnet til å sendes inn som funksjonsargumenter.
Tenk på følgende funksjon find_volume() som returnerer volumet til en kuboid gitt dimensjonene: lengde, bredde og høyde.
def find_volume(dimensions): l,b,h = dimensions return l*b*h
Anta at disse dimensjonene er tilgjengelige i en liste kalt dimensjoner. Kallet til find_volume() med dimensjoner som argument returnerer volumet.
dimensions = [2,8,5] find_volume(dimensions) 80
Du kan alltid endre dimensjonene som er lagret i en liste.
dimensions = [20,8,5] find_volume(dimensions) 800
Noen ganger trenger du imidlertid at verdiene forblir konstante og motstå endringer. Det er da du bør vurdere å lagre argumentene som en tuppel og bruke dem i funksjonskallet.
#4. Returner verdier fra funksjoner
I Python vil du komme over tupler i returverdier fra funksjoner. Når du returnerer flere verdier fra en funksjon, returnerer Python dem implisitt som en tuppel.
Tenk på følgende funksjon return_even():
def return_even(num): even = [i for i in range(num) if (i%2==0)] return even,len(even)
- Det tar et tall num som argument
- Den returnerer listen over partall i intervallet [0,num) and the length of that list.
Let’s set the value of num 20 and call the function.
num = 20
Calling return_even() returns the two values in a tuple. You can call the type() function with the function call as the verification argument.
type(return_even(num)) # <class 'tuple'>
You can print out the return value to verify that it’s a tuple containing the list of even numbers as the first item and the length of the list as the second item.
print(return_even(num)) ([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]10)
Siden det er to elementer i tuppelen, kan du pakke dem ut i to variabler, som vist nedenfor.
even_nums, count = return_even(num) print(even_nums) print(count) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10
Konklusjon
Jeg håper denne opplæringen ga en omfattende sammenligning av Python tuple vs list.
La oss avslutte opplæringen med et raskt sammendrag:
- Liste og tuples er innebygde datastrukturer i Python.
- Likheter: iterables, støtte for indeksering, slicing, forskjellige datatyper og operatør for medlemskapstesting.
- Hovedforskjell: Lister kan endres, og tupler er uforanderlige.
- Andre forskjeller: Fast lengde på tupler og variabel lengde på lister, mindre størrelse i minnet til tuppel.
- Når bør du bruke tuppel? For uforanderlige samlinger, ordboknøkler og funksjonsargumenter.
Deretter kan du sjekke ut Python-prosjekter for å øve og lære. Eller lær metoder for å fjerne dupliserte elementer fra Python-lister. God læring! da, glad koding!👩🏽💻