¿Cómo puedo formatear un flotante para que no contenga ceros finales? En otras palabras, quiero que la cadena resultante sea lo más corta posible.

Por ejemplo:

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

Yo, lo haría ('%f' % x).rstrip('0').rstrip('.'), garantiza el formato de punto fijo en lugar de la notación científica, etc. Sí, no es tan elegante y elegante como %g, pero funciona (y no sé cómo forzar %ga nunca usar la notación científica; -).

Podrías usar %gpara lograr esto:

'%g'%(3.140)

o, para Python 2.6 o superior:

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

De los documentos paraformat : gcausas (entre otras cosas)

los ceros finales insignificantes [se eliminarán] del significado, y el punto decimal también se eliminará si no quedan dígitos que lo sigan.

¿Qué hay de intentar el enfoque más fácil y probablemente más efectivo? El método normalize () elimina todos los ceros finales más a la derecha.

from decimal import Decimal

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

Funciona en Python 2 y Python 3 .

-- Actualizado --

El único problema, como señaló @ BobStein-VisiBone, es que los números como 10, 100, 1000 ... se mostrarán en representación exponencial. Esto se puede solucionar fácilmente utilizando la siguiente función:

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

Después de buscar respuestas a varias preguntas similares, esta parece ser la mejor solución para mí:

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

Mi razonamiento:

%g no se deshace de la notación científica.

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

15 decimales parecen evitar comportamientos extraños y tienen mucha precisión para mis necesidades.

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

Podría haber usado en format(inputValue, '.15f').lugar de '%.15f' % inputValue, pero eso es un poco más lento (~ 30%).

Podría haberlo usado Decimal(inputValue).normalize(), pero esto también tiene algunos problemas. Por un lado, es MUCHO más lento (~ 11x). También descubrí que aunque tiene una precisión bastante grande, aún sufre pérdida de precisión cuando se usa normalize().

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

Lo que es más importante, todavía me convertiría Decimalde una floatque puede hacer que termines con algo más que el número que pones allí. Creo que Decimalfunciona mejor cuando la aritmética permanece Decimaly Decimalse inicializa con una cadena.

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

Estoy seguro de que el problema de precisión Decimal.normalize()se puede ajustar a lo que se necesita usando la configuración de contexto, pero teniendo en cuenta la velocidad ya lenta y no necesita una precisión ridícula y el hecho de que todavía estaría convirtiendo de un flotador y perdiendo precisión de todos modos, no lo hice No creo que valiera la pena perseguirlo.

No estoy preocupado con el posible resultado "-0" ya que -0.0 es un número de coma flotante válido y probablemente sea una ocurrencia rara de todos modos, pero como mencionó que desea mantener el resultado de la cadena lo más corto posible, usted siempre podría usar un condicional adicional a muy bajo costo de velocidad adicional.

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

Aquí hay una solución que funcionó para mí. Es una combinación de la solución de PolyMesh y el uso de la nueva .format() sintaxis .

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

Salida :

3
3
3
3.1
3.14
3.14

Simplemente puede usar format () para lograr esto:

format(3.140, '.10g') donde 10 es la precisión que quieres.

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

Si bien es probable que el formato sea la forma más pitónica, aquí hay una solución alternativa que usa la more_itertools.rstripherramienta.

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"

El número se convierte en una cadena, que se despoja de los caracteres finales que satisfacen un predicado. La definición de la función fmtno es necesaria, pero se usa aquí para probar aserciones, que todas pasan. Nota: funciona en entradas de cadena y acepta predicados opcionales.

Ver también los detalles en esta biblioteca de terceros, more_itertools.

Si puede vivir con 3. y 3.0 que aparecen como "3.0", un enfoque muy simple que elimina los ceros a la derecha de las representaciones flotantes:

print("%s"%3.140)

(gracias @ellimilial por señalar las excepciones)

Usar el paquete QuantiPhy es una opción. Normalmente, QuantiPhy se usa cuando se trabaja con números con unidades y factores de escala SI, pero tiene una variedad de buenas opciones de formato de números.

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

Y no usará la notación electrónica en esta situación:

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

Una alternativa que podría preferir es usar factores de escala SI, quizás con unidades.

    >>> 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 desea eliminar los ceros superfluos y hacer que la cadena resultante sea lo más corta posible.

Encuentro que el formato exponencial% g acorta la cadena resultante para valores muy grandes y muy pequeños. El problema viene para valores que no necesitan notación exponencial, como 128.0, que no es ni muy grande ni muy pequeña.

Aquí hay una forma de formatear números como cadenas cortas que usa notación exponencial% g solo cuando Decimal.normalize crea cadenas que son demasiado largas. Es posible que esta no sea la solución más rápida (ya que utiliza 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']

Para flotar, puedes usar esto:

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

Pruébalo:

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

Para Decimal, vea la solución aquí: https://stackoverflow.com/a/42668598/5917543

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

Lo uso para formatear flotadores para seguir ceros.

Aquí está la respuesta:

import numpy

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

salida "3.14" y "3"

trim='-' elimina tanto los ceros finales como el decimal.

Utilice% g con ancho suficientemente grande, por ejemplo '% .99g'. Se imprimirá en notación de punto fijo para cualquier número razonablemente grande.

EDITAR: no funciona

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

Puedes usar max()así:

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

Puede lograr eso de la manera más pitónica de esa manera:

python3:

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

Manejando% f y deberías poner

% .2f

, donde: .2f == .00 flotantes.

Ejemplo:

imprimir "Precio:% ​​.2f"% precios [producto]

salida:

Precio: 1.50