Arbetar du med numeriska datatyper i Python? Gå upp i nivå genom att lära dig de olika sätten att avrunda tal i Python.
De flesta datauppsättningar från den verkliga världen innehåller såväl numeriska som kategoriska funktioner. Det finns ett brett utbud av numeriska funktioner, från sensoravläsningar till valutakurser, biomedicinska signaler och mer.
När du arbetar med numeriska värden kan du behöva avrunda dessa värden till en fast precision av anledningar som:
- Att säkerställa ett konsekvent format
- Enklare lagring och bearbetning
I den här handledningen lär vi oss de olika sätten att avrunda ett tal till en specifik precision, avrunda uppåt och nedåt tal till närmaste heltal och mycket mer.
Låt oss börja.
Innehållsförteckning
Hur man avrundar tal med den inbyggda round()-funktionen
Den vanligaste metoden att avrunda tal i Python är att använda den inbyggda round() funktion. Låt oss börja med att lära oss dess syntax:
round(num, ndigits)
Här,
- num är talet som du vill avrunda
- ndigits är en valfri parameter med standardvärdet None. Det är antalet platser att avrunda talet till. Om ndigits = 2, avrundas num till två platser efter decimalkomma.
- Funktionen round() returnerar num avrundat till ndigits precision efter decimalkomma.
Python round() Exempel på funktionsanvändning
Låt oss koda några exempel för att förstå hur funktionen round() fungerar.
Som nämnts är ndigits valfritt. Så när vi anropar round() med bara talet, avrundas talet till närmaste heltal.
number = 7.123456 rounded = round(number) print(rounded) # Output: 7
Låt oss nu ta några exempel där vi specificerar precisionen.
Med n-siffror inställda på 2 avrundas talet till två decimaler (tionde plats):
number = 7.123456 rounded = round(number, 2) print(rounded) # Output: 7.12
Med n-siffror inställda på 3, avrundas talet till tre decimaler (hundrade plats):
number = 7.123456 rounded = round(number, 3) print(rounded) # Output: 7.123
Du kan använda round() för att runda negativa tal också:
number = -3.4 rounded = round(number) print(rounded) # Output: -3
Här avrundar funktionen -3,4 till -3, närmaste heltal.
Avrundning till närmaste tiotals och hundratals plats
Visste du att ndigits också 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 decimalkomma istället för till höger.
Vad betyder det här? Låt oss se några exempel.
När vi sätter ndigits till -1, avrundas talet till närmaste tiotal.
number = 7.123456 rounded = round(number, -1) print(rounded) # Output: 10.0
Och att anropa funktionen round() med ndigits inställda på -2 avrundar talet 77,123456 uppåt till närmaste hundratal, vilket i det här fallet är 100,0.
number = 77.123456 rounded = round(number, -2) print(rounded) # Output: 100.0
Hittills verkar round()-funktionen följa de allmänna principerna för avrundning som vi har lärt oss i skolmatte. Men så är det inte alltid.
Det finns några begränsningar med flyttal tal. Så du kan se några oväntade resultat när du avrundar. En annan intressant varning är bankirens avrundning.
Vad är Bankers avrundning?
Starta 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, ja? Både runda(1,5) och runda(2,5) ger 2. Men hur och varför?
Internt fungerar den runda funktionen så här: alla värden som är mitt emellan två heltal avrundas till närmaste jämna heltal. Det här kallas bankirens avrundning eller den runda halvan till jämn strategi.
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.
Så hur gör man det? Låt oss lära oss det 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änder math.ceil
Funktionen ceil() (eller takfunktionen) fungerar så här: Den rundar upp ett tal till det minsta heltal som är större än talet.
Följande utdrag 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) # Output: 4
Använda decimalmodulen
Hittills har vi använt den inbyggda flytdatatypen. Men för vissa tillämpningar inom vetenskaplig beräkning och ekonomi behöver vi mycket högre precision. Och för detta levereras Python med decimalmodulen som ger:
- Mer exakt flyttalsaritmetik
- Tillförlitlig jämställdhetstestning
- Finare kontroll över precisionsnivån (standardprecisionen är 28 platser)
För att se det aktuella sammanhanget, använd getcontext() som visas:
from decimal import getcontext current_context = getcontext() print(current_context)
Du bör kunna se det aktuella precisions- och avrundningsläget, bland annat:
# Output 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)
# Output: 4
Här har talet 3,2 avrundats uppåt till närmaste heltal 4.
Hur man avrundar siffror i Python
Låt oss nu se hur man avrundar siffror i Python. I likhet med avrundningsprocessen kan vi använda antingen matematik- eller decimalmodulerna.
Använder math.floor
floor()-funktionen från matematikmodulen fungerar så här: 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) # Output: 3
Här rundar floor()-funktionen ner flyttalstalet 3,8 till 3.
Använda decimalmodulen
För att avrunda ett tal 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)
# Output: 3
Som sett 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 hälften 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ämställdhetsjämförelse: Avrundningstal 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. Så försök att undvika likhetskontroller mellan flyttal och avrundade flyttal. Om jämförelsen är nödvändig, inför sedan en toleransgräns.
- Förlust av information: Du kanske vill att vissa data som sensoravläsningar vid olika tidsstämplar fångas med hög precision. Att avrunda sådana data till färre decimaler leder till förlust av information och felaktig analys.
- Avrundning av mellanresultat: Du har ofta flera steg som en del av beräkningen. Använd konsekvent precision i alla steg. Undvik också avrundning vid mellansteg för att förhindra att avrundningsfelen blir sammansatta.
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 flytande och decimaldatatyper beroende på applikation. Om du behöver utföra flyttalsaritmetik med hög precision, välj decimaldatatyp.
- Använd konsekventa precisionsnivåer: Ställ in konsekventa precisionsnivåer för decimaltal genom hela programmet för att undvika oväntade avrundningsfel.
- Dokumentavrundningstekniker: I verkliga tillämpningar som involverar data som valuta- och sensoravläsningar är det viktigt att ha en konsekvent och dokumenterad avrundningsteknik på plats.
Avslutar
Låt oss avsluta handledningen med en snabb genomgång av vad vi har lärt oss:
- Du kan använda den inbyggda round()-funktionen med denna syntax round(num, ndigits). När du använder funktionen round() bör du vara medveten om bankens avrundningsstrategi. Så den avrundar tal exakt mellan två heltal till närmaste jämna heltal.
- Du kan använda funktionerna ceil() och floor() från matematikmodulen 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 den precision och avrundningsstrategi som krävs.
- Du bör vara medveten om vanliga fallgropar med avrundning av siffror i Python. Dessa inkluderar förlust av information från avrundning, avrundning av resultat i mellansteg och användning av olika precision i olika delar av koden.
- Bästa metoder inkluderar att välja rätt datatyp beroende på applikationen och att dokumentera konsekventa precisionsnivåer.
Lär dig sedan hur du utför våningsindelning i Python.
var den här artikeln hjälpsam?
Tack för din feedback!