Jobbar du med sifferdata i Python? Ta din kunskap till nästa nivå genom att utforska de olika metoderna för att avrunda tal.
De flesta datasamlingar från verkliga situationer innehåller både numeriska och kategoriska data. Det finns en stor variation av numeriska data, allt från sensoravläsningar till valutakurser, biomedicinska signaler och mer.
När du handskas med numeriska värden kan det vara nödvändigt att avrunda dem till en bestämd precision, till exempel för att:
- Säkerställa ett enhetligt format
- Underlätta lagring och bearbetning
I den här guiden går vi igenom olika sätt att avrunda ett tal till en viss precision, samt att avrunda tal uppåt och nedåt till närmaste heltal och mycket mer.
Låt oss sätta igång.
Hur man avrundar tal med den inbyggda `round()`-funktionen
Det vanligaste sättet att avrunda tal i Python är att använda den inbyggda funktionen `round()`. Vi börjar med att granska dess syntax:
round(num, ndigits)
Här är:
- `num` är det tal du vill avrunda.
- `ndigits` är en frivillig parameter med standardvärdet `None`. Det anger antalet siffror som talet ska avrundas till. Om `ndigits = 2`, avrundas `num` till två decimaler.
- Funktionen `round()` returnerar `num` avrundat till `ndigits` precision efter decimaltecknet.
Exempel på användning av Pythons `round()`-funktion
Låt oss undersöka några kodexempel för att förstå hur funktionen `round()` fungerar.
Som tidigare nämnts är `ndigits` valfritt. Så, när vi anropar `round()` med endast talet, avrundas talet till närmaste heltal.
number = 7.123456 rounded = round(number) print(rounded) # Utdata: 7
Låt oss nu ta några exempel där vi anger precisionen.
Med `n`-siffror inställda på 2 avrundas talet till två decimaler (tiondels plats):
number = 7.123456 rounded = round(number, 2) print(rounded) # Utdata: 7.12
Med `n`-siffror inställda på 3, avrundas talet till tre decimaler (hundradels plats):
number = 7.123456 rounded = round(number, 3) print(rounded) # Utdata: 7.123
Du kan även använda `round()` för att avrunda negativa tal:
number = -3.4 rounded = round(number) print(rounded) # Utdata: -3
Här avrundar funktionen -3,4 till -3, det närmaste heltalet.
Avrundning till närmaste tiotals- och hundratalsplats
Visste du att `ndigits` även kan ta negativa värden?
Ja, du kan anropa funktionen `round()` med negativa värden för `ndigits`. När du gör det sker avrundningen till vänster om decimaltecknet i stället för till höger.
Vad innebär det? Låt oss granska några exempel.
När vi ställer in `ndigits` till -1, avrundas talet till närmaste tiotal.
number = 7.123456 rounded = round(number, -1) print(rounded) # Utdata: 10.0
Och genom att anropa funktionen `round()` med `ndigits` inställt på -2, avrundas talet 77,123456 upp till närmaste hundratal, vilket i detta fall är 100,0.
number = 77.123456 rounded = round(number, -2) print(rounded) # Utdata: 100.0
Hittills verkar funktionen `round()` följa de vanliga avrundningsprinciper som vi har lärt oss i grundskolans matematik. Men det är inte alltid fallet.
Det finns vissa begränsningar med flyttal. Därför kan du ibland se oväntade resultat vid avrundning. Ett annat intressant fenomen är bankiravrundning.
Vad är bankiravrundning?
Öppna en Python REPL och prova följande exempel:
>>> round(1.5) 2
Vi ser att `round(1.5)` ger 2 (som förväntat). Så vad ska `round(2.5)` returnera?
>>> round(2.5) 2
Intressant, eller hur? Både `round(1.5)` och `round(2.5)` ger 2. Men hur och varför?
Internt fungerar `round`-funktionen på det här sättet: alla värden som ligger exakt mitt emellan två heltal avrundas till det närmaste jämna heltalet. Det här kallas bankiravrundning eller ”round half to even”-strategin.
Vi vet att funktionen `round()` räcker för enkla avrundningsuppgifter. Men ibland kan du behöva avrunda ett tal uppåt eller nedåt till närmaste heltal.
Hur gör man det? Det ska vi lära oss i nästa avsnitt.
Hur man rundar upp siffror i Python
För att runda upp ett tal till närmaste heltal kan du använda:
Använda `math.ceil`
Funktionen `ceil()` (eller takfunktionen) fungerar på det sättet att den rundar upp ett tal till det minsta heltal som är större än talet.
Följande kodavsnitt visar hur du använder funktionen `ceil()` för att runda upp talet 3,2:
import math number = 3.2 rounded_up = math.ceil(number) print(rounded_up) # Utdata: 4
Använda decimalmodulen
Hittills har vi använt den inbyggda flyttalsdatatypen. Men för vissa tillämpningar inom vetenskaplig databehandling och ekonomi behöver vi en mycket högre precision. För det levereras Python med decimalmodulen, som ger:
- Mer exakt flyttalsaritmetik.
- Tillförlitlig jämlikhetstestning.
- Finare kontroll över precisionsnivån (standardprecisionen är 28 siffror).
För att se det aktuella sammanhanget, använd `getcontext()` som visas:
from decimal import getcontext current_context = getcontext() print(current_context)
Du ska kunna se den aktuella precisionen och avrundningsläget, bland annat:
# Utdata Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
För att runda upp ett tal kan du använda `quantize()` genom att ange:
- Precisionen (0,0 eftersom vi vill avrunda uppåt till närmaste heltal), och
- Avrundningsläget: `ROUND_CEILING`.
from decimal import Decimal, ROUND_CEILING
number = Decimal('3.2')
rounded_up = number.quantize(Decimal('0'), rounding=ROUND_CEILING)
print(rounded_up)
# Utdata: 4
Här har talet 3,2 avrundats uppåt till närmaste heltal 4.
Hur man rundar ned siffror i Python
Låt oss nu titta på hur man avrundar siffror nedåt i Python. I likhet med upprundningsprocessen kan vi använda antingen `math`- eller `decimal`-modulerna.
Använda `math.floor`
Funktionen `floor()` från `math`-modulen fungerar på det här sättet: Den avrundar nedåt ett tal till det största heltal som är mindre än talet.
Låt oss ta följande exempel:
import math number = 3.8 rounded_down = math.floor(number) print(rounded_down) # Utdata: 3
Här rundar funktionen `floor()` ner flyttalstalet 3,8 till 3.
Använda decimalmodulen
För att avrunda ett tal nedåt kan du använda `quantize()` genom att ställa in avrundningsläget till `ROUND_FLOOR`.
from decimal import Decimal, ROUND_FLOOR
number = Decimal('3.8')
rounded_down = number.quantize(Decimal('0'), rounding=ROUND_FLOOR)
print(rounded_down)
# Utdata: 3
Som vi ser har 3,8 avrundats nedåt till 3.
Vanliga fallgropar att undvika när man avrundar siffror
Vi har redan sett att funktionen `round()` rundar ”halvt till jämnt”, vilket kanske inte alltid är önskvärt. Det finns några andra vanliga fallgropar att undvika när man avrundar tal i Python:
- Felaktig jämlikhetsjämförelse: Avrundning av tal introducerar ofta avrundningsfel. Om du försöker utföra en likhetsjämförelse mellan ett avrundat resultat med ett annat värde, kommer likhetskontrollen (nästan alltid) att misslyckas på grund av varierande precision. Försök därför att undvika likhetskontroller mellan flyttal och avrundade flyttal. Om jämförelsen är nödvändig, inför en toleransgräns.
- Förlust av information: Du kanske vill att vissa data, t.ex. sensoravläsningar vid olika tidpunkter, ska spelas in med hög precision. Att avrunda sådana data till färre decimaler leder till informationsförlust och felaktig analys.
- Avrundning av mellanresultat: Du har ofta flera steg som en del av beräkningen. Använd en konsekvent precision i alla steg. Undvik även avrundning i mellansteg för att förhindra att avrundningsfelen blir kumulativa.
Bästa metoder för att runda siffror i Python
Låt oss lista några bästa metoder att följa när du avrundar tal i Python:
- Välj rätt datatyp: Välj mellan flyttals- och decimaldatatyp beroende på tillämpningen. Om du behöver utföra flyttalsaritmetik med hög precision, välj decimaldatatypen.
- Använd konsekventa precisionsnivåer: Ställ in konsekventa precisionsnivåer för decimaltal genom hela programmet för att undvika oväntade avrundningsfel.
- Dokumentera avrundningstekniker: I verkliga tillämpningar som involverar data som valuta- och sensoravläsningar är det viktigt att ha en konsekvent och dokumenterad avrundningsteknik på plats.
Avslutning
Låt oss avsluta guiden med en snabb genomgång av vad vi har lärt oss:
- Du kan använda den inbyggda funktionen `round()` med syntaxen `round(num, ndigits)`. När du använder funktionen `round()` bör du vara medveten om bankiravrundningsstrategin. Den avrundar tal exakt mellan två heltal till närmaste jämna heltal.
- Du kan använda funktionerna `ceil()` och `floor()` från `math`-modulen för att avrunda uppåt respektive nedåt ett givet tal till närmaste heltal.
- När du behöver utföra aritmetik med hög precision med flyttal, använd decimalmodulen. Du kan avrunda siffror med önskad precision och avrundningsstrategi.
- Du bör vara medveten om de vanliga fallgroparna med avrundning av siffror i Python. De inkluderar informationsförlust från avrundning, avrundning av resultat i mellansteg och användning av varierande precision i olika delar av koden.
- Bästa metoderna inkluderar att välja rätt datatyp beroende på tillämpningen och dokumentera konsekventa precisionsnivåer.
Lär dig sedan hur du utför golvdivision i Python.
Var den här artikeln användbar?
Tack för din återkoppling!