Python round() functie met VOORBEELDEN

Ronde()

Round() is een ingebouwde functie die beschikbaar is bij python. Het geeft je een float-getal dat wordt afgerond op de decimalen die als invoer zijn opgegeven.

Als de decimalen die moeten worden afgerond niet zijn opgegeven, wordt dit beschouwd als 0 en wordt het afgerond op het dichtstbijzijnde gehele getal.

In deze Python-zelfstudie leer je:

• Ronde()
• Syntaxis:
• Hoeveel impact kan afronding hebben? (Afronding versus truncatie)
• Voorbeeld:Floating Numbers afronden
• Voorbeeld:gehele getallen afronden
• Voorbeeld:afronding op negatieve getallen
• Voorbeeld:ronde numpy-arrays
• Voorbeeld:decimale module

Syntaxis:

round(float_num, num_of_decimals)

Parameters

• float_num:het getal dat moet worden afgerond.
• num_of_decimals:(optioneel) Het aantal decimalen waarmee rekening moet worden gehouden bij het afronden. Het is optioneel en als het niet is opgegeven, wordt het standaard ingesteld op 0 en wordt het afgerond op het dichtstbijzijnde gehele getal.

Beschrijving

De methode round() heeft twee argumenten

• 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, en in dat geval wordt het afgerond op het dichtstbijzijnde gehele getal en is het retourtype ook een geheel getal.

Wanneer de decimalen, d.w.z. het tweede argument, aanwezig is, wordt afgerond op het opgegeven aantal plaatsen. Het retourtype is een float.

Als het getal achter de komma is opgegeven

• >=5 dan + 1 wordt toegevoegd aan de uiteindelijke waarde
• <5 dan wordt de uiteindelijke waarde geretourneerd zoals deze is tot op de genoemde decimalen.

Retourwaarde

Het zal een geheel getal retourneren 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 zoals deze is tot op de genoemde decimalen.

Hoeveel impact kan afronding hebben? (Afronding versus truncatie)

Het beste voorbeeld om de impact van afronding te laten zien is voor de beurs. In het verleden, d.w.z. in het jaar 1982, werd de Vancouver Stock Exchange (VSE):gebruikt om de aandelenwaarden bij elke transactie af te kappen tot drie decimalen.

Het werd bijna 3000 keer per dag gedaan. De geaccumuleerde inkortingen 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 getallen met drijvende komma die hieronder worden gegenereerd als aandelenwaarden. Op dit moment genereer ik het voor een reeks van

1.000.000 seconden tussen 0,01 en 0,05.

Voorbeelden:

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

Om de impact van afronding te laten zien, heb ik een klein stukje code geschreven waarin je in eerste instantie de getallen tot op 3 decimalen moet gebruiken, d.w.z. het getal afkappen na 3 decimalen.

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

Op dezelfde reeks getallen heb ik de methode round() 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)

Uitvoer:

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 van rond is het 0.04661938686695066

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

Voorbeeld:Floating Numbers afronden

In dit programma zullen we zien hoe woorden op zwevende getallen worden afgerond

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

Uitgang:

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:gehele getallen afronden

Als je round() op een geheel getal gebruikt, zal het je gewoon het getal teruggeven zonder enige wijzigingen.

# testing round() on a integer

num = 15

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

Uitgang:

The output is 15

Voorbeeld:afronding op negatieve getallen

Laten we 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))

Uitgang:

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

Voorbeeld:ronde numpy-arrays

Hoe numpy-arrays in python af te ronden?

Om dit op te lossen, kunnen we gebruik maken van de numpy module en de numpy.round() of numpy.around() methode gebruiken, zoals getoond 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)

Uitgang:

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 geeft als in het onderstaande voorbeeld.

Voorbeeld:decimale module

Naast de functie round() heeft python een decimale module die helpt bij het nauwkeuriger omgaan met decimale getallen.

De decimale module wordt geleverd met afrondingstypen, zoals hieronder weergegeven:

• ROUND_CEILING:het zal afronden naar Infinity,
• ROUND_DOWN:het zal de waarde naar nul afronden,
• ROUND_FLOOR:het zal afronden naar -Oneindig,
• ROUND_HALF_DOWN:het wordt afgerond naar de dichtstbijzijnde waarde richting nul,
• ROUND_HALF_EVEN:het wordt afgerond naar het dichtstbijzijnde met een waarde die gaat naar het dichtstbijzijnde even geheel getal,
• ROUND_HALF_UP:het wordt afgerond naar het dichtstbijzijnde met een waarde die vanaf nul gaat
• ROUND_UP:het rondt af waar de waarde vanaf nul gaat.

In decimalen helpt de methode quantize() om af te ronden op een vast aantal decimalen, en u kunt de te gebruiken afronding specificeren, zoals 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)

Uitgang:

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 bij python. Het zal u het float-getal teruggeven dat zal worden afgerond op de decimalen die als invoer worden gegeven.
• float_num:het getal dat moet worden afgerond.
• Aantal_decimalen:dit is het aantal decimalen waarmee rekening moet worden gehouden bij het afronden.
• Het geeft een geheel getal terug als het aantal_decimalen niet is opgegeven en een float-waarde als het aantal_decimalen is opgegeven.