Zachowanie zaokrąglania w Pythonie 3.x.

Właśnie ponownie przeczytałem Co nowego w Pythonie 3.0 i stwierdza:

Zmieniono strategię zaokrąglania funkcji round () i typ zwracania. Dokładne przypadki w połowie są teraz zaokrąglane do najbliższego parzystego wyniku zamiast od zera. (Na przykład round (2.5) zwraca teraz 2 zamiast 3).

oraz dokumentacja do rundy :

W przypadku typów wbudowanych obsługujących funkcję round () wartości są zaokrąglane do najbliższej wielokrotności 10 do potęgi minus n; jeśli dwie wielokrotności są jednakowo zbliżone, następuje zaokrąglenie w kierunku parzystego wyboru

Tak więc w wersji 2.7.3 :

In [85]: round(2.5)
Out[85]: 3.0

In [86]: round(3.5)
Out[86]: 4.0

jak bym się spodziewał. Jednak teraz w wersji 3.2.3 :

In [32]: round(2.5)
Out[32]: 2

In [33]: round(3.5)
Out[33]: 4

Wydaje się to sprzeczne z intuicją i sprzeczne z tym, co rozumiem o zaokrąglaniu (i potykaniu się o ludzi). Angielski nie jest moim językiem ojczystym, ale dopóki tego nie przeczytałem, wydawało mi się, że wiem, co oznacza zaokrąglenie: - / Jestem pewien, że w momencie wprowadzenia wersji 3 musiała o tym rozmawiać, ale nie mogłem znaleźć dobrego powodu w moje wyszukiwanie.

1. Czy ktoś ma wgląd w to, dlaczego zmieniono to na to?
2. Czy są jakieś inne popularne języki programowania (np. C, C ++, Java, Perl, ...), które wykonują tego rodzaju (dla mnie niespójne) zaokrąglanie?

Czego tu brakuje?

AKTUALIZACJA: @ Li-aungYip w komentarzu dotyczącym „Zaokrąglanie bankierów” dało mi właściwe wyszukiwane hasło / słowa kluczowe do wyszukania i znalazłem następujące pytanie SO: Dlaczego .NET domyślnie używa zaokrąglania bankierów? , więc będę to uważnie czytał.

Sposób Pythona 3.0 jest obecnie uważany za standardową metodę zaokrąglania, chociaż niektóre implementacje językowe nie są jeszcze dostępne w magistrali.

Prosta technika „zawsze zaokrąglaj 0,5 w górę” skutkuje lekkim odchyleniem w kierunku wyższej liczby. W przypadku dużej liczby obliczeń może to być znaczące. Podejście Python 3.0 eliminuje ten problem.

W powszechnym użyciu jest więcej niż jedna metoda zaokrąglania. IEEE 754, międzynarodowy standard matematyki zmiennoprzecinkowej, definiuje pięć różnych metod zaokrąglania (domyślną jest ta używana w Pythonie 3.0). I są inni.

To zachowanie nie jest tak szeroko znane, jak powinno. AppleScript był, o ile dobrze pamiętam, jednym z pierwszych użytkowników tej metody zaokrąglania. roundKomenda w AppleScript faktycznie daje kilka opcji, ale round-ku-nawet jest domyślnym, jak to jest w standardzie IEEE 754. Widocznie inżynier, który wdrożył roundpolecenie dostał więc dość wszystkich żądań do „sprawiają, że działa jak dowiedziałem się school ”, którą właśnie zaimplementował: round 2.5 rounding as taught in schooljest poprawnym poleceniem AppleScript. :-)

Możesz kontrolować zaokrąglanie uzyskiwane w Py3000 za pomocą modułu Decimal :

>>> decimal.Decimal('3.5').quantize(decimal.Decimal('1'), 
    rounding=decimal.ROUND_HALF_UP)
>>> Decimal('4')

>>> decimal.Decimal('2.5').quantize(decimal.Decimal('1'),    
    rounding=decimal.ROUND_HALF_EVEN)
>>> Decimal('2')

>>> decimal.Decimal('3.5').quantize(decimal.Decimal('1'), 
    rounding=decimal.ROUND_HALF_DOWN)
>>> Decimal('3')

Wystarczy dodać tutaj ważną notatkę z dokumentacji:

https://docs.python.org/dev/library/functions.html#round

Uwaga

Zachowanie round () dla pływaków może być zaskakujące: na przykład round (2,675, 2) daje 2,67 zamiast oczekiwanego 2,68. To nie jest błąd: wynika to z faktu, że większości ułamków dziesiętnych nie można przedstawić dokładnie jako liczby zmiennoprzecinkowej. Aby uzyskać więcej informacji, zobacz Arytmetyka zmiennoprzecinkowa: problemy i ograniczenia.

Więc nie zdziw się, jeśli uzyskasz następujące wyniki w Pythonie 3.2:

>>> round(0.25,1), round(0.35,1), round(0.45,1), round(0.55,1)
(0.2, 0.3, 0.5, 0.6)

>>> round(0.025,2), round(0.035,2), round(0.045,2), round(0.055,2)
(0.03, 0.04, 0.04, 0.06)

Ja też ostatnio miałem z tym problemy. W związku z tym opracowałem moduł Pythona 3, który ma 2 funkcje trueround () i trueround_precision (), które rozwiązują ten problem i zapewniają takie samo zaokrąglanie, do jakiego przyzwyczailiśmy się w szkole podstawowej (a nie zaokrąglanie bankierów). Oto moduł. Po prostu zapisz kod i skopiuj go lub zaimportuj. Uwaga: moduł trueround_precision może zmienić zachowanie zaokrąglania w zależności od potrzeb zgodnie z flagami ROUND_CEILING, ROUND_DOWN, ROUND_FLOOR, ROUND_HALF_DOWN, ROUND_HALF_EVEN, ROUND_HALF_UP, ROUND_UP i ROUND_05UP w module dziesiętnym (więcej informacji w tej dokumentacji). Aby zapoznać się z poniższymi funkcjami, zapoznaj się z dokumentacją lub użyj help (trueround) i help (trueround_precision), jeśli zostaną skopiowane do interpretera w celu dalszej dokumentacji.

#! /usr/bin/env python3
# -*- coding: utf-8 -*-

def trueround(number, places=0):
    '''
    trueround(number, places)

    example:

        >>> trueround(2.55, 1) == 2.6
        True

    uses standard functions with no import to give "normal" behavior to 
    rounding so that trueround(2.5) == 3, trueround(3.5) == 4, 
    trueround(4.5) == 5, etc. Use with caution, however. This still has 
    the same problem with floating point math. The return object will 
    be type int if places=0 or a float if places=>1.

    number is the floating point number needed rounding

    places is the number of decimal places to round to with '0' as the
        default which will actually return our interger. Otherwise, a
        floating point will be returned to the given decimal place.

    Note:   Use trueround_precision() if true precision with
            floats is needed

    GPL 2.0
    copywrite by Narnie Harshoe <signupnarnie@gmail.com>
    '''
    place = 10**(places)
    rounded = (int(number*place + 0.5if number>=0 else -0.5))/place
    if rounded == int(rounded):
        rounded = int(rounded)
    return rounded

def trueround_precision(number, places=0, rounding=None):
    '''
    trueround_precision(number, places, rounding=ROUND_HALF_UP)

    Uses true precision for floating numbers using the 'decimal' module in
    python and assumes the module has already been imported before calling
    this function. The return object is of type Decimal.

    All rounding options are available from the decimal module including 
    ROUND_CEILING, ROUND_DOWN, ROUND_FLOOR, ROUND_HALF_DOWN, ROUND_HALF_EVEN, 
    ROUND_HALF_UP, ROUND_UP, and ROUND_05UP.

    examples:

        >>> trueround(2.5, 0) == Decimal('3')
        True
        >>> trueround(2.5, 0, ROUND_DOWN) == Decimal('2')
        True

    number is a floating point number or a string type containing a number on 
        on which to be acted.

    places is the number of decimal places to round to with '0' as the default.

    Note:   if type float is passed as the first argument to the function, it
            will first be converted to a str type for correct rounding.

    GPL 2.0
    copywrite by Narnie Harshoe <signupnarnie@gmail.com>
    '''
    from decimal import Decimal as dec
    from decimal import ROUND_HALF_UP
    from decimal import ROUND_CEILING
    from decimal import ROUND_DOWN
    from decimal import ROUND_FLOOR
    from decimal import ROUND_HALF_DOWN
    from decimal import ROUND_HALF_EVEN
    from decimal import ROUND_UP
    from decimal import ROUND_05UP

    if type(number) == type(float()):
        number = str(number)
    if rounding == None:
        rounding = ROUND_HALF_UP
    place = '1.'
    for i in range(places):
        place = ''.join([place, '0'])
    return dec(number).quantize(dec(place), rounding=rounding)

Mam nadzieję że to pomoże,

Narnie

Python 3.x zaokrągla wartości 0,5 do parzystego sąsiada

assert round(0.5) == 0
assert round(1.5) == 2
assert round(2.5) == 2

import decimal

assert decimal.Decimal('0.5').to_integral_value() == 0
assert decimal.Decimal('1.5').to_integral_value() == 2
assert decimal.Decimal('2.5').to_integral_value() == 2

można jednak zmienić zaokrąglanie dziesiętne „z powrotem” na zawsze zaokrąglanie 0,5 w górę, w razie potrzeby:

decimal.getcontext().rounding = decimal.ROUND_HALF_UP

assert decimal.Decimal('0.5').to_integral_value() == 1
assert decimal.Decimal('1.5').to_integral_value() == 2
assert decimal.Decimal('2.5').to_integral_value() == 3

i = int(decimal.Decimal('2.5').to_integral_value()) # to get an int
assert i == 3
assert type(i) is int

Zachowanie zaokrąglania w Pythonie 2 w Pythonie 3.

Dodanie 1 na 15. miejscu po przecinku. Dokładność do 15 cyfr.

round2=lambda x,y=None: round(x+1e-15,y)

Niektóre przypadki:

in: Decimal(75.29 / 2).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
in: round(75.29 / 2, 2)
out: 37.65 GOOD

in: Decimal(85.55 / 2).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
in: round(85.55 / 2, 2)
out: 42.77 BAD

Do naprawy:

in: round(75.29 / 2 + 0.00001, 2)
out: 37.65 GOOD
in: round(85.55 / 2 + 0.00001, 2)
out: 42.78 GOOD

Jeśli chcesz mieć więcej miejsc po przecinku, na przykład 4, dodaj (+ 0,0000001).

Pracuj dla mnie.

Reprodukcja próbek:

['{} => {}'.format(x+0.5, round(x+0.5)) for x in range(10)]

['0.5 => 0', '1.5 => 2', '2.5 => 2', '3.5 => 4', '4.5 => 4', '5.5 => 6', '6.5 => 6', '7.5 => 8', '8.5 => 8', '9.5 => 10']

API: https://docs.python.org/3/library/functions.html#round

Stany:

Zwraca liczbę zaokrągloną do dokładności ncyfrowej po przecinku. Jeśli ndigits zostanie pominięte lub ma wartość None, zwraca najbliższą liczbę całkowitą na wejściu.

W przypadku typów wbudowanych obsługujących funkcję round () wartości są zaokrąglane do najbliższej wielokrotności liczby 10 do potęgi minus ncyfry; jeśli dwie wielokrotności są jednakowo zbliżone, zaokrąglanie odbywa się w kierunku równego wyboru (na przykład zaokrąglenie (0,5) i zaokrąglenie (-0,5) to 0, a zaokrąglenie (1,5) to 2). Dowolna wartość całkowita jest poprawna dla ncyfr (dodatnia, zero lub ujemna). Wartość zwracana jest liczbą całkowitą, jeśli pominięto ndigits lub brak. W przeciwnym razie wartość zwracana ma ten sam typ co liczba.

W przypadku ogólnego numeru obiektu Pythona zaokrąglaj delegatów do liczby. okrągłe .

Uwaga Zachowanie round () dla liczb zmiennoprzecinkowych może być zaskakujące: na przykład round (2,675, 2) daje 2,67 zamiast oczekiwanego 2,68. To nie jest błąd: wynika to z faktu, że większości ułamków dziesiętnych nie można przedstawić dokładnie jako liczby zmiennoprzecinkowej. Aby uzyskać więcej informacji, zobacz Arytmetyka zmiennoprzecinkowa: problemy i ograniczenia.

Biorąc pod uwagę ten wgląd, możesz użyć matematyki, aby go rozwiązać

import math
def my_round(i):
  f = math.floor(i)
  return f if i - f < 0.5 else f+1

teraz możesz uruchomić ten sam test z my_round zamiast round.

['{} => {}'.format(x + 0.5, my_round(x+0.5)) for x in range(10)]
['0.5 => 1', '1.5 => 2', '2.5 => 3', '3.5 => 4', '4.5 => 5', '5.5 => 6', '6.5 => 7', '7.5 => 8', '8.5 => 9', '9.5 => 10']

Najłatwiejszym sposobem zaokrąglenia w Pythonie 3.x, jak uczy szkoła, jest użycie zmiennej pomocniczej:

n = 0.1 
round(2.5 + n)

A to będą wyniki serii od 2,0 do 3,0 (w krokach co 0,1):

>>> round(2 + n)
>>> 2

>>> round(2.1 + n)
>>> 2

>>> round(2.2 + n)
>>> 2

>>> round(2.3 + n)
>>> 2

>>> round(2.4 + n)
>>> 2

>>> round(2.5 + n)
>>> 3

>>> round(2.6 + n)
>>> 3

>>> round(2.7 + n)
>>> 3

>>> round(2.8 + n)
>>> 3

>>> round(2.9 + n)
>>> 3

>>> round(3 + n)
>>> 3

Możesz kontrolować zaokrąglanie za pomocą modułu math.ceil:

import math
print(math.ceil(2.5))
> 3

Wypróbuj ten kod:

def roundup(input):   
   demo = input  if str(input)[-1] != "5" else str(input).replace("5","6")
   place = len(demo.split(".")[1])-1
   return(round(float(demo),place))

Rezultatem będzie:

>>> x = roundup(2.5)
>>> x
3.0  
>>> x = roundup(2.05)
>>> x
2.1 
>>> x = roundup(2.005)
>>> x
2.01 

Wyjście możesz sprawdzić tutaj: https://i.stack.imgur.com/QQUkS.png