Python round()-funktion med EKSEMPLER

Hvad er round()-funktionen i Python?

Python round() er en indbygget funktion, der er tilgængelig med PythonDen vil returnere dig et flydende tal, der afrundes til decimaler, der er angivet som input.

Hvis de decimaler, der skal afrundes, ikke er angivet, betragtes det som 0, og det vil afrunde til nærmeste heltal.

Syntaks

round(float_num, num_of_decimals)

Driftsparametre

• flydende_nummer: Det flydende tal, der skal afrundes.
• antal_decimaler: (valgfrit) Antallet af decimaler, der skal tages i betragtning ved afrunding. Det er valgfrit, og hvis ikke angivet, er standardværdien 0, og afrundingen udføres til nærmeste heltal.

Beskrivelse

Metoden round() tager to argumenter:

• det tal, der skal afrundes, og
• de decimaler, den skal tage i betragtning ved afrunding.

Det andet argument er valgfrit og har som standard en værdi på 0, når det ikke er angivet. I så fald afrunder det til nærmeste heltal, og returtypen vil også være et heltal.

Når decimalerne, dvs. det andet argument, er til stede, afrundes det til det angivne antal pladser. Returtypen vil være en flyder.

Hvis tallet efter decimalen er:

• >= 5, så lægges + 1 til den endelige værdi.
• < 5, så returneres den endelige værdi som den er, op til de nævnte decimaler.

Returværdi

Den returnerer en heltalsværdi, hvis num_of_decimals ikke er angivet, og en flydende værdi, hvis num_of_decimals er angivet. Bemærk venligst, at værdien afrundes til +1, hvis værdien efter decimaltegnet er >= 5, ellers returneres værdien, som den er, op til de nævnte decimaler.

Hvor stor indflydelse kan afrunding have? (Afrunding vs trunkering)

Det bedste eksempel på afrundingens indflydelse er børsmarkedet. Tidligere, dvs. i år 1982, Vancouver børs (VSE) bruges til at afkorte aktieværdierne til tre decimaler ved hver handel.

Det blev gjort næsten 3000 gange hver dag. De akkumulerede afkortninger førte til et tab på omkring 25 point om måneden.

Et eksempel på trunkering af værdierne i forhold til afrunding er vist nedenfor.

Betragt de flydende kommatal, der genereres nedenfor, som standardværdier. Lige nu genererer jeg dem for et interval på 1,000,000 sekunder mellem 0.01 og 0.05.

eksempler:

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

For at vise effekten af ​​afrunding har jeg skrevet et lille stykke kode, hvor man i starten bruger tallene op til kun 3 decimaler, dvs. afkorter tallet efter 3 decimaler.

Jeg har den oprindelige samlede værdi, summen fra de afkortede værdier, og forskellen mellem den oprindelige og den afkortede værdi.

På det samme sæt tal har jeg brugt round()-metoden op til 3 decimaler og beregnet summen og forskellen mellem den oprindelige værdi og den afrundede værdi.

Her er eksemplet og outputtet.

Eksempel 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)

Output:

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

Forskellen mellem den oprindelige og den afkortede værdi er 499.9016193868665, og fra round() er den 0.04661938686695066.

Forskellen synes at være meget stor, og eksemplet viser, hvordan round()-metoden hjælper med at beregne tæt på nøjagtighed.

Eksempel: Rounding Float Numbers

I dette program vil vi se, hvordan afrunding fungerer på flydende 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))

Output:

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

Eksempel: Afrunding af heltalsværdier

Hvis du tilfældigvis bruger round() på en heltalsværdi, vil det bare returnere dig tallet uden ændringer.

# testing round() on a integer

num = 15

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

Output:

The output is 15

Eksempel: Afrunding på negativ Numbers

Lad os se et par eksempler på, hvordan afrunding fungerer på negative 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))

Output:

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

Eksempel: Runde NumPy-arrays

Hvordan afrunder man NumPy arrays i Python?

For at løse dette kan vi bruge NumPy-modulet og bruge metoden numpy.round() eller numpy.around(), som vist i eksemplet nedenfor.

Brug af 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)

Output:

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

Vi kan også bruge numpy.around(), som giver dig det samme resultat som numpy.round() vist ovenfor.

Eksempel: Decimalmodul

Udover round()-funktionen, Python har et decimalmodul, der hjælper med at håndtere decimaltal mere præcist.

Decimalmodulet leveres med afrundingstyper, som vist nedenfor:

• RUNDT_LOFT: den vil runde mod Uendeligheden.
• ROUND_DOWN: den vil runde værdien af ​​mod nul.
• RUNDT_GULV: den vil runde mod -uendeligheden.
• RUND_HALV_NED: Den vil runde af til den nærmeste værdi mod nul.
• RUND_HALV_LIGE: Den afrunder til nærmeste værdi og går videre til nærmeste lige heltal.
• RUND_HALV_OP: Den afrunder til den nærmeste værdi væk fra nul.
• RUND OP: Den vil runde af, hvor værdien går væk fra nul.

I decimal hjælper quantize()-metoden med at afrunde til et fast antal decimaler, og du kan angive den afrunding, der skal bruges, som vist i eksemplet nedenfor.

Eksempel: Brug af round() og 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)

Output:

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

Ofte Stillede Spørgsmål