round () tampaknya tidak membulatkan dengan benar

Dokumentasi untuk fungsi round () menyatakan bahwa Anda memberikan angka, dan posisi melewati desimal untuk membulatkan. Jadi harus melakukan ini:

n = 5.59
round(n, 1) # 5.6

Tapi, pada kenyataannya, keanehan floating point tua yang bagus merayap masuk dan Anda mendapatkan:

5.5999999999999996

Untuk keperluan UI, saya perlu menampilkan 5.6. Saya mencari-cari di Internet dan menemukan beberapa dokumentasi yang bergantung pada implementasi Python saya. Sayangnya, ini terjadi pada mesin pengembang Windows saya dan setiap server Linux yang pernah saya coba. Lihat di sini juga .

Singkatnya membuat perpustakaan bundar saya sendiri, apakah ada cara lain?

Saya tidak dapat membantu cara penyimpanannya, tetapi setidaknya pemformatan berfungsi dengan benar:

'%.1f' % round(n, 1) # Gives you '5.6'

Pemformatan bekerja dengan benar bahkan tanpa harus dibulatkan:

"%.1f" % n

Jika Anda menggunakan modul Desimal, Anda dapat memperkirakan tanpa menggunakan fungsi 'bulat'. Inilah yang telah saya gunakan untuk pembulatan terutama saat menulis aplikasi moneter:

Decimal(str(16.2)).quantize(Decimal('.01'), rounding=ROUND_UP)

Ini akan mengembalikan Angka Desimal yaitu 16.20.

round(5.59, 1)bekerja dengan baik. Masalahnya adalah 5.6 tidak dapat direpresentasikan dengan tepat dalam binary floating point.

>>> 5.6
5.5999999999999996
>>> 

Seperti yang dikatakan Vinko, Anda dapat menggunakan pemformatan string untuk melakukan pembulatan tampilan.

Python memiliki modul untuk aritmatika desimal jika Anda membutuhkannya.

Anda mendapatkan '5.6' jika Anda melakukannya, str(round(n, 1))bukan hanya round(n, 1).

Anda dapat mengganti tipe data menjadi integer:

>>> n = 5.59
>>> int(n * 10) / 10.0
5.5
>>> int(n * 10 + 0.5)
56

Dan kemudian tampilkan angkanya dengan memasukkan pemisah desimal lokal.

Namun, jawaban Jimmy lebih baik.

Matematika floating point rentan terhadap ketidakakuratan presisi yang ringan, tetapi mengganggu. Jika Anda dapat bekerja dengan integer atau titik tetap, Anda akan dijamin presisi.

Lihatlah modul Desimal

Desimal "didasarkan pada model floating-point yang dirancang dengan mempertimbangkan orang-orang, dan harus memiliki prinsip panduan terpenting - komputer harus menyediakan aritmatika yang berfungsi dengan cara yang sama seperti aritmatika yang dipelajari orang di sekolah.” - kutipan dari spesifikasi aritmatika desimal.

dan

Angka desimal dapat direpresentasikan dengan tepat. Sebaliknya, angka seperti 1.1 dan 2.2 tidak memiliki representasi yang tepat dalam titik mengambang biner. Pengguna akhir biasanya tidak mengharapkan 1.1 + 2.2 untuk ditampilkan sebagai 3.3000000000000003 seperti halnya dengan titik mengambang biner.

Desimal menyediakan jenis operasi yang memudahkan penulisan aplikasi yang memerlukan operasi floating point dan juga perlu menyajikan hasil tersebut dalam format yang dapat dibaca manusia, misalnya, akuntansi.

printf si pengisap.

print '%.1f' % 5.59  # returns 5.6

Ini memang masalah besar. Coba kode ini:

print "%.2f" % (round((2*4.4+3*5.6+3*4.4)/8,2),)

Ini menampilkan 4,85. Kemudian Anda melakukan:

print "Media = %.1f" % (round((2*4.4+3*5.6+3*4.4)/8,1),)

dan itu menunjukkan 4.8. Apakah Anda menghitung dengan tangan, jawaban pastinya adalah 4,85, tetapi jika Anda mencoba:

print "Media = %.20f" % (round((2*4.4+3*5.6+3*4.4)/8,20),)

Anda bisa melihat kebenarannya: titik pelampung disimpan sebagai penjumlahan terbatas terdekat dari pecahan yang penyebutnya adalah pangkat dua.

Anda dapat menggunakan operator format string %, mirip dengan sprintf.

mystring = "%.2f" % 5.5999

Bekerja dengan Sempurna

format(5.59, '.1f') # to display
float(format(5.59, '.1f')) #to round

Saya lakukan:

int(round( x , 0))

Dalam hal ini, pertama kita membulatkan dengan benar pada level unit, kemudian kita ubah menjadi integer untuk menghindari pencetakan float.

begitu

>>> int(round(5.59,0))
6

Saya pikir jawaban ini bekerja lebih baik daripada memformat string, dan juga lebih masuk akal bagi saya untuk menggunakan fungsi bulat.

Saya akan menghindari mengandalkan round()sama sekali dalam kasus ini. Mempertimbangkan

print(round(61.295, 2))
print(round(1.295, 2))

akan mengeluarkan

61.3
1.29

yang bukan merupakan keluaran yang diinginkan jika Anda membutuhkan pembulatan solid ke bilangan bulat terdekat. Untuk melewati perilaku ini, ikuti math.ceil()(atau math.floor()jika Anda ingin membulatkan ke bawah):

from math import ceil
decimal_count = 2
print(ceil(61.295 * 10 ** decimal_count) / 10 ** decimal_count)
print(ceil(1.295 * 10 ** decimal_count) / 10 ** decimal_count)

keluaran

61.3
1.3

Semoga membantu.

Kode:

x1 = 5.63
x2 = 5.65
print(float('%.2f' % round(x1,1)))  # gives you '5.6'
print(float('%.2f' % round(x2,1)))  # gives you '5.7'

Keluaran:

5.6
5.7

Di sinilah saya melihat ronde gagal. Bagaimana jika Anda ingin membulatkan 2 angka ini menjadi satu tempat desimal? 23.45 23.55 Pendidikan saya adalah dari pembulatan ini anda akan mendapatkan: 23.4 23.6 "aturannya" adalah anda harus membulatkan jika bilangan sebelumnya ganjil, bukan pembulatan jika bilangan sebelumnya genap. Fungsi bulat di python hanya memotong 5.

Masalahnya hanya jika digit terakhir adalah 5. Mis. 0,045 disimpan secara internal sebagai 0,044999999999999 ... Anda cukup menaikkan digit terakhir menjadi 6 dan membulatkannya. Ini akan memberi Anda hasil yang diinginkan.

import re


def custom_round(num, precision=0):
    # Get the type of given number
    type_num = type(num)
    # If the given type is not a valid number type, raise TypeError
    if type_num not in [int, float, Decimal]:
        raise TypeError("type {} doesn't define __round__ method".format(type_num.__name__))
    # If passed number is int, there is no rounding off.
    if type_num == int:
        return num
    # Convert number to string.
    str_num = str(num).lower()
    # We will remove negative context from the number and add it back in the end
    negative_number = False
    if num < 0:
        negative_number = True
        str_num = str_num[1:]
    # If number is in format 1e-12 or 2e+13, we have to convert it to
    # to a string in standard decimal notation.
    if 'e-' in str_num:
        # For 1.23e-7, e_power = 7
        e_power = int(re.findall('e-[0-9]+', str_num)[0][2:])
        # For 1.23e-7, number = 123
        number = ''.join(str_num.split('e-')[0].split('.'))
        zeros = ''
        # Number of zeros = e_power - 1 = 6
        for i in range(e_power - 1):
            zeros = zeros + '0'
        # Scientific notation 1.23e-7 in regular decimal = 0.000000123
        str_num = '0.' + zeros + number
    if 'e+' in str_num:
        # For 1.23e+7, e_power = 7
        e_power = int(re.findall('e\+[0-9]+', str_num)[0][2:])
        # For 1.23e+7, number_characteristic = 1
        # characteristic is number left of decimal point.
        number_characteristic = str_num.split('e+')[0].split('.')[0]
        # For 1.23e+7, number_mantissa = 23
        # mantissa is number right of decimal point.
        number_mantissa = str_num.split('e+')[0].split('.')[1]
        # For 1.23e+7, number = 123
        number = number_characteristic + number_mantissa
        zeros = ''
        # Eg: for this condition = 1.23e+7
        if e_power >= len(number_mantissa):
            # Number of zeros = e_power - mantissa length = 5
            for i in range(e_power - len(number_mantissa)):
                zeros = zeros + '0'
            # Scientific notation 1.23e+7 in regular decimal = 12300000.0
            str_num = number + zeros + '.0'
        # Eg: for this condition = 1.23e+1
        if e_power < len(number_mantissa):
            # In this case, we only need to shift the decimal e_power digits to the right
            # So we just copy the digits from mantissa to characteristic and then remove
            # them from mantissa.
            for i in range(e_power):
                number_characteristic = number_characteristic + number_mantissa[i]
            number_mantissa = number_mantissa[i:]
            # Scientific notation 1.23e+1 in regular decimal = 12.3
            str_num = number_characteristic + '.' + number_mantissa
    # characteristic is number left of decimal point.
    characteristic_part = str_num.split('.')[0]
    # mantissa is number right of decimal point.
    mantissa_part = str_num.split('.')[1]
    # If number is supposed to be rounded to whole number,
    # check first decimal digit. If more than 5, return
    # characteristic + 1 else return characteristic
    if precision == 0:
        if mantissa_part and int(mantissa_part[0]) >= 5:
            return type_num(int(characteristic_part) + 1)
        return type_num(characteristic_part)
    # Get the precision of the given number.
    num_precision = len(mantissa_part)
    # Rounding off is done only if number precision is
    # greater than requested precision
    if num_precision <= precision:
        return num
    # Replace the last '5' with 6 so that rounding off returns desired results
    if str_num[-1] == '5':
        str_num = re.sub('5$', '6', str_num)
    result = round(type_num(str_num), precision)
    # If the number was negative, add negative context back
    if negative_number:
        result = result * -1
    return result

Opsi potensial lainnya adalah:

def hard_round(number, decimal_places=0):
    """
    Function:
    - Rounds a float value to a specified number of decimal places
    - Fixes issues with floating point binary approximation rounding in python
    Requires:
    - `number`:
        - Type: int|float
        - What: The number to round
    Optional:
    - `decimal_places`:
        - Type: int 
        - What: The number of decimal places to round to
        - Default: 0
    Example:
    ```
    hard_round(5.6,1)
    ```
    """
    return int(number*(10**decimal_places)+0.5)/(10**decimal_places)

Bagaimana dengan:

round(n,1)+epsilon