En beräkning ger 8.9, men funktionen kräver ett heltal. I Python kan du skriva int(8.9), men resultatet blir avhugget mot noll, vilket får en oväntad följd när talet är negativt.
Välj konvertering efter hur talet ska avrundas
int(x)tar bort decimaldelen och går mot noll.round(x)avrundar till närmaste heltal, med en särskild regel vid exakta halvor.math.floor(x)går nedåt mot minus oändligheten.math.ceil(x)går uppåt mot plus oändligheten.- Pengar och decimaler kan kräva
Decimali stället för binära flyttal.
int() kapar decimalerna mot noll
För ett positivt tal ser int() ofta ut som en vanlig avrundning nedåt: int(8.9) ger 8. Men funktionen avrundar inte till närmaste heltal. Den tar bort allt efter decimaltecknet.
Det syns tydligast med negativa tal. int(-8.9) blir -8, eftersom resultatet går mot noll, inte mot ett lägre värde. Jag tycker att just det här minustecknet är den detalj som lättast smyger in ett fel i beräkningar.
int(8.9) # 8
int(-8.9) # -8
Om du till exempel räknar ut en förändring på -8.9 och vill få det närmaste heltalet nedanför talet, räcker int() alltså inte. Då behöver du välja en annan regel.
Negativa tal visar skillnaden mellan truncering och golv
Behöver du alltid avrunda nedåt, använd math.floor(). Till skillnad från int() går den mot minus oändligheten, så math.floor(-8.9) ger -9. För positiva värden blir både int(8.9) och math.floor(8.9) lika med 8, vilket kan dölja skillnaden i ett snabbt test.
Regeln är enkel: välj int() för kapning mot noll, floor() för heltalet under värdet och ceil() för heltalet ovanför. Den sista funktionen går uppåt även för negativa tal.
| Situation | Resultat | Vad du väljer |
|---|---|---|
| Du vill ta bort decimaldelen | int(-8.9) ger -8 | int(x) |
| Du behöver heltalet under talet | math.floor(-8.9) ger -9 | math.floor(x) |
| Du behöver heltalet över talet | math.ceil(-8.9) ger -8 | math.ceil(x) |
| Du vill avrunda till närmaste heltal | round(8.9) ger 9 | round(x) |
Alla fyra alternativen kan ge ett heltal, men de betyder olika saker. I en paginering eller ett index kan kapning vara rätt; för en gräns som aldrig får understiga ett beräknat värde kan golv eller tak passa bättre.
round() rundar halvor till jämna tal
När resultatet ska ligga närmast det ursprungliga värdet använder du round(). En detalj som ofta överraskar är att Python vid exakta halvor rundar till närmaste jämna heltal: round(2.5) blir 2, medan round(3.5) blir 4.
Det här är en annan regel än att alltid avrunda halvor bort från noll. Om en rapport eller affärsregel kräver en specifik avrundningsmetod bör du uttrycka den regeln i koden i stället för att anta att round() följer den.
round(2.5) # 2
round(3.5) # 4
round(-2.5) # -2
Det kan också spela roll om du först rundar ett flyttal och sedan konverterar det. round(8.9) ger redan ett heltal; int(round(8.9)) ger samma numeriska resultat men gör två steg utan att ändra avrundningsregeln.
Binära flyttal kan ge en oväntad heltalsgräns
Värden som 0.1 går inte att representera exakt som binära flyttal. Därför kan en beräkning som verkar landa precis på en heltalsgräns i själva verket hamna strax under den, och då kapar int() ned resultatet.
Exempelvis kan ett värde som visas som 2.9999999999999996 bli 2 med int(), trots att det kan ha varit tänkt som ungefär 3. Python-dokumentationen om flyttalsaritmetik förklarar varför decimalbråk ofta bara kan lagras som approximationer.
Om indata kommer från beräkningar och du vill kontrollera att den ligger nära ett heltal kan du först testa toleransen, i stället för att blint lägga till en liten konstant:
import math
x = 2.9999999999999996
if math.isclose(x, round(x), abs_tol=1e-12):
result = round(x)
En sådan kontroll passar bara om värdet enligt programmets logik faktiskt ska vara ett heltal. En tolerans får inte användas för att dölja en avsiktlig decimaldel; vid pengar är det ofta bättre att undvika float från början.
För decimaler och pengar är Decimal ofta säkrare
Om talet kommer från användarinmatning eller representerar ett pris kan Decimal ge tydligare kontroll över decimalerna än float. Skapa värdet från en textsträng, exempelvis Decimal("2.675"), i stället för att först skapa ett flyttal. Annars följer den binära approximationen med in i decimalberäkningen.
Dokumentationen för Pythons Decimal-modul beskriver stöd för decimalaritmetik och olika avrundningslägen. Valet av avrundning behöver fortfarande följa programmets krav, exempelvis hur en faktura eller ett pris ska presenteras.
from decimal import Decimal, ROUND_HALF_UP
price = Decimal("2.675")
rounded = price.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
För ett vanligt beräknat värde är int() oftast det enklaste valet när kapning mot noll är avsikten. Om du vill avrunda, välj round() medvetet; om decimalerna måste vara exakta, välj Decimal. Jag skulle välja metoden utifrån vad resultatet betyder, inte utifrån vilken funktion som råkar vara kortast.