Python-Funktion round() mit BEISPIELE

Runde()

Round() ist eine eingebaute Funktion, die mit Python verfügbar ist. Es gibt Ihnen eine Gleitkommazahl zurück, die auf die als Eingabe angegebenen Dezimalstellen gerundet wird.

Wenn die zu rundenden Dezimalstellen nicht angegeben sind, wird sie als 0 betrachtet und auf die nächste ganze Zahl gerundet.

In diesem Python-Tutorial lernen Sie:

Runde()
Syntax:
Wie viel Einfluss kann Rundung haben? (Rundung vs. Trunkierung)
Beispiel:Rundung von Gleitkommazahlen
Beispiel:Rundung ganzzahliger Werte
Beispiel:Rundung negativer Zahlen
Beispiel:Runde Numpy-Arrays
Beispiel:Dezimalmodul

Syntax:

round(float_num, num_of_decimals)

Parameter

float_num:die zu rundende Gleitkommazahl.
num_of_decimals:(optional) Die Anzahl der Dezimalstellen, die beim Runden berücksichtigt werden sollen. Es ist optional, und wenn es nicht angegeben ist, ist es standardmäßig 0, und es wird auf die nächste ganze Zahl gerundet.

Beschreibung

Die Methode round() nimmt zwei Argumente

die zu rundende Zahl und
die Dezimalstellen, die beim Runden berücksichtigt werden sollen.

Das zweite Argument ist optional und ist standardmäßig 0, wenn es nicht angegeben ist, und in diesem Fall wird es auf die nächste Ganzzahl gerundet, und der Rückgabetyp ist ebenfalls eine Ganzzahl.

Wenn die Dezimalstellen, d. h. das zweite Argument, vorhanden sind, wird auf die Anzahl der angegebenen Stellen gerundet. Der Rückgabetyp ist ein Float.

Wird die Zahl hinter dem Komma angegeben

>=5 als +1 wird zum Endwert addiert
<5 dann wird der endgültige Wert bis auf die angegebenen Dezimalstellen zurückgegeben.

Rückgabewert

Es gibt einen ganzzahligen Wert zurück, wenn num_of_decimals nicht angegeben ist, und einen Gleitkommawert, wenn num_of_decimals angegeben ist. Bitte beachten Sie, dass der Wert auf +1 gerundet wird, wenn der Wert nach dem Dezimalpunkt>=5 ist, ansonsten wird der Wert bis auf die angegebenen Dezimalstellen unverändert zurückgegeben.

Wie viel Einfluss kann Rundung haben? (Rundung vs. Trunkierung)

Das beste Beispiel, um die Auswirkungen der Rundung zu zeigen, ist der Börsenmarkt. In der Vergangenheit, d. h. im Jahr 1982, hat die Vancouver Stock Exchange (VSE):die Aktienwerte bei jedem Trade auf drei Dezimalstellen gekürzt.

Es wurde jeden Tag fast 3000 Mal gemacht. Die kumulierten Kürzungen führen zu einem Verlust von etwa 25 Punkten pro Monat.

Ein Beispiel für das Abschneiden der Werte im Vergleich zum Runden ist unten dargestellt.

Betrachten Sie die unten generierten Gleitkommazahlen als Aktienwerte. Im Moment generiere ich es für eine Reihe von

1.000.000 Sekunden zwischen 0,01 und 0,05.

Beispiele:

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

Um die Auswirkungen der Rundung zu zeigen, habe ich einen kleinen Code geschrieben, in dem Sie zunächst die Zahlen nur bis zu 3 Dezimalstellen verwenden müssen, dh die Zahl nach 3 Dezimalstellen abschneiden.

Ich habe den ursprünglichen Gesamtwert, die Summe aus abgeschnittenen Werten und die Differenz zwischen ursprünglichem und abgeschnittenem Wert.

Für denselben Zahlensatz habe ich die Methode round() bis auf 3 Dezimalstellen verwendet und die Summe und die Differenz zwischen dem ursprünglichen Wert und dem gerundeten Wert berechnet.

Hier sind das Beispiel und die Ausgabe

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

Ausgabe:

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

Der Unterschied zwischen Original und nach dem Abschneiden beträgt 499,9016193868665 und von rund 0,04661938686695066

Der Unterschied scheint sehr groß zu sein, und das Beispiel zeigt, wie die round()-Methode bei der Berechnung nahezu genau hilft.

Beispiel:Rundung von Float-Zahlen

In diesem Programm werden wir sehen, wie Wörter auf Gleitkommazahlen gerundet werden

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

Ausgabe:

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

Beispiel:Rundung ganzzahliger Werte

Wenn Sie round() auf einen ganzzahligen Wert anwenden, wird Ihnen einfach die Zahl ohne Änderungen zurückgegeben.

# testing round() on a integer

num = 15

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

Ausgabe:

The output is 15

Beispiel:Rundung negativer Zahlen

Sehen wir uns einige Beispiele an, wie das Runden bei negativen Zahlen funktioniert

# testing round()

num = -2.8
num1 = -1.5
print("The value after rounding is", round(num))
print("The value after rounding is", round(num1))

Ausgabe:

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

Beispiel:Runde Numpy-Arrays

Wie rundet man numpy Arrays in Python?

Um dies zu lösen, können wir das Modul numpy verwenden und die Methoden numpy.round() oder numpy.around() verwenden, wie im folgenden Beispiel gezeigt.

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

Ausgabe:

C:\pythontest>python testround.py
[-0.34  1.46  4.23 -0.34  7.63  5.12]

Wir können auch numpy.around() verwenden, was Ihnen das gleiche Ergebnis liefert, wie im Beispiel unten gezeigt.

Beispiel:Dezimalmodul

Zusätzlich zur round()-Funktion hat Python ein Dezimalmodul, das dabei hilft, Dezimalzahlen genauer zu behandeln.

Das Decimal-Modul enthält Rundungstypen, wie unten gezeigt:

ROUND_CEILING:Es wird in Richtung Unendlich gerundet,
ROUND_DOWN:Der Wert wird gegen Null gerundet,
ROUND_FLOOR:Es wird in Richtung -Unendlich gerundet,
ROUND_HALF_DOWN:Es wird auf den nächsten Wert gerundet, der gegen Null geht,
ROUND_HALF_EVEN:Es wird auf die nächste ganze Zahl gerundet, wobei der Wert auf die nächste gerade Ganzzahl geht,
ROUND_HALF_UP:Es wird auf den nächsten Wert gerundet, wobei der Wert von Null weggeht
ROUND_UP:Es wird gerundet, wo der Wert von Null weggeht.

Bei Dezimalzahlen hilft die quantize()-Methode dabei, auf eine feste Anzahl von Dezimalstellen zu runden, und Sie können die zu verwendende Rundung angeben, wie im folgenden Beispiel gezeigt.

Beispiel:

Verwendung von round()- und decimal-Methoden

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)

Ausgabe:

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

Zusammenfassung:

Round(float_num, Num_of_decimals) ist eine eingebaute Funktion, die mit Python verfügbar ist. Es gibt Ihnen die Gleitkommazahl zurück, die auf die als Eingabe angegebenen Dezimalstellen gerundet wird.
float_num:die zu rundende Gleitkommazahl.
Num_of_decimals:Dies ist die Anzahl der Dezimalstellen, die beim Runden berücksichtigt werden sollen.
Es wird ein ganzzahliger Wert zurückgegeben, wenn num_of_decimals nicht angegeben ist, und ein Gleitkommawert, wenn num_of_decimals angegeben ist.

Python abs() Funktion:Beispiele für absolute Werte Python range() Funktion:Float, List, For-Schleife Beispiele

Python