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

Например:

3 -> "3"
3. -> "3"
3.0 -> "3"
3.1 -> "3.1"
3.14 -> "3.14"
3.140 -> "3.14"

Я, я бы сделал ('%f' % x).rstrip('0').rstrip('.')- гарантирует форматирование с фиксированной запятой, а не научную нотацию и т. Д. Да, не так гладко и элегантно, как %g, но это работает (и я не знаю, как заставить %gникогда не использовать научную нотацию; -).

Вы можете использовать %gдля достижения этого:

'%g'%(3.140)

или, для Python 2.6 или выше:

'{0:g}'.format(3.140)

Из документов дляformat : gпричины (среди прочего)

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

Как насчет того, чтобы попробовать самый простой и, вероятно, самый эффективный подход? Метод normalize () удаляет все крайние правые нули.

from decimal import Decimal

print (Decimal('0.001000').normalize())
# Result: 0.001

Работает в Python 2 и Python 3 .

- Обновлено -

Единственная проблема, как указал @ BobStein-VisiBone, состоит в том, что числа, такие как 10, 100, 1000 ... будут отображаться в экспоненциальном представлении. Это можно легко исправить с помощью следующей функции:

from decimal import Decimal


def format_float(f):
    d = Decimal(str(f));
    return d.quantize(Decimal(1)) if d == d.to_integral() else d.normalize()

После просмотра ответов на несколько похожих вопросов, мне кажется, это лучшее решение:

def floatToString(inputValue):
    return ('%.15f' % inputValue).rstrip('0').rstrip('.')

Мои рассуждения:

%g не избавляется от научной нотации.

>>> '%g' % 0.000035
'3.5e-05'

15 знаков после запятой, кажется, избегают странного поведения и обладают достаточной точностью для моих нужд.

>>> ('%.15f' % 1.35).rstrip('0').rstrip('.')
'1.35'
>>> ('%.16f' % 1.35).rstrip('0').rstrip('.')
'1.3500000000000001'

Я мог бы использовать format(inputValue, '.15f').вместо '%.15f' % inputValue, но это немного медленнее (~ 30%).

Я мог бы использовать Decimal(inputValue).normalize(), но это также имеет несколько проблем. Во-первых, это НАМНОГО медленнее (~ 11x). Я также обнаружил, что, хотя он имеет довольно большую точность, он все еще страдает от потери точности при использовании normalize().

>>> Decimal('0.21000000000000000000000000006').normalize()
Decimal('0.2100000000000000000000000001')
>>> Decimal('0.21000000000000000000000000006')
Decimal('0.21000000000000000000000000006')

Самое главное, что я все равно буду переходить Decimalс а, floatчто может заставить вас получить что-то, кроме числа, которое вы там указали. Я думаю, что Decimalлучше всего работает, когда арифметика остается Decimalи Decimalинициализируется строкой.

>>> Decimal(1.35)
Decimal('1.350000000000000088817841970012523233890533447265625')
>>> Decimal('1.35')
Decimal('1.35')

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

Меня не интересует возможный результат "-0", так как -0.0 является допустимым числом с плавающей запятой, и, возможно, это будет редким случаем в любом случае, но так как вы упомянули, что хотите сохранить строковый результат как можно более коротким, вы всегда можно использовать дополнительные условия при очень небольших дополнительных затратах на скорость.

def floatToString(inputValue):
    result = ('%.15f' % inputValue).rstrip('0').rstrip('.')
    return '0' if result == '-0' else result

Вот решение, которое сработало для меня. Это смесь из раствора путем Polymesh и использования нового .format() синтаксиса .

for num in 3, 3., 3.0, 3.1, 3.14, 3.140:
    print('{0:.2f}'.format(num).rstrip('0').rstrip('.'))

Выход :

3
3
3
3.1
3.14
3.14

Вы можете просто использовать format () для достижения этой цели:

format(3.140, '.10g') где 10 - точность, которую вы хотите.

>>> str(a if a % 1 else int(a))

В то время как форматирование, вероятно, является наиболее питонским способом, здесь есть альтернативное решение, использующее more_itertools.rstripинструмент.

import more_itertools as mit


def fmt(num, pred=None):
    iterable = str(num)
    predicate = pred if pred is not None else lambda x: x in {".", "0"}
    return "".join(mit.rstrip(iterable, predicate))

assert fmt(3) == "3"
assert fmt(3.) == "3"
assert fmt(3.0) == "3"
assert fmt(3.1) == "3.1"
assert fmt(3.14) == "3.14"
assert fmt(3.140) == "3.14"
assert fmt(3.14000) == "3.14"
assert fmt("3,0", pred=lambda x: x in set(",0")) == "3"

Число преобразуется в строку, в которой отсутствуют завершающие символы, удовлетворяющие предикату. Определение функции fmtне является обязательным, но оно используется здесь для проверки утверждений, которые все проходят. Примечание: он работает со строковыми входами и принимает необязательные предикаты.

Смотрите также подробности об этой сторонней библиотеке more_itertools.

Если вы можете жить с 3. и 3.0, выглядящими как «3.0», очень простой подход, который удаляет нули прямо из представлений с плавающей точкой:

print("%s"%3.140)

(спасибо @ellimilial за указание на исключения)

Использование пакета QuantiPhy является опцией. Обычно QuantiPhy используется при работе с числами с единицами измерения и масштабными коэффициентами СИ, но у него есть множество приятных опций форматирования чисел.

    >>> from quantiphy import Quantity

    >>> cases = '3 3. 3.0 3.1 3.14 3.140 3.14000'.split()
    >>> for case in cases:
    ...    q = Quantity(case)
    ...    print(f'{case:>7} -> {q:p}')
          3 -> 3
         3. -> 3
        3.0 -> 3
        3.1 -> 3.1
       3.14 -> 3.14
      3.140 -> 3.14
    3.14000 -> 3.14

И он не будет использовать электронную запись в этой ситуации:

    >>> cases = '3.14e-9 3.14 3.14e9'.split()
    >>> for case in cases:
    ...    q = Quantity(case)
    ...    print(f'{case:>7} -> {q:,p}')
    3.14e-9 -> 0
       3.14 -> 3.14
     3.14e9 -> 3,140,000,000

Альтернативой, которую вы можете предпочесть, является использование масштабных коэффициентов СИ, возможно, с единицами измерения.

    >>> cases = '3e-9 3.14e-9 3 3.14 3e9 3.14e9'.split()
    >>> for case in cases:
    ...    q = Quantity(case, 'm')
    ...    print(f'{case:>7} -> {q}')
       3e-9 -> 3 nm
    3.14e-9 -> 3.14 nm
          3 -> 3 m
       3.14 -> 3.14 m
        3e9 -> 3 Gm
     3.14e9 -> 3.14 Gm

OP хотел бы удалить лишние нули и сделать полученную строку максимально короткой.

Я считаю, что экспоненциальное форматирование% g сокращает результирующую строку для очень больших и очень малых значений. Проблема возникает для значений, которые не нуждаются в экспоненциальной записи, например 128.0, которая не является ни очень большой, ни очень маленькой.

Вот один из способов форматирования чисел в виде коротких строк, который использует экспоненциальную запись% g, только когда Decimal.normalize создает слишком длинные строки. Возможно, это не самое быстрое решение (поскольку оно использует Decimal.normalize)

def floatToString (inputValue, precision = 3):
    rc = str(Decimal(inputValue).normalize())
    if 'E' in rc or len(rc) > 5:
        rc = '{0:.{1}g}'.format(inputValue, precision)        
    return rc

inputs = [128.0, 32768.0, 65536, 65536 * 2, 31.5, 1.000, 10.0]

outputs = [floatToString(i) for i in inputs]

print(outputs)

# ['128', '32768', '65536', '1.31e+05', '31.5', '1', '10']

Для поплавка вы можете использовать это:

def format_float(num):
    return ('%i' if num == int(num) else '%s') % num

Попробуй это:

>>> format_float(1.00000)
'1'
>>> format_float(1.1234567890000000000)
'1.123456789'

Десятичное число см. Решение здесь: https://stackoverflow.com/a/42668598/5917543

"{:.5g}".format(x)

Я использую это, чтобы форматировать числа с плавающей точкой, чтобы отследить нули.

Вот ответ:

import numpy

num1 = 3.1400
num2 = 3.000
numpy.format_float_positional(num1, 3, trim='-')
numpy.format_float_positional(num2, 3, trim='-')

вывод "3.14" и "3"

trim='-' удаляет как конечные нули, так и десятичные.

Используйте% g с достаточно большой шириной, например "% .99g". Он будет печатать в фиксированной записи для любого достаточно большого числа.

РЕДАКТИРОВАТЬ: это не работает

>>> '%.99g' % 0.0000001
'9.99999999999999954748111825886258685613938723690807819366455078125e-08'

Вы можете использовать max()как это:

print(max(int(x), x))

Вы можете достичь этого наиболее питоническим способом, вот так:

python3:

"{:0.0f}".format(num)

Обработка% f, и вы должны положить

% .2f

где: .2f == .00 плавает.

Пример:

распечатать "Цена:% .2f"% цены [товар]

вывод:

Цена: 1.50