Python round() funktion med EXEMPEL

By: Logan Young Logan Young
Hours Uppdaterad

Runda()

Round() är en inbyggd funktion tillgänglig med python. Det kommer att returnera dig ett flyttal som kommer att avrundas till de decimaler som anges som inmatning.

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

  • float_num: floatnumret som ska avrundas.
  • num_of_decimals: (valfritt) Antalet decimaler som ska beaktas vid avrundning. Det är valfritt, och om det inte anges är det standard till 0, och avrundningen görs till närmaste heltal.

BESKRIVNING

Metoden round() tar två argument

  • talet som ska avrundas och
  • de decimaler den bör beakta vid avrundning.

Det andra argumentet är valfritt och är standard till 0 när det inte anges, och i sådana fall avrundas det till närmaste heltal, och returtypen kommer också att vara 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 angivna decimalen

  • >=5 än + 1 kommer att läggas till det slutliga värdet
  • <5 än det slutliga värdet kommer att returneras eftersom det är upp till de decimaler som nämns.

Returvärde

Den returnerar ett heltalsvärde om antalet_decimaler inte anges och ett flytvärde om antalet_decimaler anges. Observera att värdet avrundas till +1 om värdet efter decimalkomma är >=5, annars returnerar det värdet eftersom det är upp till de angivna decimalerna.

RELATERADE ARTIKLAR

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

Det bästa exemplet för att visa effekten av avrundning är för börsmarknaden. Förr i tiden, dvs. år 1982 Vancouver Stock Exchange (VSE): används för att trunkera aktievärdena till tre decimaler på varje handel.

Det gjordes nästan 3000 gånger varje dag. De ackumulerade trunkeringarna leder 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 aktievärden. Just nu genererar jag det för en rad

1,000,000 0.01 0.05 sekunder mellan XNUMX och XNUMX.

Exempel:

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

För att visa effekten av avrundning har jag skrivit en liten bit kod där du först behöver använda siffrorna upp till endast 3 decimaler, dvs trunkera talet efter 3 decimaler.

Jag har det ursprungliga totala värdet, summan som kommer från trunkerade värden och skillnaden mellan original och trunkerat värde.

På samma uppsättning siffror har jag använt metoden round() 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 utgången
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 original och efter trunkering är 499.9016193868665, och från runda är den 0.04661938686695066

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

Exempel: Rounding Float Numbers

I det här programmet kommer vi att se hur ord avrundas 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: Round Numpy Arrays

Hur man rundar numpy arrayer i python?

För att lösa detta kan vi använda numpy-modulen och använda numpy.round()- eller numpy.around()-metoden, 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 dig samma resultat som visas i exemplet nedan.

Exempel: Decimalmodul

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

Decimalmodulen kommer med avrundningstyper, som visas nedan:

  • ROUND_CEILING: den kommer att runda mot oändligheten,
  • ROUND_DOWN: det kommer att avrunda värdet mot noll,
  • ROUND_FLOOR: den kommer att runda mot -Oändlighet,
  • ROUND_HALF_DOWN: den avrundas till närmaste värde mot noll,
  • ROUND_HALF_EVEN: det avrundas till närmaste med värdet som går till närmaste jämna heltal,
  • ROUND_HALF_UP: den avrundas till närmaste med värdet bort från noll
  • ROUND_UP: den avrundas där värdet kommer att gå 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.
Exempelvis:
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

Sammanfattning

  • Round(float_num, Antal_decimaler) är en inbyggd funktion tillgänglig med python. Det kommer att returnera flyttalet som kommer att avrundas till decimalerna som anges som inmatning.
  • float_num: floatnumret som ska avrundas.
  • Antal_decimaler: Det är antalet decimaler som ska beaktas vid avrundning.
  • Den returnerar ett heltalsvärde om antalet_decimaler inte anges och ett flytvärde om antalet_decimaler anges.

Sammanfatta detta inlägg med: