I denne guide lærer du lighederne og forskellene mellem Python-tupler og lister. Du vil også forstå, hvornår du skal bruge en tupel.
List og tuples er begge indbyggede datastrukturer i Python. De kan bruges til at opbevare en samling af elementer.
Fra understøttelse af indeksering og udskæring til at indeholde heterogene datatyper, kan tupler og lister synes at have lignende funktionalitet. Derfor kan forståelsen af lighederne og forskellene mellem de to hjælpe dig med at beslutte, hvilken datastruktur du skal bruge.
Lad os begynde.
👩🏽💻 Du kan starte en Python REPL og følge med i denne tutorial. Du kan også bruge toadmin.dk’ online Python-editor til at kode med.
Indholdsfortegnelse
Python Tuple vs List: Hvad er lighederne?
Lad os starte med at lære lighederne mellem lister og tupler. For at lette bedre læring præsenterer vi eksempler på både lister og tupler.
#1. Python Iterables
I Python er lister omgivet af et par firkantede parenteser, hvorimod tupler er omgivet af parentes. Du kan også oprette en tupel som et sæt værdier adskilt af kommaer – uden parentes.
De er begge iterables; så du kan gå igennem dem ved hjælp af en for-løkke.
Kodecellen nedenfor viser, hvordan man gentager 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 forklaret nedenfor, kan du også iterere gennem en tupel ved hjælp af 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 til skabelse fra andre sekvenser
Den næste lighed mellem lister og tupler er, at de kan oprettes ud fra eksisterende sekvenser såsom strenge.
sample_str = "Coding!"
Den 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åde kan en tupel oprettes ud fra en streng eller anden sekvens ved hjælp af tuple(sekvens). Kodecellen nedenfor viser, hvordan du kan gøre det.
tuple_from_str = tuple(sample_str)
print(tuple_from_str)
# Output
('C', 'o', 'd', 'i', 'n', 'g', '!')
#3. Understøttelse af indeksering og udskæring
Python understøtter nul-indeksering, hvor det første element er ved indeks nul, det andet ved indeks et, og så videre. Python understøtter også negativ indeksering, hvor det sidste element er ved indeks -1, det næstsidste element er ved 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 næstsidste element, ‘g’.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[-2])
# g
Du kan bruge udskæring, når du vil arbejde med en lille del af listen eller tuple. liste[start:end] returnerer et udsnit af listen, der starter ved indeksets start og strækker sig op til slutningen – 1. Standardværdien for en start er 0, og slutningen er det sidste element i den iterable.
Du kan skære tupler ved hjælp af den samme syntaks. Lad os oprette udsnit af listen og tuple, som vi oprettede tidligere.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[0:5]) ['C', 'o', 'd', 'i', 'n']
Ud over start- og slutværdierne kan du også angive en trinværdi. tuple(start:slut:trin) returnerer et udsnit af tuplet fra start til slut – 1, i trin af trin.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[::2])
('C', 'd', 'n', '!')
Her sætter vi trinværdien til 2. Så skiven indeholder hvert andet element.
#4. Samlinger af flere datatyper
I de eksempler, vi har overvejet, var alle elementer på listen og tupler af samme datatype.
Du kan dog gemme værdier af forskellige datatyper inden for en enkelt liste eller en tupel.
Kodestykket under student_list indeholder en elevs navn som en streng, alder som et heltal og markeringer sikret som en flydende.
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 tupel.
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. Support til medlemstest
Både lister og tupler giver dig mulighed for at udføre medlemskabstest for tilstedeværelsen af visse varer. Hvis du vil kontrollere, om et bestemt element er til stede i en liste eller en tupel, kan du bruge in-operatoren.
Udtrykket element i iterable evalueres til True, hvis iterablen indeholder elementet; andet, falsk.
"Alex" in student_list # False "Jane" in student_tuple # True
Indtil videre har du lært lighederne mellem lister og tupler i Python. Lad os derefter lære de vigtigste forskelle mellem de to datastrukturer.
Python Tuple vs List: Hvad er forskellene?
#1. Foranderlighed af lister og uforanderlighed af Tuples i Python
Den mest afgørende forskel mellem en liste og en tupel i Python er, at en tuple er uforanderlig. Det betyder, at du ikke kan ændre en tupel på plads.
▶️ 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 ændre listen ved at ændre et element ved et specifikt indeks, som i den følgende kodecelle.
list1 = ["Java","Python","C++"] list1[0] = "Rust" print(list1) # Output ['Rust', 'Python', 'C++']
#2. Lister med variabel længde vs tuples med fast længde
Python-listen er en datastruktur med variabel længde.
Du kan gøre følgende:
- Tilføj et element til slutningen af listen
- Tilføj elementer fra en anden liste til slutningen af den aktuelle liste
- Fjern elementer på et 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)
▶️ Outputtet af ovenstående kodestykke.
# Output [2, 3, 4, 5, 9] [2, 3, 4, 5, 9, 0, 7] [3, 4, 5, 9, 0, 7]
Tuples er datastrukturer med fast længde. Så du kan ikke tilføje eller fjerne elementer fra en eksisterende tuple. Men du kan omdefinere tuplet til at indeholde forskellige elementer.
tuple1 = (2,4,6,8) tuple1 = (1,8,9) print(tuple1) # Output (1, 8, 9)
#3. Størrelse i hukommelsen
Vi vil nu bygge oven på det, vi lærte i det foregående afsnit: listen er en datastruktur med variabel længde.
Når du først definerer listen, tildeles den en bestemt størrelse i hukommelsen. Nu, når du ændrer en liste ved hjælp af append() eller extend() metoderne, skal der allokeres yderligere hukommelse til at gemme de tilføjede elementer. Denne tildeling sker næsten altid mere end antallet af elementer, du tilføjer.
Så der er behov for at holde styr på antallet af varer på listen og den tildelte plads. Da lister har variabel længde, er der desuden en markør, der peger på adressen på listeelementerne. Som følge heraf fylder lister med længden k mere hukommelse end en tupel med de samme k elementer.
Her er en simpel illustration.
Du kan bruge det indbyggede sys-moduls getsizeof()-metode på et Python-objekt for at få størrelsen på et objekt i hukommelsen.
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 fylder mere hukommelse end en tupel for det samme antal og samme værdi af elementer, som bekræftet i outputtet nedenfor.
# Output Size of list:104 Size of tuple:88
Hvornår skal du bruge en Python Tuple?
Fra forskellene og lighederne mellem Python-lister og tupler ved du, at hvis du har brug for en foranderlig samling, skal du bruge en liste.
Men hvornår skal du bruge en tupel i stedet for?
Det vil vi gennemgå i dette afsnit.
#1. Skrivebeskyttet samling
Når du ønsker, at en samling skal være uforanderlig, bør du definere den som en tupel. Antag, at farve = (243,55,103) en tupel, der indeholder de RGB-værdier, der svarer til en farvenuance. At definere farve som en tupel sikrer, at den ikke kan ændres.
I det væsentlige, når du har brug for, at en samling skal være skrivebeskyttet: værdier bør ikke ændres under programmet, bør du overveje at bruge en tuple. Dette vil forhindre utilsigtede ændringer af værdierne.
#2. Ordbogsnøgler
For eksempel opretter du en ordbog ved at bruge listeelementerne key_list som tasterne. Du kan bruge metoden dict.fromkeys() til at oprette en ordbog fra en liste.
key_list = list("ABCD")
dict.fromkeys(key_list)
{'A': None, 'B': None, 'C': None, 'D': None}
Antag, at du ændrer listen til at indeholde ‘D’ som det første element (indeks 0) – før du opretter ordbogen.
Hvad sker der nu med ordbogsnøglen ‘A’?
Hvis du prøver at oprette en ordbog fra key_list og få adgang til den værdi, der svarer til nøglen ‘A’, vil du løbe ind i 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øglerne til en ordbog skal være unikke. Så du kan ikke have et andet ‘D’ som nøgle.
dict.fromkeys(key_list)
{'B': None, 'C': None, 'D': None} # A is no longer a key.
Hvis du i stedet bruger en tuple, er en sådan modifikation umulig, og du er mindre tilbøjelig til at løbe ind i fejl. Derfor bør du foretrække at oprette en ordbog ved at bruge emnerne i en tuple som nøgler.
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. Funktionsargumenter
Tuplernes uforanderlighed gør dem også egnede til at blive videregivet som funktionsargumenter.
Overvej følgende funktion find_volume(), der returnerer volumenet af en kuboid givet dimensionerne: længde, bredde og højde.
def find_volume(dimensions): l,b,h = dimensions return l*b*h
Antag, at disse dimensioner er tilgængelige på en liste kaldet dimensioner. Kaldet til find_volume() med dimensioner som argument returnerer volumen.
dimensions = [2,8,5] find_volume(dimensions) 80
Du kan altid ændre de dimensioner, der er gemt på en liste.
dimensions = [20,8,5] find_volume(dimensions) 800
Men nogle gange har du brug for, at værdierne forbliver konstante og modstår modifikation. Det er da du bør overveje at gemme argumenterne som en tupel og bruge dem i funktionskaldet.
#4. Returner værdier fra funktioner
I Python vil du støde på tuples i returværdier fra funktioner. Når du returnerer flere værdier fra en funktion, returnerer Python dem implicit som en tupel.
Overvej følgende funktion return_even():
def return_even(num): even = [i for i in range(num) if (i%2==0)] return even,len(even)
- Det tager et tal num som argument
- Det returnerer listen over lige tal 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)
Da der er to genstande i tuplet, kan du pakke dem ud i to variable, 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
Konklusion
Jeg håber, at denne tutorial gav en omfattende sammenligning af Python tuple vs list.
Lad os afslutte selvstudiet med en hurtig oversigt:
- Liste og tupler er indbyggede datastrukturer i Python.
- Ligheder: iterables, understøttelse af indeksering, udskæring, forskellige datatyper og operatør til medlemskabstest.
- Nøgleforskel: Lister er foranderlige, og tupler er uforanderlige.
- Andre forskelle: Fast længde af tupler og variabel længde af lister, mindre størrelse til hukommelse af tupler.
- Hvornår skal du bruge en tuple? Til uforanderlige samlinger, ordbogsnøgler og funktionsargumenter.
Tjek derefter Python-projekter for at øve og lære. Eller lær metoder til at fjerne duplikerede elementer fra Python-lister. God læring! så tillykke med kodningen!👩🏽💻