1. ProgrammeringPythonHvordan bruges Lambda-funktioner i Python

Af Alan Shovic, John Shovic

Python understøtter konceptet med anonyme funktioner, også kaldet lambda-funktioner. Den anonyme del af navnet er baseret på, at funktionen ikke behøver at have et navn (men kan have et, hvis du vil have det). Lambda-delen er baseret på brugen af ​​nøgleordet lambda til at definere dem i Python. Lambda er også det 11. bogstav i det græske alfabet.

Men hovedårsagen til, at navnet bruges i Python, er fordi udtrykket lambda bruges til at beskrive anonyme funktioner i beregningen. Nu når vi har ryddet det op, kan du bruge denne info til at skabe fascinerende samtale på kontorfester.

Den minimale syntaks til at definere et lambda-udtryk (uden navn) med Python er:

Lambda argumenter: udtryk

Når du bruger det:

  • Erstat argumenter med data, der sendes ind i udtrykket. Erstat udtryk med et udtryk (formel), der definerer, hvad du vil have, at lambda skal returnere.

Et forholdsvis almindeligt eksempel på at bruge denne syntaks er, når du prøver at sortere tekststrenge, hvor nogle af navnene starter med store bogstaver, og andre starter med små bogstaver, som i disse navne:

Adams, Ma, diMeola, Zandusky

Antag, at du skriver følgende kode for at placere navnene på en liste, sortere den og derefter udskrive listen på denne måde:

names = ['Adams', 'Ma', 'diMeola', 'Zandusky']
names.sort ()
udskrive (navne)

Denne output fra dette er:

['Adams', 'Ma', 'Zandusky', 'diMeola']

At have diMeola kommet efter Zandusky virker forkert for nogle begyndere. Men computere ser ikke altid tingene som vi gør. (Faktisk “ser” de ikke noget, fordi de ikke har øjne eller hjerner… men det er ved siden af ​​punktet.) Årsagen til at DiMeola kommer efter Zandusky er fordi typen er baseret på ASCII, som er et system, hvor hver tegn er repræsenteret med et tal.

Alle små bogstaver har tal, der er højere end store bogstaver. Så når du sorterer, kommer alle ord, der begynder med små bogstaver, efter ordene, der starter med et stort bogstav. Hvis ikke andet, garanterer det i det mindste en mindre hmm.

For at hjælpe med disse anliggender giver Python-sorteringsmetoden () dig mulighed for at medtage et nøgle = udtryk inden i parenteserne, hvor du kan fortælle det, hvordan du sorterer. Syntaks er:

.sort (nøgle = transform)

Transformationsdelen er en vis variation på de data, der sorteres. Hvis du er heldig, og en af ​​de indbyggede funktioner som len (til længde) fungerer for dig, kan du bare bruge det i stedet for transformation, som dette:

names.sort (nøgle = len)

Desværre for os hjælper strengen ikke med alfabetisering. Så når du kører det, viser ordren sig at være:

['Ma', 'Adams', 'diMeola', 'Zandusky']

Sorteringen går fra den korteste streng (den med færrest tegn) til den længste streng. Ikke nyttigt i øjeblikket.

Du kan ikke skrive nøgle = lavere eller nøgle = øverste for at basere sorteringen på alle små eller alle store bogstaver enten, fordi nedre og øverste ikke er indbyggede funktioner (som du kan verificere temmelig hurtigt ved at google python 3.7 indbygget i funktioner).

I stedet for en indbygget funktion kan du bruge en brugerdefineret funktion, som du definerer dig selv ved hjælp af def. For eksempel kan du oprette en funktion, der hedder lavere (), der accepterer en streng og returnerer den streng med alle dens bogstaver konverteret til små bogstaver. Her er funktionen:

def lavere (anystring):
"" "Konverterer streng til alle små bogstaver" ""
returner anystring.lower ()

Navnet lavere består af, og enhver streng er en pladsholder for uanset hvilken streng du sender til den i fremtiden. Return anystring.lower () returnerer den streng, der er konverteret til alle små bogstaver ved hjælp af metoden .lower () til str (objektet) streng. (Læs mere om Python-strengmetoder for at få flere oplysninger.)

Du kan ikke bruge tasten = lavere i parenteserne for sortering (), fordi lavere () ikke er en indbygget funktion. Det er en metode ... ikke den samme. Slags irriterende med alle disse buzzwords.

Antag, at du skriver denne funktion i en Jupyter-celle eller .py-fil. Derefter kalder du funktionen med noget som udskrivning (små bogstaver ('Zandusky')). Hvad du får som output er den streng, der er konverteret til alle små bogstaver, som du ser nedenfor.

brugerdefineret funktion lavere () i Python

Okay, så nu har du en brugerdefineret funktion til at konvertere en hvilken som helst streng til alle små bogstaver. Hvordan bruger du det som en sorteringsnøgle? Let, brug nøgle = transformer det samme som før, men erstatt transform med dit brugerdefinerede funktionsnavn. Funktionen kaldes små bogstaver, så du vil bruge .sort (nøgle = små bogstaver), som vist på følgende:

def små bogstaver (anystring):
"" "Konverterer streng til alle små bogstaver" ""
returner anystring.lower ()
 
names = ['Adams', 'Ma', 'diMeola', 'Zandusky']
names.sort (nøgle = lowercaseof)

Hvis du kører denne kode for at få vist listen med navne, placeres de i den rigtige rækkefølge, fordi den baserer sorteringen på strenge, der alle er små. Outputet er det samme som før, fordi kun sorteringen, der fandt sted bag kulisserne, brugte små bogstaver. De originale data findes stadig i de originale store og små bogstaver.

'Adams', 'diMeola', 'Ma', 'Zandusky'

Hvis du stadig er vågen og bevidst efter at have læst alt dette, tænker du måske: ”Okay, du løste sorteringsproblemet. Men jeg troede, at vi talte om lambda-funktioner her. Hvor er lambda-funktionen? ”Der er endnu ingen lambda-funktion.

Men dette er et perfekt eksempel på, hvor du kunne bruge en lambda-funktion, fordi den Python-funktion, du kalder, små bogstaver (), gør alt sit arbejde med kun en kodelinje: returner anystring.lower ().

Når din funktion kan gøre sine ting med et simpelt udtryk på én linje som det, kan du springe def og funktionsnavnet over og bare bruge denne syntaks:

lambda-parametre: udtryk

Udskift parametre med et eller flere parameternavne, som du selv udgør (navnene inde i parenteserne efter def og funktionsnavnet i en almindelig funktion). Erstat udtryk med det, du vil have, at funktionen skal returnere uden ordets tilbagevenden. Så i dette eksempel ville nøglen ved hjælp af et lambda-udtryk være:

lambda anystring: anystring.lower ()

Nu kan du se, hvorfor det er en anonym funktion. Hele den første linje med funktionens navn små bogstaver () er blevet fjernet. Så fordelen ved at bruge lambda-udtrykket er, at du overhovedet ikke har brug for den eksterne brugerdefinerede funktion. Du skal bare bruge parameteren efterfulgt af et kolon og et udtryk, der fortæller det, hvad der skal returneres.

Billedet herunder viser den komplette kode og resultatet af at køre den. Du får den rigtige sorteringsrækkefølge uden behov for en ekstern kundefunktion som små bogstaver (). Du bruger bare hvilken som helst streng: anystring.lower () (efter ordet lambda) som sorteringstast.

Python lambda-udtryk

Lad os også tilføje, at enhver streng er et længere parameternavn, end de fleste Pythonistas ville bruge. Python-folk er glade for korte navne, endda navn med enkelt bogstaver. For eksempel kan du erstatte en hvilken som helst streng med s (eller et hvilket som helst andet bogstav) som i det følgende, og koden fungerer nøjagtigt den samme:

names = ['Adams', 'Ma', 'diMeola', 'Zandusky']
names.sort (nøgle = lambda s: s.lower ())
udskrive (navne)

Vej tilbage i begyndelsen af ​​denne tirade blev det nævnt, at en lambda-funktion ikke behøver at være anonym. Du kan give dem navne og kalde dem, som du ville gøre for andre funktioner.

For eksempel er her en lambda-funktion med navnet valuta, der tager et hvilket som helst tal og returnerer en streng i valutaformat (det vil sige med et førende dollartegn, komma mellem tusinder og to cifre for øre):

valuta = lambda n: f "$ {n:,. 2f}"

Her er en navngivet procent, der multiplicerer ethvert tal, du sender til det med 100, og viser det med to procenttegn i slutningen:

procent = lambda n: f "{n: .2%}"

Følgende billede viser eksempler på begge funktioner defineret øverst i en Jupyter-celle. Derefter kalder et par udskrivningsangivelser funktionerne ved navn og videregiver nogle eksempeldata til dem. Hver udskrivning () udsagn viser nummeret i det ønskede format.

Python-formateringsnumre

Årsagen til at du kan definere dem som single-line lambdas er fordi du kan udføre alt arbejde på en linje, f "$ {n:,. 2f}" for den første og f "{n: .2%}" for den anden. Men bare fordi du kan gøre det på den måde, betyder det ikke, at du skal. Du kan også bruge almindelige funktioner som følger:

# Vis nummer i valutaformat.
def valuta (n):
returnerer f "$ {n:,. 2f}"
 
def procent (n):
# Vis nummer i procentformat.
returnerer f "{n: .2%}"

Med denne længere syntaks kunne du også give flere oplysninger. For eksempel kan du som standard indstille et højrejusteret format inden for en bestemt bredde (f.eks. 15 tegn), så alle numre kom ud højrejusteret til den samme bredde. Billedet viser denne variation på de to funktioner.

Python formateringsfunktion fast bredde

På billedet ovenfor er den anden parameter valgfri og er standard til 15 hvis den udelades. Så hvis du kalder det sådan:

print (valuta (9999))

… Får du 9.999,00 polstring med tilstrækkelige mellemrum til venstre for at gøre det 15 tegn bredt. Hvis du i stedet kalder det sådan:

print (valuta (9999,20)

… Du får stadig 9.999,00 $ men polstret med nok pladser til venstre for at gøre det 20 tegn bredt.

.Ljust () brugt ovenfor er en Python indbygget strengmetode, der polstrer venstre side af en streng med tilstrækkelige mellemrum til at gøre den til den specificerede bredde. Der er også en retfærdig () metode til at padde den højre side. Du kan også specificere et andet tegn end et mellemrum. Google python 3 justerer kun, hvis du har brug for mere information.

Så der har du det, muligheden for at oprette dine egne brugerdefinerede funktioner i Python. I det virkelige liv er det, du gerne vil gøre, hver gang du finder ud af, at du har brug for adgang til den samme kodedel - den samme bit af login - igen og igen i din app, ikke bare kopier / indsæt den del af kode igen og igen. I stedet skal du placere al denne kode i en funktion, som du kan kalde ved navn.

På den måde, hvis du beslutter at ændre Python-strengkoden, behøver du ikke at gå gennem din app for at finde alle de steder, der skal ændres. Bare ændre det i den funktion, hvor det hele er defineret på et sted.

  1. ProgrammeringPythonHvordan defineres og bruges Python-lister

Af Alan Shovic, John Shovic

Den enkleste dataindsamling i Python er en liste. En liste er enhver liste over dataelementer, adskilt med kommaer, inden i firkantede parenteser. Typisk tildeler du et navn til Python-listen ved hjælp af et = -tegn, ligesom du ville gjort med variabler. Hvis listen indeholder numre, skal du ikke bruge anførselstegn omkring dem. Her er f.eks. En liste over testresultater:

scoringer = [88, 92, 78, 90, 98, 84]

Hvis listen indeholder strenge, skal disse strenge som altid være lukket med enkelt eller dobbelt anførselstegn, som i dette eksempel:

For at få vist indholdet af en liste på skærmen, kan du udskrive den, ligesom du vil udskrive enhver almindelig variabel. Eksempelvis udfører udskrivning (studerende) i din kode efter at have defineret denne liste, dette på skærmen.

['Mark', 'Amber', 'Todd', 'Anita', 'Sandy']

Dette er måske ikke nøjagtigt, hvad du havde i tankerne. Men rolig, Python tilbyder masser af gode måder at få adgang til data på lister og vise dem, som du vil.

Henvisning til Python-listeemner efter position

Hvert element på en liste har et positionsnummer, der starter med nul, selvom du ikke ser nogen tal. Du kan henvise til ethvert element på listen med dets nummer ved hjælp af navnet på listen efterfulgt af et tal i firkantede parenteser. Brug med andre ord denne syntaks:

listenavn [x]

Udskift listenavn med navnet på den liste, du får adgang til, og erstatt x med det ønskede positionsnummer. Husk, at den første vare altid er nul, ikke en. For eksempel definerer jeg en liste med navn studerende på den første linje nedenfor og udskriver derefter varenummeret nul fra den liste. Resultatet, når du udfører koden, er, at navnet Mark vises.
studerende = ["Mark", "Amber", "Todd", "Anita", "Sandy"]
print (studerende [0])
Mærke

Når du læser elementer i adgangslisten, bruger fagfolk ordet sub før nummeret. For eksempel tales studerende [0] som studerende under nul.

Dette næste eksempel viser en liste med navn, scoringer. Funktionen Print () udskriver positionsnummeret for den sidste score på listen, som er 4 (fordi den første altid er nul).

scoringer = [88, 92, 78, 90, 84]
print (scores [4])
84

Hvis du prøver at få adgang til en liste, der ikke findes, får du en "indeks uden for rækkevidde" -fejl. Indeksdelen er en henvisning til antallet inden i de firkantede parenteser. For eksempel viser billedet herunder et lille eksperiment i en Jupyter-notebook, hvor der blev oprettet en liste med scoringer, og derefter blev udskrivningen af ​​score [5] forsøgt.

Det mislykkedes og genererede en fejl, fordi der ikke er nogen score [5]. Der er kun scoringer [0], scoringer [1], scoringer [2], scoringer [3] og scoringer [4], fordi tællingen altid starter ved nul med den første på listen.

Python indeksinterval

Sløjfer gennem en Python-liste

For at få adgang til hvert element på en liste skal du bare bruge en for-loop med denne syntaks:

for x på listen:

Udskift x med et variabelt navn, du vælger. Erstat listen med navnet på listen. En nem måde at gøre koden læselig på er altid at bruge et flertal til listens navn (som studerende, scoringer). Derefter kan du bruge entalnavnet (studerende, score) til variabelnavnet. Du behøver heller ikke bruge abonnementsnumre (tal i firkantede parenteser) med denne tilgang. For eksempel udskriver følgende kode hver score på scorelisten:

til score i scoringer:
print (score)

Husk altid at indrykke koden, der skal udføres i løkken. Dette billede viser et mere komplet eksempel, hvor du kan se resultatet af at køre koden i en Jupyter-notebook.

Sløjfer gennem en Python-liste

Se om en Python-liste indeholder et element

Hvis du vil have din kode til at kontrollere indholdet på en liste for at se, om den allerede indeholder et emne, skal du bruge i listenavn i en if-sætning eller en variabel tildeling.

For eksempel opretter koden på billedet herunder en liste over navne. Derefter gemmer to variabler resultaterne af søgning på listen efter navnene Anita og Bob. Udskrivning af indholdet af hver variabel viser sandt for det, hvor navnet (Anita) er på listen. Testen for at se, om Bob er på listen, beviser falsk.

Se om et element findes på en Python-liste

Få længden af ​​en Python-liste

For at bestemme, hvor mange elementer der er på en liste, skal du bruge len () -funktionen (kort for længden). Læg navnet på listen inde i parenteserne. Skriv f.eks. Følgende kode i en Jupyter-notebook eller Python-prompt eller hvad:

studerende = ["Mark", "Amber", "Todd", "Anita", "Sandy"]
udskrive (LEN (studerende))

Kørsel af denne kode producerer denne output:

5

Der er faktisk fem elementer på listen, skønt den sidste altid er en mindre end antallet, fordi Python begynder at tælle ved nul. Så den sidste, Sandy, henviser faktisk til studerende [4] og ikke studerende [5].

Tilføjelse af et element i slutningen af ​​en Python-liste

Når du ønsker, at din Python-kode skal tilføje et nyt element i slutningen af ​​en liste, skal du bruge metoden .append () med den værdi, du vil tilføje inden for parenteserne. Du kan enten bruge et variabelt navn eller en bogstavelig værdi inde i anførselstegnene.

For eksempel føjer linjen, der læser studerende i følgende billede, tilføjet ("Goober") navnet Goober på listen. Linjen, der læser studerende. Append (new_student) tilføjer det navn, der er gemt i variablen med navnet new_student, på listen. Metoden .append () føjer altid til slutningen af ​​listen. Så når du udskriver listen, ser du de to nye navne i slutningen.

Python-tilføjelsesliste

Du kan bruge en test til at se, om et element er på en liste og derefter tilføje det kun, når varen ikke allerede er der. For eksempel føjer koden nedenfor ikke navnet Amber til listen, fordi dette navn allerede findes på listen:

student_name = "Amanda"

# Tilføj studentnavn, men kun hvis ikke allerede på listen.
hvis studentnavn i studerende:
    udskriv (studentnavn + "allerede på listen")
andet:
    students.append (student_name)
    print (studentnavn + "tilføjet til listen")

Indsættelse af et element i en Python-liste

Selvom append () -metoden giver dig mulighed for at tilføje et element i slutningen af ​​en liste, giver insert () -metoden dig mulighed for at tilføje et element til listen i enhver position. Syntaks for indsættelse () er

listname.insert (position, item)

Udskift listenavn med navnet på listen, placering med den position, hvor du vil indsætte emnet (for eksempel 0 for at gøre det til det første emne, 1 for at gøre det til det andet emne osv.). Erstat emnet med den værdi eller navnet på en variabel, der indeholder den værdi, som du vil lægge på listen.

For eksempel gør følgende kode Lupe til det første punkt på listen:

# Opret en liste over strenge (navn).
studerende = ["Mark", "Amber", "Todd", "Anita", "Sandy"]

student_name = "Lupe"
# Tilføj studerendes navn foran på listen.
students.insert (0, student_name)

# Vis mig den nye liste.
udskrive (studerende)

Hvis du kører koden, viser print (studerende) listen, når det nye navn er indsat som følger:

['Lupe', 'Mark', 'Amber', 'Todd', 'Anita', 'Sandy']

Ændring af et element i en Python-liste

Du kan ændre et element på en liste ved hjælp af tildelingsoperatøren (tjek disse almindelige Python-operatører), ligesom du gør med variabler. Bare sørg for at medtage indeksnummeret i firkantede parenteser for det element, du vil ændre. Syntaks er:

listenavn [index] = NEWVALUE

Udskift listenavn med listen på navnet; udskift indeks med underskriptet (indeksnummer) for det emne, du vil ændre; og erstatte newvalue med det, du vil lægge i listeposten. Se f.eks. Denne kode:

# Opret en liste over strenge (navn).
studerende = ["Mark", "Amber", "Todd", "Anita", "Sandy"]
studerende [3] = "Hobart"
udskrive (studerende)

Når du kører denne kode, er output som følger, fordi Anitas navn er ændret til Hobart.

['Mark', 'Amber', 'Todd', 'Hobart', 'Sandy']

Kombination af Python-lister

Hvis du har to lister, du vil kombinere til en enkelt liste, skal du bruge funktionen ext () med syntaks:

original_list.extend (additional_items_list)

I din kode skal du erstatte original_listen med navnet på den liste, som du vil tilføje nye listeelementer til. Erstat ekstra_items_list med navnet på listen, der indeholder de emner, du vil tilføje til den første liste. Her er et simpelt eksempel ved hjælp af lister, der hedder liste1 og liste2. Efter udførelse af list1.extend (liste2) indeholder den første liste elementerne fra begge lister, som du kan se i output fra udskrivningen () -sætningen i slutningen.

# Opret to lister med navne.
list1 = ["Zara", "Lupe", "Hong", "Alberto", "Jake"]
list2 = ["Huey", "Dewey", "Louie", "Nader", "Bubba"]

# Føj liste2-navne til liste1.
list1.extend (list2)

# Udskriv liste 1.
print (liste1)

['Zara', 'Lupe', 'Hong', 'Alberto', 'Jake', 'Huey', 'Dewey', 'Louie', 'Nader', 'Bubba']

Easy Parcheesi, nej?

Fjernelse af Python-listen

Python tilbyder en remove () -metode, så du kan fjerne enhver værdi fra listen. Hvis elementet er på listen flere gange, fjernes kun den første forekomst. For eksempel viser følgende kode en liste over bogstaver med bogstavet C gentaget et par gange. Derefter bruger koden bogstaver. Fjern ("C") til at fjerne bogstavet C fra listen:

# Fjern "C" fra listen.
letters.remove ( "C")

# Vis mig den nye liste.
udskrive (bogstaver)

Når du faktisk udfører denne kode og derefter udskriver listen, ser du, at kun det første bogstav C er blevet fjernet:

['A', 'B', 'D', 'C', 'E', 'C']

Hvis du har brug for at fjerne alt et emne, kan du bruge en stund-løkke til at gentage. Fjern så længe elementet stadig er på listen. F.eks. Gentager denne kode fjernelsen, så længe “C” stadig er på listen.

# Opret en liste over strenge.
bogstaver = ["A", "B", "C", "D", "C", "E", "C"]

Hvis du vil fjerne et element baseret på dets placering på listen, skal du bruge pop () med et indeksnummer i stedet for at fjerne () med en værdi. Hvis du vil fjerne det sidste element fra listen, skal du bruge pop () uden et indeksnummer.

For eksempel opretter følgende kode en liste, en linje fjerner det første emne (0), og en anden fjerner det sidste punkt (pop () uden noget i parenteserne). Udskrivning af listen viser, at de to elementer er blevet fjernet:

# Opret en liste over strenge.
bogstaver = ["A", "B", "C", "D", "E", "F", "G"]
 
# Fjern det første emne.
letters.pop (0)
# Fjern det sidste emne.
letters.pop ()
 
# Vis mig den nye liste.
udskrive (bogstaver)

At køre koden viser, at dukkingen af ​​den første og den sidste vare faktisk virkede:

['B', 'C', 'D', 'E', 'F']

Når du pop () et element fra listen, kan du gemme en kopi af den værdi i en eller anden variabel. For eksempel viser dette billede den samme kode som ovenfor. Dog gemmer det kopier af, hvad der er blevet fjernet i variabler, der hedder first_removed og last_removed. I slutningen udskrives det Python-listen og viser også hvilke bogstaver, der blev fjernet.

fjern elementer fra Python-listen

Python tilbyder også en del (forkortelse for sletning) -kommando, der sletter ethvert element fra en liste baseret på dets indeksnummer (position). Men igen, skal du huske, at den første vare er nul. Så lad os sige, at du kører følgende kode for at slette varenummer 2 fra listen:

# Opret en liste over strenge.
bogstaver = ["A", "B", "C", "D", "E", "F", "G"]
 
# Fjern emne under 2.
del bogstaver [2]
 
udskrive (bogstaver)

Kørsel af denne kode viser listen igen som følger. Bogstavet C er blevet slettet, hvilket er det korrekte element, der skal slettes, fordi bogstaverne er nummereret 0, 1, 2, 3 osv.

['A', 'B', 'D', 'E', 'F', 'G']

Du kan også bruge del til at slette en hel liste. Brug bare ikke de firkantede parenteser og indeksnummeret. For eksempel opretter koden, du ser nedenfor, en liste og sletter den derefter. Forsøg på at udskrive listen efter sletningen medfører en fejl, fordi listen ikke længere findes, når udskrivningen () -sætningen udføres.

slette Python-listen

Rydning af en Python-liste

Hvis du vil slette indholdet af en liste, men ikke selve listen, skal du bruge .clear (). Listen findes stadig; den indeholder dog ingen varer. Det er med andre ord en tom liste. Følgende kode viser, hvordan du kan teste dette. Kørsel af koden vises [] i slutningen, som lader dig vide, at listen er tom:

# Opret en liste over strenge.
bogstaver = ["A", "B", "C", "D", "E", "F", "G"]
 
# Ryd listen over alle poster.
letters.clear ()
 
# Vis mig den nye liste.
udskrive (bogstaver)

[]

Tæller hvor mange gange et element vises på en Python-liste

Du kan bruge Python count () -metoden til at tælle, hvor mange gange et element vises på en liste. Som med andre listemetoder er syntaksen enkel:

listname.count (x)

Erstat listenavn med navnet på din liste og x med den værdi, du leder efter (eller navnet på en variabel, der indeholder den værdi).

Koden på billedet herunder tæller, hvor mange gange bogstavet B vises på listen ved hjælp af en bogstavelig B inden for parenteserne af .antal (). Den samme kode tæller også antallet af C-kvaliteter, men denne værdi blev gemt i en variabel bare for at vise forskellen i syntaks. Begge tæller arbejdede, som du kan se i output fra programmet i bunden. Den ene blev tilføjet for at tælle F'erne og ikke bruge nogen variabler. F'erne blev talt højre i den kode, der viser meddelelsen. Der er ingen F-kvaliteter, så dette returnerer nul, som du kan se i output.

tæller Python-listen

Når du prøver at kombinere tal og strenge til at danne en meddelelse, skal du huske, at du er nødt til at konvertere numrene til strenge ved hjælp af funktionen str (). Ellers får du en fejl, der læser noget som kun kan sammenkæde str (ikke "int") til str. I denne meddelelse er int kort for heltal, og str er kort for streng.

Findning af et Python-listeelementets indeks

Python tilbyder en .index () -metode, der returnerer et tal, der angiver positionen, baseret på indeksnummer, for et element på en liste. Syntaks er:

listname.index (x)

Udskift som altid listenavn med navnet på den liste, du vil søge. Udskift x hvad du end leder efter (enten som en bogstavelig eller som et variabelt navn, som altid). Der er naturligvis ingen garanti for, at varen er på listen, og selvom den er, er der ingen garanti for, at varen kun er på listen. Hvis varen ikke er på listen, opstår der en fejl. Hvis varen er på listen flere gange, returneres indekset for den første matchende vare.

Følgende billede viser et eksempel, hvor programmet går ned på linjen f_index = grade.index (look_for), fordi der ikke er nogen F på listen.

Indeks for Python-listen

En nem måde at omgå dette problem er at bruge en if-sætning for at se, om et element er på listen, før du prøver at få indeksnummeret. Hvis varen ikke er på listen, skal du få vist en meddelelse, der siger det. Ellers skal du få indeksnummeret og vise det i en meddelelse. Denne kode er som følger:

# Opret en liste over strenge.
karakterer = ["C", "B", "A", "D", "C", "B", "C"]
# Bestem hvad du skal kigge efter
look_for = "F"
# Se om varen er på listen.
hvis look_for i karakterer:
    # Hvis det er på listen, skal du hente og vise indekset.
    print (str (look_for) + "er ved indeks" + str (grade.index (look_for)))
andet:
    # Hvis ikke på listen, prøv ikke engang indeksnummer.
    print (str (look_for) + "er ikke på listen.")

Alfabetisering og sortering af Python-lister

Python tilbyder en sorteringsmetode () til sorteringslister. I sin enkleste form alfabetiserer de elementerne på listen (hvis de er strenge). Hvis listen indeholder tal, sorteres de mindst til størst. For en simpel slags som sådan, skal du bare bruge sortering () med tomme parenteser:

listname.sort ()

Udskift listenavn med navnet på din liste. Følgende billede viser et eksempel ved hjælp af en liste over strenge og en liste over numre. I eksemplet blev der oprettet en ny liste til hver af dem ved blot at tildele hver sorteret liste til et nyt listenavn. Derefter udskriver koden indholdet af hver sorteret liste.

sorter Python-liste

Hvis din liste indeholder strenge med en blanding af store og små bogstaver, og hvis resultaterne af typen ikke ser rigtige ud, prøv at erstatte .sort () med .sort (nøgle = lambda s: s.lower ()) og derefter kører koden igen.

Datoer er lidt vanskeligere, fordi du ikke bare kan indtaste dem som strenge, som "12/31/2020". De skal være datodatatypen for at sortere korrekt. Dette betyder at bruge datetime-modulet og metoden dato () til at definere hver dato. Du kan tilføje datoer til listen, som du ville gøre for enhver anden liste. På følgende linje opretter koden for eksempel en liste med fire datoer, og koden er helt fin.

datoer = [dt.date (2020,12,31), dt.date (2019,1,31), dt.date (2018,2,28), dt.date (2020,1,1)]

Computeren har bestemt ikke noget imod, hvis du opretter listen på denne måde. Men hvis du vil gøre koden mere læsbar for dig selv eller andre udviklere, kan du eventuelt oprette og tilføje hver dato, ad gangen, så bare så det er lidt lettere at se, hvad der foregår, og så har du ikke at håndtere så mange kommaer i en kodelinje. Billedet herunder viser et eksempel, hvor en tom liste med navnet dateliste blev oprettet:

dateliste = []
vis datoer i Python

Derefter blev en dato ad gangen føjet til listen ved hjælp af syntaks dt.date (år, måned, dag).

Når listen er oprettet, bruger koden datelist.sort () til at sortere dem i kronologisk rækkefølge (tidligst til sidst). Du behøver ikke at bruge udskrivning (dataliste) i den kode, fordi den metode viser datoer med de inkluderede datatypeoplysninger som denne:

[datetime.date (2018, 2, 28), datetime.date (2019, 1, 31), datetime.date (2020, 1, 1), datetime.date (2020, 12, 31)]

Ikke den nemmeste liste at læse. Så i stedet for at udskrive hele listen med en udskrivning () -sætning, kan du gennemgå hver dato på listen og udskrive hver formateret med f-strengen% m /% d /% Y. Dette viser hver dato på sin egen linje i mm / dd / åååå

Hvis du vil sortere emner i omvendt rækkefølge, skal du sætte omvendt = Sandt i sorteringen () -parametre (og glem ikke at oprette det første bogstav med store bogstaver). Billedet herunder viser eksempler på sortering af alle tre lister i faldende (omvendt) rækkefølge ved hjælp af omvendt = sandt.

sortere info i Python-listen baglæns

Vend en Python-liste

Du kan også vende rækkefølgen af ​​emner på en liste ved hjælp af .reverse-metoden. Dette er ikke det samme som sortering i omvendt rækkefølge, fordi når du sorterer i omvendt rækkefølge, sorterer du stadig: Z – A for strenge, størst til mindste for tal, senest til tidligst for datoer. Når du reverserer en liste, vender du blot elementerne på listen, uanset deres rækkefølge, uden at prøve at sortere dem på nogen måde.

Følgende kode viser et eksempel, hvor du ændrer rækkefølgen af ​​navnene på listen og derefter udskriver listen. Outputet viser listeposter, der er vendt tilbage fra deres oprindelige rækkefølge:

# Opret en liste over strenge.
names = ["Zara", "Lupe", "Hong", "Alberto", "Jake"]
# Reverse listen
names.reverse ()
# Udskriv listen
udskrive (navne)
 
['Jake', 'Alberto', 'Hong', 'Lupe', 'Zara']

Kopiering af en Python-liste

Hvis du nogensinde har brug for at arbejde med en kopi af en liste, skal du bruge metoden .copy () for ikke at ændre den originale liste. F.eks. Ligner følgende kode den foregående kode, bortset fra at du i stedet for at vende rækkefølgen af ​​den originale liste opretter en kopi af listen og vender den. Udskrivning af indholdet af hver liste viser, hvordan den første liste stadig er i den oprindelige rækkefølge, mens den anden vendes:

# Opret en liste over strenge.
names = ["Zara", "Lupe", "Hong", "Alberto", "Jake"]
 
# Lav en kopi af listen
backward_names = names.copy ()
# Vend kopien
backward_names.reverse ()
 
# Udskriv listen
udskrive (navne)
udskrive (backward_names)
 
['Zara', 'Lupe', 'Hong', 'Alberto', 'Jake']
['Jake', 'Alberto', 'Hong', 'Lupe', 'Zara']

For fremtidige referencer opsummerer nedenstående tabel de metoder, du har lært om.