Python round()-funktion med EXEMPEL

Vad är round()-funktionen i Python?

Python round() är en inbyggd funktion som är tillgänglig med PythonDen returnerar ett flyttal som avrundas till decimaler som anges som indata.

Om de decimaler som ska avrundas inte anges, betraktas det som 0, och det avrundas till närmaste heltal.

syntax

round(float_num, num_of_decimals)

Driftparametrar

• flyttalnummer: Flyttalsvärdet som ska avrundas.
• antal_decimaler: (valfritt) Antalet decimaler som ska beaktas vid avrundning. Det är valfritt, och om inget anges är standardvärdet 0, och avrundningen görs till närmaste heltal.

BESKRIVNING

Metoden round() tar två argument:

• det tal som ska avrundas, och
• de decimaler den bör beakta vid avrundning.

Det andra argumentet är valfritt och har som standard 0 när det inte anges, och i sådant fall avrundas det till närmaste heltal, och returtypen blir också ett heltal.

När decimalerna, dvs det andra argumentet, finns, avrundas det till antalet angivna platser. Returtypen kommer att vara en float.

Om talet efter decimalen är:

• >= 5, då läggs + 1 till det slutliga värdet.
• < 5, så returneras det slutliga värdet som det är, upp till de angivna decimalerna.

Returvärde

Den returnerar ett heltal om num_of_decimals inte anges och ett flyttal om num_of_decimals anges. Observera att värdet avrundas till +1 om värdet efter decimaltecknet är >= 5, annars returnerar den värdet som det är, upp till de angivna decimalerna.

Hur stor påverkan kan avrundning ha? (Avrundning vs trunkering)

Det bästa exemplet för att visa avrundningens inverkan är börsmarknaden. Förr i tiden, dvs. år 1982, Vancouver Stock Exchange (VSE) används för att avkorta aktievärdena till tre decimaler vid varje handel.

Det gjordes nästan 3000 gånger varje dag. De ackumulerade avkortningarna ledde till en förlust på cirka 25 poäng per månad.

Ett exempel på trunkering av värdena kontra avrundning visas nedan.

Betrakta flyttalstalen som genereras nedan som standardvärden. Just nu genererar jag dem för ett intervall på 1 000 000 sekunder mellan 0.01 och 0.05.

Exempel:

arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]

För att visa effekten av avrundning har jag skrivit en liten kodsnutt där man först använder siffrorna upp till endast 3 decimaler, dvs. avkortar talet efter 3 decimaler.

Jag har det ursprungliga totalvärdet, summan som kommer från de avkortade värdena och skillnaden mellan det ursprungliga och det avkortade värdet.

På samma uppsättning tal har jag använt round()-metoden upp till 3 decimaler och beräknat summan och skillnaden mellan det ursprungliga värdet och det avrundade värdet.

Här är exemplet och utdata.

Exempelvis 1

import random

def truncate(num):
    return int(num * 1000) / 1000

arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]
sum_num = 0
sum_truncate = 0
for i in arr:
    sum_num = sum_num + i  
    sum_truncate = truncate(sum_truncate + i)
  
print("Testing by using truncating upto 3 decimal places")
print("The original sum is = ", sum_num)
print("The total using truncate = ", sum_truncate)
print("The difference from original - truncate = ", sum_num - sum_truncate)

print("\n\n")
print("Testing by using round() upto 3 decimal places")
sum_num1 = 0
sum_truncate1 = 0
for i in arr:
    sum_num1 = sum_num1 + i  
    sum_truncate1 = round(sum_truncate1 + i, 3)

print("The original sum is =", sum_num1)
print("The total using round = ", sum_truncate1)
print("The difference from original - round =", sum_num1 - sum_truncate1)

Produktion:

Testing by using truncating upto 3 decimal places
The original sum is =  29985.958619386867
The total using truncate =  29486.057
The difference from original - truncate =  499.9016193868665

Testing by using round() up to 3 decimal places
The original sum is = 29985.958619386867
The total using round =  29985.912
The difference from original - round = 0.04661938686695066

Skillnaden mellan det ursprungliga och det avkortade värdet är 499.9016193868665, och från round() är det 0.04661938686695066.

Skillnaden verkar vara mycket stor, och exemplet visar hur round()-metoden hjälper till att beräkna med nära noggrannhet.

Exempel: Rounding Float Numbers

I det här programmet ska vi se hur avrundning fungerar på flytande tal.

# testing round()

float_num1 = 10.60 # here the value will be rounded to 11 as after the decimal point the number is 6 that is >5

float_num2 = 10.40 # here the value will be rounded to 10 as after the decimal point the number is 4 that is <=5

float_num3 = 10.3456 # here the value will be 10.35 as after the 2 decimal points the value >=5

float_num4 = 10.3445 #here the value will be 10.34 as after the 2 decimal points the value is <5

print("The rounded value without num_of_decimals is :", round(float_num1))
print("The rounded value without num_of_decimals is :", round(float_num2))
print("The rounded value with num_of_decimals as 2 is :", round(float_num3, 2))
print("The rounded value with num_of_decimals as 2 is :", round(float_num4, 2))

Produktion:

The rounded value without num_of_decimals is : 11
The rounded value without num_of_decimals is : 10
The rounded value with num_of_decimals as 2 is : 10.35
The rounded value with num_of_decimals as 2 is : 10.34

Exempel: Avrundning av heltalsvärden

Om du råkar använda round() på ett heltalsvärde, kommer det bara att returnera dig numret utan några ändringar.

# testing round() on a integer

num = 15

print("The output is", round(num))

Produktion:

The output is 15

Exempel: Avrundning till negativ Numbers

Låt oss se några exempel på hur avrundning fungerar på negativa tal.

# testing round()

num = -2.8
num1 = -1.5
print("The value after rounding is", round(num))
print("The value after rounding is", round(num1))

Produktion:

C:\pythontest>python testround.py
The value after rounding is -3
The value after rounding is -2

Exempel: Runda NumPy-matriser

Hur avrundar man NumPy arrayer i Python?

För att lösa detta kan vi använda NumPy-modulen och använda metoden numpy.round() eller numpy.around(), som visas i exemplet nedan.

Använder numpy.round()

# testing round()
import numpy as np

arr = [-0.341111, 1.455098989, 4.232323, -0.3432326, 7.626632, 5.122323]

arr1 = np.round(arr, 2)

print(arr1)

Produktion:

C:\pythontest>python testround.py
[-0.34  1.46  4.23 -0.34  7.63  5.12]

Vi kan också använda numpy.around(), vilket ger samma resultat som numpy.round() som visas ovan.

Exempel: Decimalmodul

Förutom round()-funktionen, Python har en decimalmodul som hjälper till att hantera decimaltal mer exakt.

Decimalmodulen har avrundningstyper, som visas nedan:

• RUNDT_TAK: den kommer att runda mot oändligheten.
• AVRUNDA_NER: den kommer att avrunda värdet mot noll.
• ROUND_FLOOR: den kommer att runda mot -oändligheten.
• RUNDA_HALV_NER: Den avrundas till närmaste värde mot noll.
• ROUND_HALV_JÄMN: den avrundas till närmaste värde och går vidare till närmaste jämna heltal.
• AVRUNDA_HALV_UPPÅ: Den avrundas till närmaste värde som går bort från noll.
• AVRUNDA UPPÅT: Den kommer att avrunda där värdet går bort från noll.

I decimal hjälper quantize()-metoden att avrunda till ett fast antal decimaler, och du kan ange vilken avrundning som ska användas, som visas i exemplet nedan.

Exempel: Använder round() och decimalmetoder

import  decimal
round_num = 15.456

final_val = round(round_num, 2)

#Using decimal module
final_val1 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_CEILING)
final_val2 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_DOWN)
final_val3 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_FLOOR)
final_val4 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_DOWN)
final_val5 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_EVEN)
final_val6 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_UP)
final_val7 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_UP)

print("Using round()", final_val)
print("Using Decimal - ROUND_CEILING ",final_val1)
print("Using Decimal - ROUND_DOWN ",final_val2)
print("Using Decimal - ROUND_FLOOR ",final_val3)
print("Using Decimal - ROUND_HALF_DOWN ",final_val4)
print("Using Decimal - ROUND_HALF_EVEN ",final_val5)
print("Using Decimal - ROUND_HALF_UP ",final_val6)
print("Using Decimal - ROUND_UP ",final_val7)

Produktion:

Using round() 15.46
Using Decimal - ROUND_CEILING  15.46
Using Decimal - ROUND_DOWN  15.45
Using Decimal - ROUND_FLOOR  15.45
Using Decimal - ROUND_HALF_DOWN  15.46
Using Decimal - ROUND_HALF_EVEN  15.46
Using Decimal - ROUND_HALF_UP  15.46
Using Decimal - ROUND_UP  15.46

Vanliga frågor