Python De functie round() met voorbeelden.

Wat is de functie round() in Python?

Python round() is een ingebouwde functie die beschikbaar is met PythonHet retourneert een zwevendekommagetal dat wordt afgerond op het aantal decimalen dat als invoer is gegeven.

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)

Kenmerken

• float_num: Het te afronden zwevendekommagetal.
• aantal_decimalen: (optioneel) Het aantal decimalen dat bij het afronden in aanmerking moet worden genomen. Dit is optioneel; indien niet opgegeven, is de standaardwaarde 0 en wordt er afgerond naar het dichtstbijzijnde hele getal.

Beschrijving

De round()-methode accepteert twee argumenten:

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

Het tweede argument is optioneel en heeft als standaardwaarde 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 gegeven getal achter de komma is:

• Als het resultaat groter of gelijk is aan 5, wordt er 1 bij de eindwaarde opgeteld.
• Als de waarde kleiner is dan 5, wordt de uiteindelijke waarde ongewijzigd geretourneerd, tot op het aangegeven aantal decimalen.

Winstwaarde

De functie retourneert een geheel getal als het aantal decimalen niet is opgegeven en een zwevendekommagetal als het aantal decimalen wel is opgegeven. Houd er rekening mee dat de waarde wordt afgerond naar +1 als het aantal decimalen groter of gelijk is aan 5; anders wordt de waarde ongewijzigd geretourneerd, tot het opgegeven aantal decimalen.

Hoeveel impact kan afronding hebben? (Afronding versus afknotting)

Het beste voorbeeld om de impact van afronding te illustreren is de aandelenmarkt. In het verleden, bijvoorbeeld in 1982, Beurs van Vancouver (VSE) werd gebruikt om de aandelenkoersen bij elke transactie af te ronden tot drie decimalen.

Dit gebeurde bijna 3000 keer per dag. De cumulatieve afkappingen leidden 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 onderstaande drijvende-komma getallen als aandelenkoersen. Op dit moment genereer ik ze voor een periode van 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 illustreren, heb ik een klein stukje code geschreven waarin je in eerste instantie de getallen tot 3 decimalen gebruikt, oftewel het getal na 3 decimalen afkapt.

Ik heb de oorspronkelijke totaalwaarde, het totaal dat voortkomt uit de afgekorte waarden, en het verschil tussen de oorspronkelijke en de afgekorte waarde.

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

Hieronder staan ​​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 de oorspronkelijke en de afgekorte waarde is 499.9016193868665, en na afronding (round()) is dit 0.04661938686695066.

Het verschil lijkt erg groot, en het voorbeeld laat zien hoe de round()-methode helpt bij het berekenen van een resultaat dat bijna net zo nauwkeurig is.

Voorbeeld: Afrondingsvlotter Numbers

In dit programma zullen we zien hoe afronden werkt bij drijvende-kommagetallen.

# 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 kijken naar een paar voorbeelden van hoe afronden werkt bij 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: NumPy-arrays afronden

Hoe rond je af in NumPy? arrays in Python?

Om dit op te lossen, kunnen we gebruikmaken van de NumPy-module en de methode numpy.round() of numpy.around() gebruiken, zoals in het onderstaande voorbeeld wordt getoond.

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 numpy.round() zoals hierboven getoond.

Voorbeeld: decimale module

Naast de functie round(), Python Het bevat een decimale module die helpt bij het nauwkeuriger verwerken van decimale getallen.

De module Decimal biedt verschillende afrondingstypen, zoals hieronder weergegeven:

• ROND PLAFOND: Het zal afronden naar oneindigheid.
• AFRONDEN NAAR BENEDEN: Het zal de waarde afronden naar nul.
• RONDE VLOER: Het zal afronden naar -oneindig.
• AFRONDEN_HALVE_OMLAAG: Het wordt afgerond naar de dichtstbijzijnde waarde richting nul.
• ROND_HALF_EVEN: Het wordt afgerond naar de dichtstbijzijnde waarde, met de dichtstbijzijnde even hele getallen als resultaat.
• AFRONDEN_HALVE_OMHOOG: Het wordt afgerond naar de dichtstbijzijnde waarde die van nul afwijkt.
• ROUND_UP: Het zal afronden waar de waarde van nul afwijkt.

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

Veelgestelde vragen