Zahlen kaufmännisch Runden

[Sirius3]

wenn Du Python 2.7 benutzt, dann ist die Division / ein Ganzzahldivision. Von daher solltest Du Fließkommadivision als default einstellen. Runden sollte man erst bei der Ausgabe:

Code: Alles auswählen

from __future__ import division
print "{:.0f}".format(422999 / 1000)

[__blackjack__]

@don dirko: Also ich weiss nicht was Du meinst. Hier Python 2.7:

Code: Alles auswählen

In [5]: print round(422999 / 1000)
422.0

In [6]: print round(round(422999 / 1000))
422.0

Und hier 3.5:

Code: Alles auswählen

In [2]: print(round(422999 / 1000))
423

In [3]: print(round(round(422999 / 1000)))
423

In keinem der beiden Fälle bringt doppeltes `round()` irgendwas. Wäre auch sehr verwunderlich.

Der Unterschied zwischen den beiden ist hauptsächlich der hier:
Python 2:

Code: Alles auswählen

In [7]: 422999 / 1000
Out[7]: 422

Python 3:

Code: Alles auswählen

In [4]: 422999 / 1000
Out[4]: 422.999

In Python 2 ergibt die Division von zwei `int`-Werten einen `int`-Wert, in Python 3 dagegen einen `float`-Wert.

[Sirius3]

@__blackjack__: wichtig ist die Klammernsetzung. `round(422999)` wandelt erst die Zahl in float, die dann korrekt geteilt werden kann. Auch so ein Punkt, der sich zwischen Python 2 und 3 grundsätzlich geändert hat.

[__blackjack__]

Ups, glatt übersehen das `round()` als `float()` missbraucht wurde.

[c.burkes]

Moin =)


Reanimation eines alten Threads .... check xD

... das von ...

unverzerrtes Runden ("round-to-even"),

... beschriebene betrifft auch die Umwandlung von einem float-Wert in einen int-Wert? Sprich, da wird einfach auf Grund des Prinzipes des Programmes alles nach dem Komma weggecuttet, was auch immer da steht? Es besteht ansonsten keine mathematische Notwendigkeit oder der Gleichen?

Bin gerade, wie Märzhase, im Rahmen einer Uebung darueber gestolpert und erinnere mich dunkel, dazu mal nen Satz gelesen zu haben. Leider war das nur ne Erwaehnung und keine Erklaerung ...


lg, c.b

[__blackjack__]

@c.burkes: Nein, `round()` und `int()` machen da unterschiedliches. `round()` macht unverzerrtes Runden, und `int()` schneidet alle Nachkommastellen ab. Letzteres ist in Python 2 und 3 das gleiche Vehalten.

Python 3:

Code: Alles auswählen

In [7]: [(round(x), int(x)) for x in [0.5, 1.5, 2.5, 3.5, 4.5]]
Out[7]: [(0, 0), (2, 1), (2, 2), (4, 3), (4, 4)]

[c.burkes]

Achso ... das meint das round to even ... okay .... worin begruendet sich dann aber das Abschneiden bei float zu int? Also ich meine, warum macht sich das Programm eben nicht die Muehe zu runden .... also kaufmaennisch?

[__blackjack__]

@c.burkes: Braucht man dafür eine Begründung? Das ist halt so™. Und auch irgendwie das was man erwartet. Das war bei meiner ersten Programmiersprache so (CBM BASIC V2), das ist bei C so wenn man da implizit oder explizit von Gleitkommazahl zu Ganzzahl gewandelt wird. Kannst ja mal eine Programmiersprache suchen wo das anders gehandhabt wird.

Edit: Warum sollte sich `int()` die Mühe geben zu runden? Dafür gibt es doch `round()`. Beziehungsweise wenn Du eine bestimmte Rundungsart haben möchtest, musst Du ja sowieso selbst Hand anlegen, denn es gibt ja nicht *die* Rundungsart die für alle passt. Da ist es IMHO besser einfach abzuschneiden, und damit die Möglichkeit zu haben basierend darauf eigene Rundungsarten zu implementieren. Das ist mit einfach abschneiden nämlich einfacher als wenn das jetzt beispielsweise kaufmännisch runden würde.

[c.burkes]

okay ... der Vergleich zu anderen Sprachen fehlt mir natuerlich komplett und ich haette aus reiner Selbstbezogenheit, da ich eben immer kaufmaennisch Runde, das auch vom Pc so erwartet xD

Aber gut - ist eben nicht so. Danke Dir!

Da ist es IMHO besser einfach abzuschneiden, und damit die Möglichkeit zu haben basierend darauf eigene Rundungsarten zu implementieren. Das ist mit einfach abschneiden nämlich einfacher als wenn das jetzt beispielsweise kaufmännisch runden würde.

Ah ... ich ahne was Du ansprichst. Das klingt logisch *tu*

[DeaD_EyE]

Das kaufmännische Runden findet in der Wissenschaft keine Anwendung.
Hier mit einem Video erklärt: https://www.youtube.com/watch?v=3D64rkIy_Ug
Nochmal mit Code erklärt.

Code: Alles auswählen

def kround(number):
    if (number - int(number)) >= 0.5:
        return int(number) + 1
    else:
        return int(number)

numbers = [n + 0.5 for n in range(1,10)]
knumbers = [kround(n) for n in numbers]
wnumbers = [round(n) for n in numbers]
print('Summe:', sum(numbers))
print('Summe aus kaufmännisch gerundeten Zahlen:', sum(knumbers))
print('Summe aus wissenschaftliche gerundeten Zahlen:', sum(wnumbers))

Welches Ergebnis ist nun das beste?
Jemanden, der mir mit kaufmännischen Runden um die Ecke kommt, jage ich zum Teufel!

[Sirius3]

@DeaD_EyE: Deine Funktion kround funktioniert nur für positive Zahlen.

Code: Alles auswählen

def kround(number):
    return int(number) + (abs(number) % 1 >= 0.5) * ((number > 0) * 2 - 1)

[DeaD_EyE]

Habe sie auch nur auf positive Zahlen angewandt
Jetzt sieht sie nicht mehr so schön aus.

[DeaD_EyE]

Ich habe deine Methode mal etwas geändert:

Code: Alles auswählen

def kround2(number):
    sign = -1 if number < 0 else 1
    rest = abs(number) % 1
    number = int(number)
    if rest >= 0.5:
        return number + sign
    else:
        return number

Der Trick mit modulo gefällt mir.

[__blackjack__]

Ich habe das mal so geschrieben als ich es brauchte:

Code: Alles auswählen

def kround(x):
    fractional, integer = math.modf(x)
    return int(integer) + (-1 if x < 0 else 1) * (abs(fractional) >= 0.5)