Utforsk den essensielle `sum()`-funksjonen i Python: Lær hvordan den brukes med ulike datastrukturer gjennom praktiske kodeeksempler.
Når du håndterer samlinger av data i Python, som for eksempel lister med tall, er det vanlig å trenge å beregne summen av alle elementene. Dette behovet oppstår også med andre samlinger, som tupler og sett.
Selv om det finnes flere måter å gjøre dette på, er den anbefalte og mest Python-vennlige metoden å benytte den innebygde `sum()`-funksjonen.
La oss først se på noen alternative tilnærminger, som å bruke løkker og å definere en egen funksjon. Deretter skal vi dykke ned i syntaksen til `sum()` og se på mange kodeeksempler for å få en dypere forståelse.
Summering av verdier i en Python-samling
📋 Du kan eksperimentere med koden i en Python REPL, eller bruke en online Python-editor, som for eksempel tipsbilk.net.
La oss se på denne listen med tall:
>>> tall = [2, 8, 5, 3, 11, 7, 9]
Vårt mål er å beregne summen av alle tallene i denne listen. Vi skal snart lære om `sum()`-funksjonen, men la oss starte med å se på noen andre metoder vi kan bruke. Disse inkluderer:
- Bruk av en enkel `for`-løkke.
- Bruk av `reduce()`-funksjonen fra `functools`-modulen.
- Definere en tilpasset funksjon.
Bruke løkker
For å finne summen av elementene i en liste, kan vi bruke en `for`-løkke som følger:
- Initialiser en variabel `total` til null.
- Gå gjennom listen og hent ut hvert tall.
- Legg tallet til `total`.
>>> tall = [2, 8, 5, 3, 11, 7, 9] >>> total = 0 >>> for t in tall: ... total += t ... >>> total 45
Bruke Reduser-funksjonen
En annen måte å summere elementer i en samling på er å bruke `reduce()`-funksjonen. Denne funksjonen, som finnes i `functools`-modulen, tar inn en funksjon og en samling. Den reduserer samlingen ved å gjentatte ganger bruke funksjonen på elementene i samlingen.
Her bruker vi en `lambda`-funksjon for å definere addisjonen av to tall og sender inn `tall`-listen som samling.
>>> tall = [2, 8, 5, 3, 11, 7, 9] >>> from functools import reduce >>> total = reduce(lambda t1, t2: t1 + t2, tall) >>> total 45
`reduce()`-funksjonen legger til to tall sammen, fra venstre mot høyre, til det er redusert til en enkel sum:
Bruke en egendefinert funksjon
Vi kan også lage vår egen funksjon for å gjøre dette. La oss definere en funksjon `sum_liste` som:
- Tar inn en liste med tall som argument.
- Returnerer summen av elementene i listen.
Funksjonen bruker løkke-metoden vi så på tidligere. Men ved å lage en funksjon, får vi gjenbrukbarhet.
>>> def sum_liste(liste): ... total = 0 ... for t in liste: ... total += t ... return total ...
Kaller vi `sum_liste()` med tall som argumenter, får vi summen 45:
>>> tall = [2, 8, 5, 3, 11, 7, 9] >>> total = sum_liste(tall) >>> total 45
La oss nå se på den innebygde `sum()`-funksjonen. Den er ikke bare enkel å bruke, men også robust ved at den fungerer fint med flere samlinger og datatyper.
Syntaks for Python `sum()`-funksjonen
Syntaksen for å bruke `sum()`-funksjonen ser slik ut:
sum(samling, start)
Her er:
- `samling` er et obligatorisk argument. Det kan være en hvilken som helst samling som summering er gyldig for, for eksempel lister eller tupler med tall. Kaller du `sum()` med strenger, får du en `TypeError`-feil (mer om dette senere).
- `start` er et valgfritt argument. Det er ofte en numerisk verdi som legges til den beregnede summen. Dette kan være nyttig når du trenger å legge til en konstant til resultatet.
Nå som vi har lært syntaksen til `sum()`, la oss bruke den til å summere samlinger.
Summering av samlinger med `sum()`-funksjonen
#1. Liste
La oss finne summen av tall i `tall`-listen ved å bruke `sum()`-funksjonen:
>>> tall = [2, 8, 5, 3, 11, 7, 9] >>> sum_1 = sum(tall) >>> sum_1 45
Bruke den valgfrie startverdien
For å legge til en konstant verdi til summen, kan vi bruke `sum()` med den valgfrie startverdien. Her sender vi inn en startverdi på 100:
>>> sum_start = sum(tall, 100) >>> sum_start 145
Startverdien kan også angis som et nøkkelordargument:
>>> sum_start = sum(tall, start=10) >>> sum_start 55
#2. Tupler
`sum()`-funksjonen fungerer også med tupler. Vi lager en tuppel `tall_tuppel` ved å konvertere tall-listen til en tuppel:
>>> tall_tuppel = tuple(tall) >>> tall_tuppel (2, 8, 5, 3, 11, 7, 9)
>>> sum_2 = sum(tall_tuppel) >>> sum_2 45
#3. Sett
Vi kan også bruke `sum()` med et sett tall:
>>> tall_sett = set(tall)
>>> tall_sett
{2, 3, 5, 7, 8, 9, 11}
Her konverterer vi `tall`-listen til et Python-sett og beregner summen av elementene i `tall_sett`.
>>> sum_3 = sum(tall_sett) >>> sum_3 45
#4. Ordbok
La oss se på følgende ordbok `student_ordbok` med numeriske nøkler. Legg merke til hva som skjer når du kaller `sum()` med denne ordboken som argument.
>>> student_ordbok = {1: 106, 2: 112, 3: 127}
>>> sum_4 = sum(student_ordbok)
>>> sum_4
6
Som standard returnerer `sum()` summen av nøklene.
Summering av nøklene
Vi vet at standardoppførselen er å summere nøklene til ordboken.
Du kan imidlertid gjøre dette mer tydelig ved å bruke ordbokmetoden `keys()` for å få tilgang til nøklene. Deretter sender du listen av nøkler til `sum()`-funksjonen:
>>> sum_nøkler = sum(student_ordbok.keys()) >>> sum_nøkler 6
Summering av verdiene
Hvis du vil summere verdiene i ordboken i stedet, kan du få tilgang til verdiene ved å kalle `values()`-metoden på ordbokobjektet:
>>> sum_verdier = sum(student_ordbok.values()) >>> sum_verdier 345
Bruke Pythons `sum()` med andre numeriske datatyper
Så langt har vi sett hvordan vi kan bruke `sum()`-funksjonen med samlinger av heltall. La oss nå se på noen eksempler med andre numeriske datatyper.
Komplekse tall
`sum()` kan også brukes til å summere komplekse tall. I dette eksemplet er `tall_k` en liste med komplekse tall:
>>> tall_k = [3 + 4j, 1 + 2j] >>> sum_k = sum(tall_k) >>> sum_k (4+6j)
Flyttall
Her bruker vi `sum()` for å summere en liste med flyttall `tall_f`:
>>> tall_f = [1.8, 2.5, 3.6, 7.2] >>> sum_f = sum(tall_f) >>> sum_f 15.100000000000001
📑 For bedre presisjon når du summerer flyttall, kan du bruke `fsum()`-funksjonen fra `math`-modulen.
Utflating med `sum()`-funksjonen
La oss nå se hvordan `sum()` kan brukes til å flate ut og sammenføye samlinger.
Flate ut en liste
Anta at vi har en nestet liste:
>>> lister = [[2, 4, 6], [3, 5, 7]]
Når vi kaller `sum()` ved å sende inn denne nestede listen som argument sammen med en tom liste som startverdi:
>>> sum(lister, []) [2, 4, 6, 3, 5, 7]
Ser vi at den nestede listen er flatet ut til en enkelt liste med tall.
Tilsvarende, når vi tenker på at listen har formen `l3 = [l1, l2]`, så slår `sum()` sammen de to listene `l1` og `l2` som er nestet i listen `l3`.
📝 Prøv selv å bruke `sum()` på andre nestede samlinger.
Vanlig feil: Ikke bruk `sum()` med strenger
Siden vi har sett at `sum()` kan brukes til å flate ut og sammenføye lister (og andre samlinger som tupler), er det lett å tro at vi også kan bruke det til å sette sammen strenger.
Men hvis du prøver å gjøre det, får du en `TypeError`:
>>> sum(['a', 'b', 'c'], '') Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: sum() can't sum strings [use ''.join(seq) instead]
`sum()` kan altså ikke brukes til å summere (eller sette sammen) strenger.
Som vist i feilmeldingen ovenfor, kan du bruke `join()`-metoden for å sette sammen en liste med strenger til en enkelt streng.
>>> ''.join(['a', 'b', 'c']) 'abc'
Konklusjon
I denne veiledningen har vi lært hvordan du bruker den innebygde `sum()`-funksjonen for å finne summen av alle elementene i en samling. Den generelle syntaksen er: `sum(samling, start)`, der `samling` er obligatorisk og `start` er valgfritt.
Vi har også sett flere eksempler for å forstå hvordan `sum()` fungerer med lister, tupler, sett og ordbøker. Vi har også sett hvordan `sum()` kan brukes til å flate ut og sammenføye samlinger, med unntak av strenger.
Jeg håper du fant denne veiledningen nyttig. Du kan også sjekke ut denne veiledningen om Pythons `map()`-funksjon.