Хорошее представление числа с плавающей точкой в ​​python - PullRequest
12 голосов
/ 18 апреля 2010

Я хочу представить число с плавающей запятой в виде строки, округленной до некоторого числа значащих цифр, и никогда не использовать экспоненциальный формат. По сути, я хочу отобразить любое число с плавающей запятой и убедиться, что оно & ldquo; выглядит красиво & quot;.

Эта проблема состоит из нескольких частей:

  • Мне нужно указать количество значащих цифр.
  • Количество значащих цифр должен быть переменным, который не может быть сделано с форматированием строки оператор . [править] Я был исправлен; оператор форматирования строки может сделать это.
  • Мне нужно, чтобы оно было округлено, как человек ожидал, а не что-то как 1.999999999999

Я нашел один способ сделать это, хотя это выглядит как обходной путь и не совсем идеально. (Максимальная точность составляет 15 значащих цифр.)

>>> def f(number, sigfig):
    return ("%.15f" % (round(number, int(-1 * floor(log10(number)) + (sigfig - 1))))).rstrip("0").rstrip(".")

>>> print f(0.1, 1)
0.1
>>> print f(0.0000000000368568, 2)
0.000000000037
>>> print f(756867, 3)
757000

Есть ли лучший способ сделать это? Почему в Python для этого нет встроенной функции?

Ответы [ 4 ]

8 голосов
/ 18 апреля 2010

Кажется, что нет встроенного трюка форматирования строки, который позволяет (1) печатать числа с плавающей запятой, первая значащая цифра которых появляется после 15-го знака после запятой и (2) не в научной нотации. Так что остается ручное манипулирование строками.

Ниже я использую модуль decimal для извлечения десятичных цифр из числа с плавающей точкой. Функция float_to_decimal используется для преобразования объекта с плавающей точкой в ​​объект Decimal. Очевидный способ decimal.Decimal(str(f)) неверен, потому что str(f) может терять значащие цифры.

float_to_decimal было взято из документации десятичного модуля .

Как только десятичные цифры получены как кортеж целых чисел, приведенный ниже код делает очевидную вещь: отсекает нужное количество значащих цифр, округляет при необходимости, объединяет цифры в строку, прикрепляет знак, поместите десятичную точку и нули влево или вправо в зависимости от ситуации.

Внизу вы найдете несколько случаев, которые я использовал для проверки функции f.

import decimal

def float_to_decimal(f):
    # http://docs.python.org/library/decimal.html#decimal-faq
    "Convert a floating point number to a Decimal with no loss of information"
    n, d = f.as_integer_ratio()
    numerator, denominator = decimal.Decimal(n), decimal.Decimal(d)
    ctx = decimal.Context(prec=60)
    result = ctx.divide(numerator, denominator)
    while ctx.flags[decimal.Inexact]:
        ctx.flags[decimal.Inexact] = False
        ctx.prec *= 2
        result = ctx.divide(numerator, denominator)
    return result 

def f(number, sigfig):
    # /1986897/horoshee-predstavlenie-chisla-s-plavayschei-tochkoi-v-python
    assert(sigfig>0)
    try:
        d=decimal.Decimal(number)
    except TypeError:
        d=float_to_decimal(float(number))
    sign,digits,exponent=d.as_tuple()
    if len(digits) < sigfig:
        digits = list(digits)
        digits.extend([0] * (sigfig - len(digits)))    
    shift=d.adjusted()
    result=int(''.join(map(str,digits[:sigfig])))
    # Round the result
    if len(digits)>sigfig and digits[sigfig]>=5: result+=1
    result=list(str(result))
    # Rounding can change the length of result
    # If so, adjust shift
    shift+=len(result)-sigfig
    # reset len of result to sigfig
    result=result[:sigfig]
    if shift >= sigfig-1:
        # Tack more zeros on the end
        result+=['0']*(shift-sigfig+1)
    elif 0<=shift:
        # Place the decimal point in between digits
        result.insert(shift+1,'.')
    else:
        # Tack zeros on the front
        assert(shift<0)
        result=['0.']+['0']*(-shift-1)+result
    if sign:
        result.insert(0,'-')
    return ''.join(result)

if __name__=='__main__':
    tests=[
        (0.1, 1, '0.1'),
        (0.0000000000368568, 2,'0.000000000037'),           
        (0.00000000000000000000368568, 2,'0.0000000000000000000037'),
        (756867, 3, '757000'),
        (-756867, 3, '-757000'),
        (-756867, 1, '-800000'),
        (0.0999999999999,1,'0.1'),
        (0.00999999999999,1,'0.01'),
        (0.00999999999999,2,'0.010'),
        (0.0099,2,'0.0099'),         
        (1.999999999999,1,'2'),
        (1.999999999999,2,'2.0'),           
        (34500000000000000000000, 17, '34500000000000000000000'),
        ('34500000000000000000000', 17, '34500000000000000000000'),  
        (756867, 7, '756867.0'),
        ]

    for number,sigfig,answer in tests:
        try:
            result=f(number,sigfig)
            assert(result==answer)
            print(result)
        except AssertionError:
            print('Error',number,sigfig,result,answer)
6 голосов
/ 19 апреля 2010

Если вам нужна точность с плавающей запятой, вам нужно использовать модуль decimal, который является частью стандартной библиотеки Python :

>>> import decimal
>>> d = decimal.Decimal('0.0000000000368568')
>>> print '%.15f' % d
0.000000000036857
0 голосов
/ 27 августа 2012

Вот фрагмент кода, который форматирует значение в соответствии с заданными полосами ошибок.

from math import floor, log10, round

def sigfig3(v, errplus, errmin):
    i = int(floor(-log10(max(errplus,errmin)) + 2))
    if i > 0:
        fmt = "%%.%df" % (i)
        return "{%s}^{%s}_{%s}" % (fmt % v,fmt % errplus, fmt % errmin)
    else:
        return "{%d}^{%d}_{%d}" % (round(v, i),round(errplus, i), numpy.round(i))

Примеры:

5268685 (+1463262,-2401422) becomes 5300000 (+1500000,-2400000)
0.84312 +- 0.173124 becomes 0.84 +- 0.17
0 голосов
/ 19 апреля 2010

Для правильного ответа на этот вопрос необходимы произвольные значения точности. Поэтому использование десятичного модуля является обязательным. Не существует метода для преобразования десятичной дроби в строку без использования экспоненциального формата (часть исходного вопроса), поэтому я написал для этого функцию:

def removeExponent(decimal):
    digits = [str(n) for n in decimal.as_tuple().digits]
    length = len(digits)
    exponent = decimal.as_tuple().exponent
    if length <= -1 * exponent:
        zeros = -1 * exponent - length
        digits[0:0] = ["0."] + ["0"] * zeros
    elif 0 < -1 * exponent < length:
        digits.insert(exponent, ".")
    elif 0 <= exponent:
        digits.extend(["0"] * exponent)
    sign = []
    if decimal.as_tuple().sign == 1:
        sign = ["-"]
    print "".join(sign + digits)

Проблема заключается в округлении до значимых цифр. Метод quantize () десятичного числа не округляется выше десятичной точки, а функция round () всегда возвращает число с плавающей запятой. Я не знаю, являются ли это ошибками, но это означает, что единственный способ округлить числа с плавающей запятой с бесконечной точностью - это проанализировать их как список или строку и выполнить округление вручную. Другими словами, нет разумного ответа на этот вопрос.

...