Python Sort List Array Method - Stigende og faldende forklaret med eksempler
Hvis du vil lære at arbejde med sort()
metoden i dine Python-projekter, er denne artikel noget for dig. Denne metode er meget kraftfuld, og du kan tilpasse den til dine behov, så lad os se, hvordan den fungerer i detaljer.
Du vil lære:
- Sådan bruges denne metode og tilpasser dens funktionalitet.
- Hvornår skal du bruge det, og hvornår det ikke skal bruges.
- Hvordan man kalder det passerer forskellige kombinationer af argumenter.
- Sådan sorteres en liste i stigende og faldende rækkefølge.
- Sådan sammenlignes elementerne på en liste baseret på mellemværdier.
- Hvordan du kan overføre lambdafunktioner til denne metode.
- Hvordan denne metode kan sammenlignes med
sorted()
funktionen. - Hvorfor
sort()
metoden udfører en stabil sortering. - Hvordan mutationsprocessen fungerer bag kulisserne.
Er du klar? Lad os begynde! ⭐
? Formål og brugssager
Med sort()
metoden kan du sortere en liste i enten:
- Stigende rækkefølge
- Faldende rækkefølge
Denne metode bruges til at sortere en liste på plads, hvilket betyder at den muterer den eller ændrer den direkte uden at oprette yderligere kopier, så husk:

Du vil lære mere om mutation i denne artikel (jeg lover!), Men for nu er det meget vigtigt, at du ved, at sort()
metoden ændrer listen, så dens originale version går tabt.
På grund af dette bør du kun bruge denne metode, hvis:
- Du vil ændre (sortere) listen permanent.
- Du behøver ikke at beholde den oprindelige version af listen.
Hvis dette passer til dine behov, er .sort()
metoden nøjagtigt det, du leder efter.
? Syntaks og argumenter
Lad os se, hvordan du kan ringe for .sort()
at drage fordel af dens fulde kraft.
Dette er det mest basale opkald (uden argumenter):

Hvis du ikke sender nogen argumenter, som standard:
- Listen sorteres i stigende rækkefølge.
- Elementerne på listen sammenlignes direkte ved hjælp af deres værdier med
<
operatøren.
For eksempel:
>>> b = [6, 3, 8, 2, 7, 3, 9] >>> b.sort() >>> b [2, 3, 3, 6, 7, 8, 9] # Sorted!
Brugerdefinerede argumenter
For at tilpasse, hvordan sort()
metoden fungerer, kan du videregive to valgfri argumenter:
- Nøgle
- Baglæns
Lad os se, hvordan de ændrer opførelsen af denne metode. Her har vi et metodekald med disse to argumenter:

Inden jeg forklarer, hvordan de fungerer, vil jeg gerne forklare noget, som du sandsynligvis har bemærket i diagrammet ovenfor - i metodekaldet skal navnene på parametrene medtages før deres tilsvarende værdier, som denne:
key=
reverse=
Dette er fordi de kun er søgeordsargumenter . Hvis du sender en brugerdefineret værdi til dem, skal deres navne angives i metodekaldet efterfulgt af et lighedstegn =
og deres tilsvarende værdier som denne:

Ellers, hvis du forsøger at videregive argumenterne direkte, som vi normalt gør for positionsparametre, vil du se denne fejl, fordi funktionen ikke ved, hvilket argument svarer til hvilken parameter:
TypeError: sort() takes no positional arguments
Baglæns
Nu hvor du ved, hvad kun søgeordsargumenter er, lad os starte med reverse
.
Værdien af reverse
kan være enten True
eller False
:
False
betyder, at listen vil blive sorteret i stigende rækkefølge.True
betyder, at listen vil blive sorteret i faldende (omvendt) rækkefølge.
Tip: Som standard er dens værdi False
- hvis du ikke sender nogen argumenter for denne parameter, sorteres listen i stigende rækkefølge.
Her har vi et par eksempler:

# List of Integers >>> b = [6, 3, 8, 2, 7, 3, 9] >>> b.sort() >>> b [2, 3, 3, 6, 7, 8, 9] # List of Strings >>> c = ["A", "Z", "D", "T", "U"] >>> c.sort() >>> c ['A', 'D', 'T', 'U', 'Z']
? Tip: Hvis elementerne på listen er strenge, sorteres de alfabetisk.

# List of Integers >>> b = [6, 3, 8, 2, 7, 3, 9] >>> b.sort(reverse=True) >>> b [9, 8, 7, 6, 3, 3, 2] # List of Strings >>> c = ["A", "Z", "D", "T", "U"] >>> c.sort(reverse=True) >>> c ['Z', 'U', 'T', 'D', 'A']
? Tip: Bemærk, hvordan listen sorteres i faldende rækkefølge, hvis den reverse
er True
.
Nøgle
Nu hvor du ved, hvordan du arbejder med reverse
parameteren, skal vi se key
parameteren.
Denne parameter er lidt mere detaljeret, fordi den bestemmer, hvordan elementerne på listen sammenlignes under sorteringsprocessen.

Værdien af key
er enten:
None
, hvilket betyder, at elementerne på listen sammenlignes direkte. F.eks. Kan en heltal i en liste over heltal bruges til sammenligningen.- En funktion af et argument, der genererer en mellemværdi for hvert element. Denne mellemværdi beregnes kun en gang, og den bruges til at foretage sammenligningerne under hele sorteringsprocessen. Vi bruger dette, når vi ikke ønsker at sammenligne elementerne direkte, for eksempel når vi vil sammenligne strenge baseret på deres længde (den mellemliggende værdi).
? Tip: Som standard er værdien af key
er None
, så elementerne sammenlignes direkte.
For eksempel:
Lad os sige, at vi vil sortere en liste over strenge baseret på deres længde, fra den korteste streng til den længste streng. Vi kan passere funktionen len
som værdien af key
, som denne:
>>> d = ["aaa", "bb", "c"] >>> d.sort(key=len) >>> d ['c', 'bb', 'aaa']
? Tip: Bemærk, at vi kun sender navnet på funktionen ( len
) uden parentes, fordi vi ikke kalder funktionen. Dette er meget vigtigt.
Bemærk forskellen mellem at sammenligne elementerne direkte og sammenligne deres længde (se nedenfor). Brug af standardværdien af key
( None
) ville have sorteret strengene alfabetisk (venstre), men nu sorterer vi dem ud fra deres længde (højre):

Hvad sker der bag kulisserne? Hvert element sendes som et argument til len()
funktionen, og den værdi, der returneres af dette funktionsopkald, bruges til at udføre sammenligningerne under sorteringsprocessen:

Dette resulterer i en liste med forskellige sorteringskriterier: længde.
Her har vi et andet eksempel:
Et andet interessant eksempel er at sortere en liste over strenge, som om de alle var skrevet med små bogstaver (for eksempel at gøre "Aa" svarende til "aa").
I henhold til leksikografisk rækkefølge kommer store bogstaver før små bogstaver:
>>> "E" < "e" True
Så strengen "Emma"
ville komme før "emily"
i en sorteret liste, selvom deres små versioner ville være i den modsatte rækkefølge:
>>> "Emma" >> "emma" < "emily" False
For at undgå at skelne mellem store og små bogstaver kan vi videregive funktionen str.lower
som key
. Dette genererer en lille version af strengene, der vil blive brugt til sammenligningerne:
>>> e = ["Emma", "emily", "Amy", "Jason"] >>> e.sort(key=str.lower) >>> e ['Amy', 'emily', 'Emma', 'Jason']
Bemærk, at nu "emily"
kommer før "Emma"
i den sorterede liste, hvilket er præcis, hvad vi ønskede.
? Tip: hvis vi havde brugt standard sortering proces, alle de strenge, der begyndte med et stort bogstav ville være kommet før alle strengene, der startede med et lille bogstav:
>>> e = ["Emma", "emily", "Amy", "Jason"] >>> e.sort() >>> e ['Amy', 'Emma', 'Jason', 'emily']
Her er et eksempel ved hjælp af objektorienteret programmering (OOP):
Hvis vi har denne meget enkle Python-klasse:
>>> class Client: def __init__(self, age): self.age = age
Og vi opretter fire forekomster:
>>> client1 = Client(67) >>> client2 = Client(23) >>> client3 = Client(13) >>> client4 = Client(35)
Vi kan lave en liste, der refererer til dem:
>>> clients = [client1, client2, client3, client4]
Derefter, hvis vi definerer en funktion til at få de age
af disse forekomster:
>>> def get_age(client): return client.age
Vi kan sortere listen ud fra deres alder ved at videregive get_age
funktionen til et argument:
>>> clients.sort(key=get_age)
Dette er den endelige, sorterede version af listen. Vi bruger en for-løkke til at udskrive forekomstenes alder i den rækkefølge, de vises på listen:
>>> for client in clients: print(client.age) 13 23 35 67
Præcis hvad vi ønskede - nu er listen sorteret i stigende rækkefølge baseret på instansernes alder.
? Tip: I stedet for at definere en get_age
funktion, kunne vi have brugt en lambda-funktion til at få alderen for hver forekomst, som denne:
>>> clients.sort(key=lambda x: x.age)
Lambda-funktioner er små og enkle anonyme funktioner, hvilket betyder, at de ikke har noget navn. De er meget nyttige i disse scenarier, når vi kun vil bruge dem bestemte steder i en meget kort periode.
Dette er den grundlæggende struktur for lambda-funktionen, som vi bruger til at sortere listen:

Videregivelse af begge argumenter
Fantastisk! Nu ved du at tilpasse sort()
metodens funktionalitet. Men du kan tage dine færdigheder til et helt nyt niveau ved at kombinere effekten af key
og reverse
i samme metodeopkald:
>>> f = ["A", "a", "B", "b", "C", "c"] >>> f.sort(key=str.lower, reverse=True) >>> f ['C', 'c', 'B', 'b', 'A', 'a']
Dette er de forskellige kombinationer af argumenterne og deres virkning:

Rækkefølgen af argumenter, der kun er søgeord, betyder ikke noget
Da vi specificerer navnene på argumenterne, ved vi allerede, hvilken værdi der svarer til hvilken parameter, så vi kan inkludere den ene key
eller den reverse
første på listen, og effekten vil være nøjagtig den samme.
Så denne metode kalder:

Svarer til:

Dette er et eksempel:
>>> a = ["Zz", "c", "y", "o", "F"] >>> a.sort(key=str.lower, reverse=True) >>> a ['Zz', 'y', 'o', 'F', 'c']
Hvis vi ændrer rækkefølgen af argumenterne, får vi nøjagtigt det samme resultat:
>>> a = ["Zz", "c", "y", "o", "F"] >>> a.sort(reverse=True, key=str.lower) >>> a ['Zz', 'y', 'o', 'F', 'c']
? Returneringsværdi
Lad os nu tale lidt om returværdien af denne metode. De sort()
metode returnerer None
- det gør ikke returnere en ordnet version af listen, ligesom vi måske intuitivt forvente.
Ifølge Python-dokumentationen:
For at minde brugerne om, at den fungerer ved bivirkning, returnerer den ikke den sorterede sekvens.Dybest set bruges dette til at minde os om, at vi ændrer den oprindelige liste i hukommelsen og ikke genererer en ny kopi af listen.
Dette er et eksempel på returværdien af sort()
:
>>> nums = [6.5, 2.4, 7.3, 3.5, 2.6, 7.4] # Assign the return value to this variable: >>> val = nums.sort() # Check the return value: >>> print(val) None
Se? None
blev returneret ved metodeopkaldet.
? Tip: It is very important not to confuse the sort()
method with the sorted()
function, which is a function that works very similarly, but doesn't modify the original list. Instead sorted()
generates and returns a new copy of the list, already sorted.
This is an example that we can use to compare them:
# The sort() method returns None >>> nums = [6.5, 2.4, 7.3, 3.5, 2.6, 7.4] >>> val = nums.sort() >>> print(val) None
# sorted() returns a new sorted copy of the original list >>> nums = [6.5, 2.4, 7.3, 3.5, 2.6, 7.4] >>> val = sorted(nums) >>> val [2.4, 2.6, 3.5, 6.5, 7.3, 7.4] # But it doesn't modify the original list >>> nums [6.5, 2.4, 7.3, 3.5, 2.6, 7.4]
This is very important because their effect is very different. Using the sort()
method when you intended to use sorted()
can introduce serious bugs into your program because you might not realize that the list is being mutated.
? The sort() Method Performs a Stable Sort
Now let's talk a little bit about the characteristics of the sorting algorithm used by sort()
.
Denne metode udfører en stabil sortering, fordi den fungerer med en implementering af TimSort, en meget effektiv og stabil sorteringsalgoritme.
Ifølge Python-dokumentationen:
En sortering er stabil, hvis den garanterer ikke at ændre den relative rækkefølge af elementer, der sammenligner ens - dette er nyttigt til sortering i flere passeringer (for eksempel sorter efter afdeling og derefter efter lønklasse).Dette betyder, at hvis to elementer har samme værdi eller mellemværdi (nøgle), er de garanteret at forblive i samme rækkefølge i forhold til hinanden.
Lad os se, hvad jeg mener med dette. Se dette eksempel et øjeblik:
>>> d = ["BB", "AA", "CC", "A", "B", "AAA", "BBB"] >>> d.sort(key=len) >>> d ['A', 'B', 'BB', 'AA', 'CC', 'AAA', 'BBB']
Vi sammenligner elementerne baseret på deres længde, fordi vi passerede len
funktionen som argumentet for key
.
We can see that there are three elements with length 2: "BB"
, "AA"
, and "CC"
in that order.
Now, notice that these three elements are in the same relative order in the final sorted list:

This is because the algorithm is guaranteed to be stable and the three of them had the same intermediate value (key) during the sorting process (their length was 2, so their key was 2).
? Tip: The same happened with "A"
and "B"
(length 1) and "AAA"
and "BBB"
(length 3), their original order relative to each other was preserved.
Now you know how the sort()
method works, so let's dive into mutation and how it can affect your program.
? Mutation and Risks
As promised, let's see how the process of mutation works behind the scenes:
When you define a list in Python, like this:
a = [1, 2, 3, 4]
You create an object at a specific memory location. This location is called the "memory address" of the object, represented by a unique integer called an id.
You can think of an id as a "tag" used to identify a specific place in memory:

You can access a list's id using the id()
function, passing the list as argument:
>>> a = [1, 2, 3, 4] >>> id(a) 60501512
When you mutate the list, you change it directly in memory. You may ask, why is this so risky?
It's risky because it affects every single line of code that uses the list after the mutation, so you may be writing code to work with a list that is completely different from the actual list that exists in memory after the mutation.
This is why you need to be very careful with methods that cause mutation.
In particular, the sort()
method mutates the list. This is an example of its effect:

Here is an example:
# Define a list >>> a = [7, 3, 5, 1] # Check its id >>> id(a) 67091624 # Sort the list using .sort() >>> a.sort() # Check its id (it's the same, so the list is the same object in memory) >>> id(a) 67091624 # Now the list is sorted. It has been mutated! >>> a [1, 3, 5, 7]
The list was mutated after calling .sort()
.
Every single line of code that works with list a
after the mutation has occurred will use the new, sorted version of the list. If this was not what you intended, you may not realize that other parts of your program are working with the new version of the list.
Here is another example of the risks of mutation within a function:
# List >>> a = [7, 3, 5, 1] # Function that prints the elements of the list in ascending order. >>> def print_sorted(x): x.sort() for elem in x: print(elem) # Call the function passing 'a' as argument >>> print_sorted(a) 1 3 5 7 # Oops! The original list was mutated. >>> a [1, 3, 5, 7]
The list a
that was passed as argument was mutated, even if that wasn't what you intended when you initially wrote the function.
? Tip: If a function mutates an argument, it should be clearly stated to avoid introducing bugs into other parts of your program.
? Summary of the sort() Method
- The
sort()
method lets you sort a list in ascending or descending order. - It takes two keyword-only arguments:
key
andreverse
. reverse
determines if the list is sorted in ascending or descending order.key
is a function that generates an intermediate value for each element, and this value is used to do the comparisons during the sorting process.- The
sort()
method mutates the list, causing permanent changes. You need to be very careful and only use it if you do not need the original version of the list.
Jeg håber virkelig, at du kunne lide min artikel og fandt det nyttigt. Nu kan du arbejde medsort()
metoden i dine Python-projekter. Tjek mine online kurser. Følg mig på Twitter. ⭐️