Das Runden einer Zahl bedeutet, die Zahl einfacher zu machen, indem ihr Wert intakt bleibt, aber näher an der nächsten Zahl liegt. 
Beispiel: Wenn wir eine Zahl abrunden möchten, sagen wir 3.5. Es wird auf die nächste ganze Zahl gerundet, die 4 ist. Die Zahl 3.74 wird jedoch auf eine Dezimalstelle gerundet, um 3.7 zu ergeben. 

Methode 1: Unter Verwendung von Einbau- round() Funktion. In Python gibt es eine integrierte Funktion round(), die eine Zahl auf die angegebene Anzahl von Ziffern abrundet. Die Funktion round() akzeptiert zwei numerische Argumente, n und n Ziffern, und gibt dann die Zahl n zurück, nachdem sie auf n Ziffern gerundet wurde. Wenn die Anzahl der Ziffern nicht zum Abrunden vorgesehen ist, rundet die Funktion die angegebene Zahl n auf die nächste ganze Zahl ab. 

Syntax: rund (Anzahl, Anzahl der Ziffern)

Parameter: 

  • number: Die zu rundende Zahl
  • Anzahl der Stellen (optional): Die Anzahl der Stellen, auf die die angegebene Zahl gerundet werden soll

Beispiel: 



print(round(11)) 
  
print(round(22.7))   
  
  
print(round(4.465, 2))  
    
print(round(4.476, 2))    
    
print(round(4.473, 2)) 

Ausgabe: 

11
23
4.46
4.48
4.47

Methode 2: Verwenden des Kürzungskonzepts .
Das Abschneiden ist eine der einfachsten Methoden zum Runden einer Zahl, bei der eine Zahl auf eine bestimmte Anzahl von Ziffern abgeschnitten wird. In dieser Funktion wird jede Ziffer nach einer bestimmten Position durch 0 ersetzt. Die Funktion truncate() kann sowohl mit positiven als auch mit negativen Zahlen verwendet werden. 

Die Kürzungsfunktion kann folgendermaßen implementiert werden:

  • Multiplizieren Sie die Zahl mit 10 ^ p (10 erhöht um die p-te Potenz), um den Dezimalpunkt p nach rechts zu verschieben.
  • Nehmen Sie den ganzzahligen Teil dieser neuen Zahl mit int().
  • Durch Verschieben der Dezimalstelle p wird durch Teilen durch 10 ^ p nach links verschoben.

Implementierung des Truncation-Konzepts mit der benutzerdefinierten Funktion truncate(): 

  
def truncate(n, decimals = 0): 
    multiplier = 10 ** decimals 
    return int(n * multiplier) / multiplier 
  
print(truncate(16.5)) 
print(truncate(-3.853, 1)) 
print(truncate(3.815, 2)) 
  
print(truncate(346.8, -1)) 
print(truncate(-2947.48, -3))

Ausgabe: 

16.0
-3.8
3.81
340.0
-2000.0

Methode 3: Verwenden von Math . Ceil() und Math.floor() Funktionen. Math.ceil(): Diese Funktion gibt die nächste Ganzzahl zurück, die größer oder gleich einer bestimmten Zahl ist. Math.floor(): Diese Funktion gibt die nächste Ganzzahl zurück, die kleiner oder gleich einer bestimmten Zahl ist. Beispiel:


import math 
  
print(math.ceil(4.2)) 
  
print(math.ceil(-0.5)) 
  
print(math.floor(2.2)) 
print(math.floor(-0.5)) 

Ausgabe: 

5
2
-1

Methode 3: Verwenden des Aufrundungskonzepts .
Beim Aufrunden wird eine Zahl auf eine bestimmte Anzahl von Stellen aufgerundet. 
 



Die Aufrundungsfunktion kann folgendermaßen implementiert werden: 

  • Zuerst wird der Dezimalpunkt in n um die richtige Anzahl von Stellen nach rechts verschoben, indem n mit 10 ** Dezimalstellen multipliziert wird.
  • Der neue Wert wird mit math.ceil() auf die nächste Ganzzahl aufgerundet.
  • Schließlich wird der Dezimalpunkt durch Teilen durch 10 ** Dezimalstellen nach links verschoben.

Implementierung des Aufrundungskonzepts mit der benutzerdefinierten Funktion round_up():

import math 
  
def round_up(n, decimals = 0):  
    multiplier = 10 ** decimals  
    return math.ceil(n * multiplier) / multiplier 
  
print(round_up(2.1)) 
print(round_up(2.23, 1)) 
print(round_up(2.543, 2)) 
  
print(round_up(22.45, -1)) 
print(round_up(2352, -2)) 

Ausgabe: 

3.0
2.3
2,55
30.0
2400.0

Wir können dem folgenden Diagramm folgen, um das Auf- und Abrunden zu verstehen. Runden Sie nach rechts und nach links ab. 
 

Grundlegendes zum Auf- und Abrunden

Beim Aufrunden wird in der Zahlenreihe immer eine Zahl nach rechts gerundet, beim Runden wird in der Zahlenreihe immer eine Zahl nach links gerundet. 
Methode 5: Verwenden Abrunden Konzept.

Beim Abrunden wird eine Zahl auf eine bestimmte Anzahl von Stellen abgerundet. 

Die Abrundungsfunktion kann folgendermaßen implementiert werden: 

  • Zuerst wird der Dezimalpunkt in n um die richtige Anzahl von Stellen nach rechts verschoben, indem n mit 10 ** Dezimalstellen multipliziert wird.
  • Der neue Wert wird mit math.floor() auf die nächste Ganzzahl aufgerundet.
  • Schließlich wird der Dezimalpunkt durch Teilen durch 10 ** Dezimalstellen nach links verschoben.

Implementierung des Rundungskonzepts mit der benutzerdefinierten Funktion round_down():

import math 
  
def round_down(n, decimals=0): 
    multiplier = 10 ** decimals 
    return math.floor(n * multiplier) / multiplier 
  
print(round_down(2.5)) 
print(round_down(2.48, 1)) 
print(round_down(-0.5)) 

Ausgabe: 



2.0
2.4
-1,0

Methode 5: Verwenden des Rounding Bias- Konzepts.
Das Konzept der Symmetrie führt den Begriff der Rundungsverzerrung ein, der beschreibt, wie sich die Rundung auf numerische Daten in einem Datensatz auswirkt. 
Die Aufrundungsstrategie hat eine Runde in Richtung einer positiven Unendlichkeitsverzerrung, da der Wert immer in Richtung einer positiven Unendlichkeit aufgerundet wird. In ähnlicher Weise hat die Abrundungsstrategie eine Runde in Richtung einer negativen Unendlichkeitsverzerrung. Die Kürzungsstrategie hat eine Runde in Richtung einer negativen Unendlichkeitsverzerrung für positive Werte und eine Runde in Richtung einer positiven Unendlichkeit für negative Werte. Rundungsfunktionen mit diesem Verhalten sollen im Allgemeinen eine Rundung gegen Null haben. 

a) Rounding Half Up- Konzept.
Die Aufrundungshälfte rundet jede Zahl mit der angegebenen Genauigkeit auf die nächste Zahl und unterbricht die Bindungen durch Aufrunden. 
Die Strategie zur Aufrundung der Hälfte wird implementiert, indem der Dezimalpunkt um die gewünschte Anzahl von Stellen nach rechts verschoben wird. In diesem Fall müssen wir feststellen, ob die Ziffer nach dem verschobenen Dezimalpunkt kleiner oder größer als 5 ist. 
Wir können dem verschobenen Wert 0,5 hinzufügen und ihn dann mit der Funktion math.floor() abrunden. 

Implementierung der Funktion round_half_up(): 

import math 
  
  
def round_half_up(n, decimals=0): 
    multiplier = 10 ** decimals 
    return math.floor(n * multiplier + 0.5) / multiplier 
  
  
print(round_half_up(1.28, 1)) 
print(round_half_up(-1.5)) 
print(round_half_up(-1.225, 2)) 

Ausgabe: 

1.3
-1,0
-1,23

b) Round-Half-Down- Konzept.
Dies rundet auf die nächste Zahl, ähnlich wie bei der Aufrundungsmethode. Der Unterschied besteht darin, dass Bindungen durch Aufrunden auf die kleinere der beiden Zahlen unterbrochen werden. Die Strategie zum Abrunden der Hälfte wird implementiert, indem math.floor() in der Funktion round_half_up() durch math.ceil() ersetzt und dann 0,5 subtrahiert wird, anstatt zu addieren. 

Implementierung der Funktion round_half_down(): 

import math 
  
def round_half_down(n, decimals=0): 
    multiplier = 10 ** decimals 
    return math.ceil(n * multiplier - 0.5) / multiplier 
  
print(round_half_down(2.5)) 
print(round_half_down(-2.5)) 
print(round_half_down(2.25, 1)) 

Ausgabe: 

2.0
-3.0
2.2

Methode 6: Rundung von Null.
In Rounding Half Away From Zero müssen wir wie gewohnt beginnen, indem wir den Dezimalpunkt um eine bestimmte Anzahl von Stellen nach rechts verschieben und dann die Ziffer (d) unmittelbar rechts von der Dezimalstelle in der neuen Zahl beachten. Es sind vier Fälle zu berücksichtigen:

  • Wenn n positiv ist und d> = 5, runden Sie auf
  • Wenn n positiv ist und d = 5, runden Sie ab
  • Wenn n negativ ist und d> = 5, runden Sie ab
  • Wenn n negativ und d <5 ist, runden Sie auf

Nach dem Runden gemäß den oben genannten Regeln können wir die Dezimalstelle wieder nach links verschieben. 

  • Rundung auf die Hälfte: Es gibt eine Möglichkeit, die Rundungsverzerrung zu verringern, während Werte in einem Datensatz gerundet werden. Wir können Krawatten einfach mit der gewünschten Genauigkeit auf die nächste gerade Zahl runden. Die Rundungshälfte zur geraden Strategie ist die Strategie, die von Pythons integrierter Runde() verwendet wird. Die Dezimalklasse bietet Unterstützung für eine schnelle, korrekt gerundete Dezimal-Gleitkomma-Arithmetik. Dies bietet mehrere Vorteile gegenüber dem Float-Datentyp. Die Standardrundungsstrategie im Dezimalmodul lautet ROUND_HALF_EVEN.

Beispiel: 

from decimal import Decimal 
print(Decimal("0.1")) 
print(Decimal(0.1)) 
  
print(Decimal("1.65").quantize(Decimal("1.0"))) 
print(Decimal("1.675").quantize(Decimal("1.00"))) 

Ausgabe: 

0,1
0.1000000000000000055511151231257827021181583404541015625
1.6
1,68