Lær å Mestre Avrunding av Tall i Python
Jobber du med numeriske data i Python? Utvid dine ferdigheter ved å utforske de ulike metodene for å avrunde tall.
De fleste reelle datasett inneholder både numeriske og kategoriske data. Numeriske data omfatter alt fra sensoravlesninger til valutakurser, biomedisinske signaler, og mye mer.
Når du jobber med numeriske verdier, kan det være nødvendig å avrunde dem til en bestemt presisjon for å:
- Sikre et konsistent format
- Forenkle lagring og prosessering
I denne veiledningen vil vi utforske de forskjellige teknikkene for å avrunde tall til en spesifikk presisjon, avrunde opp og ned til nærmeste heltall, og andre relevante metoder.
La oss begynne!
Avrunding med den Innebygde `round()` Funksjonen
Den mest brukte metoden for å avrunde tall i Python er ved hjelp av den innebygde funksjonen `round()`. La oss se på syntaksen:
round(tall, antall_desimaler)
Hvor:
- `tall` er den numeriske verdien du ønsker å avrunde.
- `antall_desimaler` er en valgfri parameter, som standard er None. Den angir antall desimalplasser tallet skal avrundes til. Hvis `antall_desimaler` er 2, vil `tall` avrundes til to desimaler.
- `round()`-funksjonen returnerer det avrundede tallet med spesifisert presisjon.
Eksempler på Bruk av `round()`
La oss se på noen praktiske eksempler for å forstå hvordan `round()` fungerer.
Som nevnt er `antall_desimaler` valgfritt. Når vi bruker `round()` kun med tallet, vil det avrundes til nærmeste heltall.
tall = 7.123456 avrundet = round(tall) print(avrundet) # Output: 7
La oss nå se på eksempler der vi angir presisjonen.
Når `antall_desimaler` settes til 2, avrundes tallet til to desimaler:
tall = 7.123456
avrundet = round(tall, 2)
print(avrundet)
# Output: 7.12
Og med `antall_desimaler` satt til 3, avrundes tallet til tre desimaler:
tall = 7.123456
avrundet = round(tall, 3)
print(avrundet)
# Output: 7.123
Du kan også bruke `round()` for å avrunde negative tall:
tall = -3.4
avrundet = round(tall)
print(avrundet)
# Output: -3
Her avrundes -3.4 til -3, det nærmeste heltallet.
Avrunding til Nærmeste Tier og Hundrer
Visste du at `antall_desimaler` også kan være negativt?
Når du bruker negative verdier for `antall_desimaler`, skjer avrundingen til venstre for desimaltegnet.
Hva betyr det? La oss se på noen eksempler.
Med `antall_desimaler` satt til -1, avrundes tallet til nærmeste tier:
tall = 7.123456 avrundet = round(tall, -1) print(avrundet) # Output: 10.0
Når vi bruker `round()` med `antall_desimaler` satt til -2, avrundes 77.123456 til nærmeste hundre, som i dette tilfellet er 100.0.
tall = 77.123456 avrundet = round(tall, -2) print(avrundet) # Output: 100.0
Så langt ser det ut til at `round()` følger de vanlige reglene for avrunding. Men dette er ikke alltid tilfelle.
Det finnes begrensninger med flyttall. Derfor kan du oppleve uventede resultater. En annen viktig ting er bankers avrunding.
Hva er Bankers Avrunding?
Start en Python-konsoll og prøv:
>>> round(1.5) 2
Vi ser at `round(1.5)` gir 2 (som forventet). Hva vil `round(2.5)` returnere?
>>> round(2.5) 2
Interessant, ikke sant? Både `round(1.5)` og `round(2.5)` gir 2. Men hvordan og hvorfor?
Internt fungerer `round()` slik: en verdi som er midt mellom to heltall, avrundes til nærmeste partall. Dette kalles bankers avrunding, eller «round half to even» strategi.
Vi vet at `round()` fungerer fint for enkle avrundingsoppgaver. Men noen ganger trenger vi å avrunde opp eller ned til nærmeste heltall.
La oss se hvordan det gjøres i neste avsnitt.
Hvordan Runde Opp Tall i Python
For å runde opp et tall til nærmeste heltall, kan du bruke:
Bruk av `math.ceil`
Funksjonen `ceil()` (eller takfunksjonen) runder opp et tall til det minste heltallet som er større enn tallet.
Følgende eksempel viser hvordan du bruker `ceil()` til å runde opp tallet 3.2:
import math tall = 3.2 avrundet_opp = math.ceil(tall) print(avrundet_opp) # Output: 4
Bruk av `decimal`-modulen
Vi har så langt brukt flyttallsdatatypen. Men for visse bruksområder, spesielt innen vitenskap og finans, trenger vi høyere presisjon. Python leverer derfor `decimal`-modulen, som gir:
- Mer presis flyttallsaritmetikk
- Pålitelig sammenligning av likhet
- Finere kontroll over presisjonsnivået (standard presisjon er 28 desimaler)
For å se gjeldende kontekst, bruk `getcontext()`:
from decimal import getcontext
gjeldende_kontekst = getcontext()
print(gjeldende_kontekst)
Du vil se gjeldende presisjon og avrundingsmodus:
# Output
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
For å runde opp et tall kan du bruke `quantize()` ved å spesifisere:
- Presisjonen (0.0 siden vi ønsker å runde opp til nærmeste heltall), og
- Avrundingsmodus: `ROUND_CEILING`
from decimal import Decimal, ROUND_CEILING
tall = Decimal('3.2')
avrundet_opp = tall.quantize(Decimal('0'), rounding=ROUND_CEILING)
print(avrundet_opp)
# Output: 4
Her avrundes 3.2 opp til nærmeste heltall, 4.
Hvordan Runde Ned Tall i Python
La oss se på hvordan du runder ned tall i Python. Som ved avrunding opp, kan vi bruke enten `math`- eller `decimal`-modulene.
Bruk av `math.floor`
Funksjonen `floor()` fra `math`-modulen runder ned et tall til det største heltallet som er mindre enn tallet.
La oss se på dette eksemplet:
import math tall = 3.8 avrundet_ned = math.floor(tall) print(avrundet_ned) # Output: 3
Her runder `floor()` ned 3.8 til 3.
Bruk av `decimal`-modulen
For å runde ned et tall, kan du bruke `quantize()` med `ROUND_FLOOR` som avrundingsmodus.
from decimal import Decimal, ROUND_FLOOR
tall = Decimal('3.8')
avrundet_ned = tall.quantize(Decimal('0'), rounding=ROUND_FLOOR)
print(avrundet_ned)
# Output: 3
Som du ser, avrundes 3.8 ned til 3.
Vanlige Fallgruver å Unngå Ved Avrunding av Tall
Vi har sett at `round()` avrunder til nærmeste partall, noe som ikke alltid er ønsket. Det er også noen andre vanlige fallgruver:
- Feil sammenligning av likhet: Avrunding av tall kan føre til avrundingsfeil. Hvis du sammenligner et avrundet resultat med en annen verdi, vil ofte likhetstesten feile. Unngå derfor direkte likhetstester mellom flyttall og avrundede flyttall. Hvis en sammenligning er nødvendig, introduser en toleransegrense.
- Tap av informasjon: Avrunding av data med høy presisjon kan føre til tap av informasjon og unøyaktig analyse.
- Avrunding av mellomresultater: Bruk konsekvent presisjon gjennom alle trinn i beregningen. Unngå avrunding i mellomtrinn for å hindre at avrundingsfeilene blir kumulative.
Beste Praksis for Å Runde Tall i Python
Her er noen anbefalte praksiser for avrunding av tall i Python:
- Velg riktig datatype: Velg mellom flytende og desimaldatatype avhengig av behovet. For flyttallsaritmetikk med høy presisjon, bruk desimaldatatype.
- Bruk konsistente presisjonsnivåer: Angi konsistente presisjonsnivåer for desimaltall gjennom hele programmet.
- Dokumenter avrundingsmetoder: I virkelig bruk av data som valuta og sensorverdier, er det viktig å ha en konsistent og dokumentert avrundingsmetode.
Oppsummering
La oss oppsummere det vi har lært:
- Du kan bruke den innebygde `round()`-funksjonen med syntaksen `round(tall, antall_desimaler)`. Vær klar over bankers avrunding når du bruker `round()`.
- Du kan bruke funksjonene `ceil()` og `floor()` fra `math`-modulen for å runde opp og ned et tall til nærmeste heltall.
- For flyttallsaritmetikk med høy presisjon, bruk `decimal`-modulen.
- Vær oppmerksom på fallgruver ved avrunding i Python, som tap av informasjon, avrunding i mellomtrinn og bruk av ulik presisjon.
- Anbefalte praksiser inkluderer å velge riktig datatype og å dokumentere konsekvente presisjonsnivåer.
Neste trinn er å lære om gulvdivisjon i Python.
Var denne artikkelen nyttig?
Takk for din tilbakemelding!