Python-round()-Funktion mit BEISPIELEN

Runden()

Round() ist eine integrierte Funktion, die in Python verfügbar ist. Sie erhalten eine Gleitkommazahl zurück, die auf die als Eingabe angegebenen Dezimalstellen gerundet wird.

Wenn die zu rundenden Dezimalstellen nicht angegeben sind, wird der Wert als 0 betrachtet und auf ne gerundetarest ganze Zahl.

Syntax

round(float_num, num_of_decimals)

Parameter

  • float_num: die zu rundende Float-Zahl.
  • num_of_decimals: (optional) Die Anzahl der Dezimalstellen, die beim Runden berücksichtigt werden sollen. Es ist optional und wenn nicht angegeben, ist es standardmäßig 0 und die Rundung erfolgt auf die nearest ganze Zahl.

Beschreibung

Die Methode „round()“ benötigt zwei Argumente

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

Das zweite Argument ist optional und hat den Standardwert 0, wenn es nicht angegeben wird. In diesem Fall wird auf ne gerundetarest Ganzzahl, und der Rückgabetyp ist ebenfalls eine Ganzzahl.

Wenn die Nachkommastellen, also das zweite Argument, vorhanden sind, wird auf die angegebene Stellenzahl gerundet. Der Rückgabetyp ist ein Float.

Ist die Zahl nach der Dezimalstelle angegeben

  • >=5 als + 1 wird zum Endwert addiert
  • <5 als der endgültige Wert zurückgegeben wird, da er bis auf die genannten Dezimalstellen reicht.

Rückgabewert

Es wird ein ganzzahliger Wert zurückgegeben, wenn num_of_decimals nicht angegeben ist, und ein Float-Wert, wenn num_of_decimals angegeben ist. Bitte beachten Sie, dass der Wert auf +1 gerundet wird, wenn der Wert nach dem Dezimalpunkt >=5 ist. Andernfalls wird der Wert bis auf die genannten Dezimalstellen zurückgegeben.

Welchen Einfluss kann Rundung haben? (Rundung vs. Kürzung)

Das beste Beispiel, um die Auswirkung der Rundung zu verdeutlichen, ist der Börsenmarkt. In der Vergangenheit, also im Jahr 1982, wurde die Vancouver-Börse (VSE): Wird verwendet, um die Aktienwerte bei jedem Trade auf drei Dezimalstellen zu kürzen.

Es wurde jeden Tag fast 3000 Mal durchgeführt. Die aufgelaufenen Kürzungen führen zu einem Verlust von rund 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 erstelle 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 Auswirkung des Rundens zu veranschaulichen, habe ich einen kleinen Code geschrieben, in dem Sie zunächst Zahlen bis auf drei Dezimalstellen verwenden müssen, d. h. die Zahl nach drei Dezimalstellen abschneiden muss.

Ich habe den ursprünglichen Gesamtwert, die Summe aus gekürzten Werten und die Differenz zwischen ursprünglichem und gekürztem Wert.

Für denselben Zahlensatz habe ich die Methode „round()“ bis zu drei 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)

Ausgang:

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 Methode „round()“ dabei hilft, nahezu genaue Berechnungen durchzuführen.

Beispiel: Float-Zahlen runden

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

Ausgang:

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: Ganzzahlwerte runden

Wenn Sie „round()“ für einen ganzzahligen Wert verwenden, erhalten Sie einfach die Zahl ohne Änderungen zurück.

# testing round() on a integer

num = 15

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

Ausgang:

The output is 15

Beispiel: Runden negativer Zahlen

Sehen wir uns einige Beispiele dafür 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))

Ausgang:

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

Beispiel: Runde Numpy-Arrays

So runden Sie Numpy Arrays in Python?

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

Verwenden von 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)

Ausgang:

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 das gleiche Ergebnis wie im folgenden Beispiel liefert.

Beispiel: Dezimalmodul

Zusätzlich zur Funktion „round()“ verfügt Python über ein Dezimalmodul, das bei der genaueren Verarbeitung von Dezimalzahlen hilft.

Das Decimal-Modul verfügt über Rundungsarten, wie unten gezeigt:

  • ROUND_CEILING: Es wird in Richtung Unendlichkeit gerundet,
  • ROUND_DOWN: Der Wert wird gegen Null gerundet.
  • ROUND_FLOOR: Es wird in Richtung -Unendlich gerundet,
  • ROUND_HALF_DOWN: Es wird auf ne gerundetarest-Wert geht gegen Null,
  • ROUND_HALF_EVEN: Es wird auf ne gerundetarest mit Wert geht zu nearest gerade ganze Zahl,
  • ROUND_HALF_UP: Es wird auf ne gerundetarest mit einem Wert, der von Null weggeht
  • ROUND_UP: Es wird gerundet, wenn der Wert von Null weggeht.

Im Dezimalformat hilft die Methode quantize() 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 Dezimalmethoden

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)

Ausgang:

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 integrierte Funktion, die in Python verfügbar ist. Sie erhalten die Gleitkommazahl zurück, die auf die als Eingabe angegebenen Dezimalstellen gerundet wird.
  • float_num: die zu rundende Float-Zahl.
  • 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 Float-Wert, wenn num_of_decimals angegeben ist.