Python round() functie met VOORBEELDEN

Ronde()

Round() is een ingebouwde functie die beschikbaar is in Python. Het geeft u een float-getal terug dat wordt afgerond op de decimalen die als invoer worden opgegeven.

Als het aantal decimalen dat afgerond moet worden niet is opgegeven, wordt dit als 0 beschouwd en wordt er afgerond op het dichtstbijzijnde gehele getal.

Syntaxis

round(float_num, num_of_decimals)

parameters

• float_num: het floatgetal dat moet worden afgerond.
• num_of_decimals: (optioneel) Het aantal decimalen dat in aanmerking moet worden genomen bij het afronden. Het is optioneel en als het niet wordt opgegeven, is de standaardwaarde 0 en wordt er afgerond op het dichtstbijzijnde gehele getal.

Beschrijving

De round() methode heeft twee argumenten nodig

• het getal dat moet worden afgerond en
• de decimalen waarmee rekening moet worden gehouden bij het afronden.

Het tweede argument is optioneel en is standaard 0 als het niet is opgegeven. In dat geval wordt afgerond naar het dichtstbijzijnde gehele getal en is het retourtype ook een geheel getal.

Als de cijfers achter de komma, dat wil zeggen het tweede argument, aanwezig zijn, wordt afgerond naar het opgegeven aantal cijfers. Het retourtype is een float.

Als het getal achter de komma wordt opgegeven

• >=5 dan + 1 wordt opgeteld bij de uiteindelijke waarde
• <5 dan zal de uiteindelijke waarde terugkeren, aangezien deze tot aan de genoemde decimalen reikt.

Winstwaarde

Het retourneert een geheel getal als het aantal_decimalen niet is opgegeven, en een float-waarde als het aantal_decimalen is opgegeven. Houd er rekening mee dat de waarde wordt afgerond op +1 als de waarde na de komma >=5 is, anders wordt de waarde geretourneerd tot op de genoemde decimalen.

Hoeveel impact kan afronding hebben? (Afronding versus afknotting)

Het beste voorbeeld om de impact van afronding aan te tonen is voor de beursmarkt. In het verleden, dat wil zeggen in het jaar 1982, werd de Beurs van Vancouver (VSE): wordt gebruikt om de aandelenwaarden bij elke transactie af te korten tot drie decimalen.

Het werd bijna 3000 keer per dag gedaan. De opgetelde afkortingen leiden tot een verlies van ongeveer 25 punten per maand.

Hieronder ziet u een voorbeeld van het afkappen van de waarden versus het afronden.

Beschouw de drijvende-kommagetallen die hieronder worden gegenereerd als aandelenwaarden. Op dit moment genereer ik ze voor een reeks

1,000,000 seconden tussen 0.01 en 0.05.

Voorbeelden:

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

Om het effect van afronding te laten zien, heb ik een klein stukje code geschreven. Eerst moet u getallen tot 3 decimalen gebruiken, dat wil zeggen dat u het getal na 3 decimalen moet afkappen.

Ik heb de oorspronkelijke totale waarde, het totaal afkomstig van ingekorte waarden en het verschil tussen originele en ingekorte waarde.

Voor dezelfde reeks getallen heb ik de round()-methode tot 3 decimalen gebruikt en de som en het verschil tussen de oorspronkelijke waarde en de afgeronde waarde berekend.

Hier zijn het voorbeeld en de uitvoer
Voorbeeld 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

Het verschil tussen origineel en na afkappen is 499.9016193868665, en vanaf rond is het 0.04661938686695066

Het verschil lijkt erg groot, en het voorbeeld laat zien hoe de round()-methode helpt bij het berekenen van bijna nauwkeurigheid.

Voorbeeld: Afrondingsvlotter Numbers

In dit programma zullen we zien hoe we woorden op drijvende getallen kunnen afronden

# 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

Voorbeeld: afgeronde gehele waarden

Als u round() gebruikt voor een geheel getal, krijgt u gewoon het getal terug zonder enige wijzigingen.

# testing round() on a integer

num = 15

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

Output:

The output is 15

Voorbeeld: Afronding op negatief Numbers

Laten we eens een paar voorbeelden bekijken van hoe afronding werkt op negatieve getallen

# 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

Voorbeeld: ronde Numpy-arrays

Numpy afronden arrays in python?

Om dit op te lossen, kunnen we gebruik maken van de numpy-module en de numpy.round() of numpy.around()-methode gebruiken, zoals weergegeven in het onderstaande voorbeeld.

Numpy.round() gebruiken

# 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]

We kunnen ook numpy.around() gebruiken, wat hetzelfde resultaat oplevert als in het onderstaande voorbeeld.

Voorbeeld: decimale module

Naast de round()-functie beschikt Python over een decimale module waarmee decimale getallen nauwkeuriger kunnen worden verwerkt.

De Decimal-module wordt geleverd met afrondingstypen, zoals hieronder weergegeven:

• ROUND_CEILING: het zal afronden naar het oneindige,
• ROUND_DOWN: de waarde wordt afgerond naar nul,
• ROUND_FLOOR: het wordt afgerond naar -Infinity,
• ROUND_HALF_DOWN: rondt af naar de dichtstbijzijnde waarde, richting nul,
• ROUND_HALF_EVEN: rondt af naar de dichtstbijzijnde waarde, waarbij de waarde naar het dichtstbijzijnde even gehele getal gaat,
• ROUND_HALF_UP: dit rondt af naar de dichtstbijzijnde waarde, waarbij de waarde verder van nul af ligt
• ROUND_UP: er wordt afgerond waar de waarde van nul afgaat.

In decimalen helpt de methode quantize() om af te ronden op een vast aantal decimalen, en u kunt de te gebruiken afronding specificeren, zoals weergegeven in het onderstaande voorbeeld.
Voorbeeld:
Round() en decimale methoden gebruiken

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

Samenvatting

• Round(float_num, Num_of_decimals) is een ingebouwde functie die beschikbaar is in Python. Het geeft u het float-nummer terug dat wordt afgerond op de decimalen die als invoer worden opgegeven.
• float_num: het floatgetal dat moet worden afgerond.
• Aantal_decimalen: Dit is het aantal decimalen waarmee rekening moet worden gehouden bij het afronden.
• Het retourneert een geheel getal als het aantal_decimalen niet is opgegeven, en een float-waarde als het aantal_decimalen is opgegeven.