Hành vi làm tròn Python 3.x

Tôi vừa đọc lại What New trong Python 3.0 và nó nói:

Chiến lược làm tròn hàm () và kiểu trả về đã thay đổi. Các trường hợp nửa chừng chính xác bây giờ được làm tròn đến kết quả thậm chí gần nhất thay vì từ 0. (Ví dụ: vòng (2.5) bây giờ trả về 2 thay vì 3.)

và tài liệu cho vòng :

Đối với các loại tích hợp hỗ trợ round (), các giá trị được làm tròn đến bội số gần nhất của 10 với công suất trừ n; Nếu hai bội số gần nhau như nhau, làm tròn được thực hiện theo lựa chọn chẵn

Vì vậy, theo v2.7.3 :

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

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

như tôi đã mong đợi Tuy nhiên, bây giờ theo v3.2.3 :

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

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

Điều này có vẻ phản trực giác và trái ngược với những gì tôi hiểu về làm tròn số (và bị ràng buộc để làm tăng người lên). Tiếng Anh không phải là ngôn ngữ mẹ đẻ của tôi nhưng cho đến khi tôi đọc nó, tôi nghĩ rằng tôi biết làm tròn có nghĩa là gì: - / Tôi chắc chắn tại thời điểm v3 được giới thiệu, phải có một số cuộc thảo luận về điều này, nhưng tôi không thể tìm thấy lý do chính đáng trong tìm kiếm của tôi.

1. Có ai có cái nhìn sâu sắc về lý do tại sao điều này đã được thay đổi thành này?
2. Có bất kỳ ngôn ngữ lập trình chính thống nào khác (ví dụ: C, C ++, Java, Perl, ..) thực hiện kiểu làm tròn này (với tôi không nhất quán) không?

Tôi đang thiếu gì ở đây?

CẬP NHẬT: Nhận xét của @ Li-aungYip lại "Làm tròn ngân hàng" đã cho tôi cụm từ / từ khóa tìm kiếm phù hợp để tìm kiếm và tôi đã tìm thấy câu hỏi SO này: Tại sao .NET sử dụng làm tròn ngân hàng làm mặc định? , vì vậy tôi sẽ đọc nó một cách cẩn thận.

Cách của Python 3.0 được coi là phương pháp làm tròn tiêu chuẩn ngày nay, mặc dù một số triển khai ngôn ngữ chưa có trên xe buýt.

Kỹ thuật "luôn làm tròn 0,5 lên" đơn giản dẫn đến sai lệch nhỏ so với số cao hơn. Với số lượng lớn các tính toán, điều này có thể là đáng kể. Cách tiếp cận Python 3.0 loại bỏ vấn đề này.

Có nhiều hơn một phương pháp làm tròn được sử dụng phổ biến. IEEE 754, tiêu chuẩn quốc tế cho toán học dấu phẩy động, định nghĩa năm phương pháp làm tròn khác nhau ( phương pháp được sử dụng bởi Python 3.0 là mặc định). Và có những người khác.

Hành vi này không được biết đến rộng rãi như nó phải được. AppleScript là, nếu tôi nhớ chính xác, là người áp dụng sớm phương pháp làm tròn này. Các roundlệnh trong AppleScript thực sự không phục vụ một số tùy chọn, nhưng tròn về phía-thậm chí là mặc định vì nó là trong IEEE 754. Rõ ràng người kỹ sư thực hiện các roundlệnh đã quá chán ngán với tất cả các yêu cầu để "làm cho nó làm việc như tôi đã học được trong trường "mà ông đã thực hiện chỉ là: round 2.5 rounding as taught in schoollà một lệnh AppleScript hợp lệ. :-)

Bạn có thể điều khiển làm tròn số bạn nhận được trong Py3000 bằng mô-đun thập phân :

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

Chỉ cần thêm vào đây một lưu ý quan trọng từ tài liệu:

https://docs.python.org/dev/l Library / fiances.html #round

Ghi chú

Hành vi của vòng () đối với phao có thể gây ngạc nhiên: ví dụ: vòng (2.675, 2) cho 2,67 thay vì 2,68 như mong đợi. Đây không phải là một lỗi: đó là kết quả của thực tế là hầu hết các phân số thập phân không thể được biểu diễn chính xác dưới dạng nổi. Xem Số học dấu phẩy động: Các vấn đề và giới hạn để biết thêm thông tin.

Vì vậy, đừng ngạc nhiên khi nhận được kết quả sau trong Python 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)

Gần đây tôi cũng có vấn đề với điều này. Do đó, tôi đã phát triển một mô-đun python 3 có 2 chức năng trueround () và trueround_precision () giải quyết vấn đề này và đưa ra hành vi làm tròn tương tự được sử dụng từ trường tiểu học (không phải làm tròn ngân hàng). Đây là mô-đun. Chỉ cần lưu mã và sao chép nó vào hoặc nhập nó. Lưu ý: mô-đun trueround_precision có thể thay đổi hành vi làm tròn tùy theo nhu cầu theo các mô-đun ROUND_CEILING, ROUND_DOWN, ROUND_FLOOR, ROUND_HALF_DOWN, ROUND_HALF_EVEN, ROUND_HALF_UP, ROUND_ Đối với các chức năng bên dưới, hãy xem các tài liệu hoặc sử dụng trợ giúp (trueround) và trợ giúp (trueround_precision) nếu được sao chép vào một trình thông dịch để có thêm tài liệu.

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

Hi vọng điêu nay co ich,

Narnie

Python 3.x làm tròn 0,5 giá trị cho hàng xóm chẵn

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

tuy nhiên, người ta có thể thay đổi "làm tròn" thập phân thành luôn làm tròn .5 lên, nếu cần:

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

Hành vi làm tròn Python 2 trong python 3.

Thêm 1 ở vị trí thập phân thứ 15. Độ chính xác lên tới 15 chữ số.

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

Một số trường hợp:

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

Để khắc phục:

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

Nếu bạn muốn có nhiều số thập phân hơn, ví dụ 4, bạn nên thêm (+ 0,0000001).

Làm việc cho tôi.

Sinh sản mẫu:

['{} => {}'.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/l Library / fiances.html #round

Những trạng thái:

Trả về số được làm tròn đến độ chính xác ndigits sau dấu thập phân. Nếu ndigits bị bỏ qua hoặc là Không có, nó sẽ trả về số nguyên gần nhất cho đầu vào của nó.

Đối với các loại tích hợp hỗ trợ round (), các giá trị được làm tròn đến bội số gần nhất của 10 với công suất trừ ndigits; nếu hai bội số gần nhau như nhau, làm tròn được thực hiện theo lựa chọn chẵn (ví dụ: cả vòng (0,5) và vòng (-0,5) là 0 và vòng (1,5) là 2). Bất kỳ giá trị số nguyên nào cũng hợp lệ cho ndigits (dương, không hoặc âm). Giá trị trả về là một số nguyên nếu ndigits bị bỏ qua hoặc Không có. Nếu không, giá trị trả về có cùng loại với số.

Đối với một số đối tượng Python chung, làm tròn số đại biểu thành số. tròn .

Lưu ý Hành vi của vòng () đối với phao có thể gây ngạc nhiên: ví dụ: vòng (2.675, 2) cho 2.67 thay vì 2.68 như mong đợi. Đây không phải là một lỗi: đó là kết quả của thực tế là hầu hết các phân số thập phân không thể được biểu diễn chính xác dưới dạng nổi. Xem Số học dấu phẩy động: Các vấn đề và giới hạn để biết thêm thông tin.

Với cái nhìn sâu sắc này, bạn có thể sử dụng một số toán học để giải quyết nó

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

bây giờ bạn có thể chạy thử nghiệm tương tự với my_round thay vì vòng.

['{} => {}'.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']

Cách dễ nhất để làm tròn trong Python 3.x như được dạy ở trường là sử dụng biến phụ trợ:

n = 0.1 
round(2.5 + n)

Và đây sẽ là kết quả của loạt 2.0 đến 3.0 (trong 0,1 bước):

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

Bạn có thể điều khiển làm tròn bạn bằng mô-đun math.ceil:

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

Hãy thử mã này:

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

Kết quả sẽ là:

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

Ooutput bạn có thể kiểm tra tại đây: https://i.stack.imgur.com/QQUkS.png