Python round() funktion med EKSEMPLER

Af: Logan Young Logan Young
Hours Opdateret

Rund()

Round() er en indbygget funktion tilgængelig med python. Det vil returnere dig et flydende tal, der vil blive afrundet til decimalerne, som 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

  • float_num: det flydende tal, der skal afrundes.
  • antal_decimaler: (valgfrit) Antallet af decimaler, der skal tages i betragtning ved afrunding. Den er valgfri, og hvis den ikke er angivet, er den som standard 0, og afrundingen udføres til nærmeste heltal.

Beskrivelse

round() metoden tager to argumenter

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

Det andet argument er valgfrit og er standard til 0, når det ikke er angivet, og i så fald vil det runde af 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 angivet

  • >=5 end + 1 vil blive lagt til den endelige værdi
  • <5 end den endelige værdi vil returnere, da den er op til de nævnte decimaler.

Returværdi

Det vil returnere en heltalsværdi, hvis num_of_decimals ikke er givet, og en flydende værdi, hvis num_of_decimals er givet. Bemærk venligst, at værdien vil blive afrundet til +1, hvis værdien efter decimalkommaet er >=5, ellers returnerer den værdien, da den er op til de nævnte decimaler.

RELATEREDE ARTIKLER

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

Det bedste eksempel på at vise effekten af ​​afrunding er for børsmarkedet. I fortiden, dvs. i år 1982 Vancouver børs (VSE): bruges til at afkorte aktieværdierne til tre decimaler på hver handel.

Det blev gjort næsten 3000 gange hver dag. De akkumulerede trunkeringer fører til et tab på omkring 25 point pr. måned.

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

Betragt de floating-point-tal, der genereres nedenfor, som aktieværdier. Lige nu genererer jeg det til en række af

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 virkningen af ​​afrunding har jeg skrevet et lille stykke kode, hvor du først skal bruge tallene op til kun 3 decimaler, dvs. at afkorte tallet efter 3 decimaler.

Jeg har den oprindelige samlede værdi, totalen kommer fra trunkerede værdier og forskellen mellem original og trunkeret 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 original og efter trunkering er 499.9016193868665, og fra rund er den 0.04661938686695066

Forskellen ser ud til at være meget stor, og eksemplet viser, hvordan man round() metode hjælper med at beregne tæt på nøjagtighed.

Eksempel: Rounding Float Numbers

I dette program vil vi se, hvordan ord afrundes 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 nogle få eksempler på, hvordan afrunding virker 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: Round Numpy Arrays

Hvordan man runder numpy arrays i python?

For at løse dette kan vi gøre brug af numpy-modulet og bruge numpy.round()- eller numpy.around()-metoden, 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 vist i eksemplet nedenfor.

Eksempel: Decimalmodul

Ud over funktionen round() har python et decimalmodul, der hjælper med at håndtere decimaltal mere præcist.

Decimalmodulet leveres med afrundingstyper, som vist nedenfor:

  • ROUND_CEILING: det vil runde mod Uendelighed,
  • ROUND_DOWN: det vil runde værdien mod nul,
  • ROUND_FLOOR: den vil runde mod -Uendelig,
  • ROUND_HALF_DOWN: den vil afrunde til nærmeste værdi, der går mod nul,
  • ROUND_HALF_EVEN: det vil afrunde til nærmeste med værdi, der går til nærmeste lige heltal,
  • ROUND_HALF_UP: den afrundes til nærmeste med værdi, der går væk fra nul
  • ROUND_UP: det vil runde, hvor værdien vil gå 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

Resumé

  • Round(float_num, Num_of_decimals) er en indbygget funktion tilgængelig med python. Det vil returnere dig det flydende tal, der vil blive afrundet til decimalerne, som er angivet som input.
  • float_num: det flydende tal, der skal afrundes.
  • Antal_decimaler: Det er antallet af decimaler, der skal tages i betragtning ved afrunding.
  • Det vil returnere en heltalsværdi, hvis num_of_decimals ikke er givet, og en flydende værdi, hvis num_of_decimals er givet.

Opsummer dette indlæg med: