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 de af te ronden decimalen niet zijn gespecificeerd, wordt dit beschouwd als 0 en wordt afgerond naar de nearest geheel getal.

Syntaxis

round(float_num, num_of_decimals)

parameters

  • float_num: het floatgetal 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 wordt gespecificeerd, wordt het standaard op 0 gezet en wordt afgerond naar de nearest geheel getal.

Omschrijving

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 wordt standaard op 0 gezet als het niet wordt opgegeven. In dat geval wordt het afgerond naar nearest geheel getal, en het retourneringstype zal ook een geheel getal zijn.

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 hieronder gegenereerde getallen met drijvende komma 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 eerst de getallen tot slechts 3 decimalen hoeft te gebruiken, dat wil zeggen dat je 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 op 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: zwevende getallen 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))

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 negatieve getallen

Laten we enkele 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 functie round() heeft Python een decimale module die helpt bij het nauwkeuriger omgaan met decimale getallen.

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: het wordt afgerond naar nearest-waarde richting nul,
  • ROUND_HALF_EVEN: het wordt afgerond naar nearest waarbij de waarde naar ne gaatarest zelfs geheel getal,
  • ROUND_HALF_UP: het wordt afgerond naar nearest waarbij de waarde weggaat van nul
  • 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

Samengevat

  • 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.