Ønsker du å skrive kode i Python som er både elegant og effektiv? Da er du kommet til rett sted! Her presenterer vi en samling smarte Python-enlinjere som kan forenkle vanlige oppgaver.
For de som er nye i Python-programmering, er det viktig å forstå grunnleggende datastrukturer som lister og strenger. Mange operasjoner på disse strukturene kan utføres med konsise, enlinjes kodebiter.
Selv om lesbarhet og vedlikehold av koden alltid bør prioriteres, er det fullt mulig å skrive enlinjere i Python som også følger god kodepraksis.
Denne artikkelen fokuserer på enlinjere for enkle liste- og strengmanipulasjonsoppgaver i Python.
La oss dykke inn!
Opprett en tallrekke
Den enkleste måten å generere en liste med tall er ved å bruke `range()`-funksjonen. Denne funksjonen returnerer et områdeobjekt, som enkelt kan konverteres til en liste. `range(tall)` genererer sekvensen 0, 1, 2, …, `tall`-1.
>>> tallrekke = list(range(10)) >>> tallrekke [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Mer om bruken av `range()`-funksjonen:
Du kan også bruke `range()` med en valgfri stegverdi. Så, `range(start, slutt, steg)` genererer sekvensen `start`, `start + steg`, `start + 2*steg`, og så videre. Den siste verdien vil være `start + k*steg` slik at `(start + k*steg) < slutt` og `(start + (k+1)*steg) > slutt`.
Finn den høyeste og laveste verdien i en liste
Python tilbyr de innebygde funksjonene `max()` og `min()` for å enkelt finne henholdsvis det største og minste elementet i en liste.
>>> min_verdi, maks_verdi = min(tallrekke), max(tallrekke) >>> min_verdi 0 >>> maks_verdi 9
Viktig om flere tildelinger:
Legg merke til at vi har tildelt verdier til både `min_verdi` og `maks_verdi` i en enkelt setning. Python tillater slike multiple tildelinger, noe som er praktisk for å pakke ut itererbare objekter og tildele verdier til flere variabler samtidig.
Fjern gjentakende elementer fra en liste
En annen vanlig oppgave er å fjerne duplikater fra lister. Dette er nyttig når du kun ønsker å jobbe med unike verdier. Den mest effektive måten å gjøre dette på, er å konvertere listen til et sett.
Et sett er en innebygd datastruktur som kun tillater unike og hashbare elementer.
>>> tallrekke2 = [2,4,7,9,7,10]
I `tallrekke2` forekommer tallet 7 to ganger. Når vi konverterer den til et sett, fjernes duplikatet (tallet 7), og vi sitter igjen med en samling av unike verdier.
Siden vi ønsker å jobbe med en liste, konverterer vi settet tilbake til en liste. Denne operasjonen kan utføres med følgende linje kode:
>>> tallrekke2 = list(set(tallrekke2)) >>> tallrekke2 [2, 4, 7, 9, 10]
For å lære mer om ulike teknikker for å fjerne duplikater fra lister, sjekk ut denne veiledningen.
Tell forekomster i en liste
For å telle hvor mange ganger et element forekommer i en liste, kan du bruke den innebygde `count()`-metoden. `list.count(element)` returnerer antallet ganger `element` forekommer i listen.
>>> tallrekke [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Her forekommer 7 én gang i `tallrekke`, så `count()`-metoden vil returnere 1.
>>> tallrekke.count(7) 1
Sjekk om alle elementer i en liste oppfyller en betingelse
For å sjekke om alle elementene i en liste oppfyller en gitt betingelse, kan du bruke Pythons innebygde `all()`-funksjon.
`all()`-funksjonen tar en iterabel som argument og returnerer `True` dersom alle elementene i denne er sanne (eller evalueres til `True`).
Her sjekker vi om alle elementene i `tallrekke3`-listen er oddetall.
>>> tallrekke3 = [3,4,7,11,21,67,12]
Vi kan bruke listeforståelse for å generere en liste av boolske verdier, som så sendes inn som argument til `all()`-funksjonen.
Her vil `tall%2!=0` være `False` for elementene 4 og 12, som er partall. Derfor vil listen over boolske verdier konstruert ved hjelp av listeforståelse inneholde `False` (og `all(liste)` vil returnere `False`).
>>> all([tall%2!=0 for tall in tallrekke3]) False
Det er viktig å merke seg at `all([])` (alle tomme itererbare objekter) returnerer `True`.
Sjekk om minst ett element i listen oppfyller en betingelse
For å sjekke om minst ett element i en liste oppfyller en bestemt betingelse, kan du bruke `any()`-funksjonen. `any(en-liste)` returnerer `True` dersom minst ett element evalueres til `True`.
>>> tallrekke3 = [3,4,7,11,21,67,12]
Som i forrige eksempel bruker vi listeforståelse for å få en liste med boolske verdier. Siden listen inneholder partall, vil `any()`-funksjonen returnere `True`.
>>> any([tall%2 for tall in tallrekke3]) True
Reverser en streng
I Python er strenger uforanderlige, så når du ønsker å reversere en streng, må du lage en reversert kopi av den. Det finnes to vanlige tilnærminger – som begge kan skrives som enlinjere – ved hjelp av strengslicing og innebygde funksjoner.
Bruke strengslicing
Strengslicing med negative stegverdier gir en del av strengen fra slutten. Syntaksen er `streng[start:slutt:steg]`. Hva skjer når vi setter steg til -1 og ignorerer start- og sluttindeksene?
Den returnerer en kopi av strengen, fra slutten til begynnelsen – inkludert hvert tegn.
>>> streng1 = 'hei' >>> streng1[::-1] 'ieh'
Bruke `reversed()`-funksjonen
Den innebygde `reversed()`-funksjonen returnerer en reversert iterator over en sekvens.
>>> reversed(streng1) <reversed object at 0x008BAF70> >>> for tegn in streng1: ... print(tegn) ... h e i
Du kan bruke den sammen med `join()`-metoden, som vist her:
>>> ''.join(reversed(streng1)) 'ieh'
Konverter en streng til en liste med tegn
Anta at vi ønsker å dele en streng til en liste med tegn. Vi kan gjøre dette med listeforståelse.
>>> streng1 = 'hei'
Listeforståelse er et kraftig verktøy i Python.
Vi går gjennom strengen og samler hvert tegn.
>>> tegn = [tegn for tegn in streng1] >>> tegn ['h', 'e', 'i']
For å dele en lengre streng inn i en liste av strenger ved hvert mellomrom, kan du bruke `split()`-metoden.
>>> streng2 = 'hei verden' >>> streng2.split() ['hei', 'verden']
Plukk ut tall fra en streng
Vi har allerede sett hvordan man bruker listeforståelse for å dele en streng i en liste av tegn. I det eksemplet samlet vi alle tegnene ved å gå gjennom strengen.
Nå skal vi gå gjennom strengen og kun samle sifrene. Hvordan gjør vi det?
- Vi kan spesifisere en filtreringsbetingelse i listeforståelsen ved å bruke `isdigit()`-metoden.
- `c.isdigit()` returnerer `True` hvis `c` er et siffer, ellers returnerer den `False`.
>>> streng3 = 'python3' >>> tall = [c for c in streng3 if c.isdigit()] >>> tall ['3']
Sjekk om en streng starter med en bestemt delstreng
For å sjekke om en streng starter med en spesifikk delstreng, kan du bruke strengmetoden `startswith()`. `streng1.startswith(delstreng)` returnerer `True` dersom `streng1` starter med `delstreng`, ellers `False`.
Her er noen eksempler:
>>> streng4 = 'koding'
>>> streng4.startswith('ko')
True
>>> streng5 = 'python'
>>> streng5.startswith('ko')
False
Sjekk om en streng slutter med en spesifikk delstreng
Som du kanskje har gjettet, kan du bruke `endswith()`-metoden for å sjekke om en streng slutter med en gitt delstreng.
>>> streng5 = 'python'
>>> streng5.endswith('on')
True
Vi kan også bruke denne strengmetoden i en listeforståelse for å få en liste over boolske verdier, som vist her:
>>> strenger = ['python','neon','nano','silicon']
>>> slutter_med = [str.endswith('on') for str in strenger]
>>> slutter_med
[True, True, False, True]
Slå sammen elementer fra en liste til en streng
Vi har allerede sett hvordan man deler en streng inn i en liste av tegn. Hvordan gjør vi det motsatte, altså slår sammen elementene i en liste til en streng?
Dette kan gjøres med strengmetoden `join()` med syntaksen `separator.join(en-liste)`. Vi ønsker å kombinere alle elementene i listen til en enkelt streng, uten noen separator. Da setter vi separatoren til en tom streng.
>>> liste_1 = ['p','y','t','h','o','n','3'] >>> ''.join(liste_1) 'python3'
Lag en Python-ordbok
På samme måte som listeforståelse hjelper oss å lage nye lister fra eksisterende itererbare objekter, kan ordbokforståelse hjelpe oss å generere nye ordbøker fra eksisterende itererbare objekter.
Python ordbokforståelse er en kraftig enlinjer som kan hjelpe deg å lage en ordbok raskt og enkelt.
Her har vi en liste med strenger kalt `navn`.
>>> navn = ['Joe','Amy','Jake','Florence']
Vi lager `navn_d`, en ordbok som inneholder navnene som nøkler og lengden på hvert navn som verdi.
>>> navn_d = {navn:len(navn) for navn in navn}
>>> navn_d
{'Joe': 3, 'Amy': 3, 'Jake': 4, 'Florence': 8}
Betinget tildeling av verdier til variabler
Noen ganger må du kanskje tilordne verdier til variabler basert på en bestemt betingelse.
For eksempel kan du lese inn brukerdata, for eksempel alderen til en person. Avhengig av inndataverdien kan du bestemme om vedkommende får delta på et arrangement eller ikke.
For å utføre en slik betinget tildeling i Python, kan du skrive følgende enlinjer ved å bruke den ternære operatoren:
>>> alder = 21 >>> tillatt = True if alder >= 18 else False >>> tillatt True
Lær mer om den ternære operatoren i Python.
Generer alle permutasjoner
Permutasjon refererer til en mulig rekkefølge av elementer i en gruppe. Hvis det finnes n unike elementer i en gruppe, finnes det n! mulige måter å ordne dem på – og dermed n! permutasjoner.
La oss bruke den følgende listen med bokstaver:
>>> bokstaver = ['a','b','c']
Du kan bruke `permutations()` fra `itertools`-modulen for å generere alle mulige permutasjoner av den gitte itererbare sekvensen.
>>> from itertools import permutations >>> bokstaver_p = permutations(bokstaver) >>> bokstaver_p <itertools.permutations object at 0x0127AF50>
Som vi ser, returnerer `permutations(iterabel)` et permutasjonsobjekt som vi kan iterere over ved hjelp av en `for`-løkke:
>>> for p in bokstaver_p:
... print(p)
...
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')
Vi kan skrive dette som en enlinjer ved å konvertere permutasjonsobjektet til en liste:
>>> bokstaver_p = list(permutations(bokstaver))
>>> bokstaver_p
[('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]
Her er det tre unike elementer, og det finnes 3! = 6 mulige permutasjoner.
Generer delsett av en liste
Noen ganger kan du ha behov for å konstruere alle mulige delsett av en bestemt størrelse fra en liste. La oss bruke `bokstaver`-listen og finne alle underlister med størrelse 2.
Dette kan gjøres ved å bruke `combinations()` fra `itertools`-modulen, slik:
>>> from itertools import combinations
>>> bokstaver_2 = list(combinations(bokstaver,2))
>>> bokstaver_2
[('a', 'b'), ('a', 'c'), ('b', 'c')]
Konklusjon
I denne artikkelen har vi sett på nyttige Python enlinjere for å utføre vanlige operasjoner på lister og strenger. Vi har også lært om Python-listeforståelse og ordbokforståelse, og hvordan de kan brukes sammen med innebygde funksjoner for å utføre ulike oppgaver.
Som et neste skritt kan du sjekke ut denne listen over nybegynnervennlige Python-prosjekter.