¿Cómo suprimir la notación científica al imprimir valores flotantes?

Aquí está mi código:

x = 1.0
y = 100000.0    
print x/y

Mi cociente se muestra como 1.00000e-05.

¿Hay alguna forma de suprimir la notación científica y hacer que se muestre como 0.00001? Voy a usar el resultado como una cadena.

'%f' % (x/y)

pero necesitas manejar la precisión tú mismo. p.ej,

'%f' % (1/10**8)

solo mostrará ceros.
los detalles están en los documentos

O para Python 3 el formato antiguo equivalente o el formato de estilo más nuevo

Usando la versión más nueva ''.format(también recuerde especificar cuántos dígitos después de la .que desea mostrar, esto depende de qué tan pequeño sea el número flotante). Ver este ejemplo:

>>> a = -7.1855143557448603e-17
>>> '{:f}'.format(a)
'-0.000000'

como se muestra arriba, ¡el valor predeterminado es de 6 dígitos! Esto no es útil para nuestro ejemplo de caso, por lo que podríamos usar algo como esto:

>>> '{:.20f}'.format(a)
'-0.00000000000000007186'

Actualizar

A partir de Python 3.6, esto se puede simplificar con el nuevo literal de cadena formateado , de la siguiente manera:

>>> f'{a:.20f}'
'-0.00000000000000007186'

Con las versiones más recientes de Python (2.6 y posteriores), puede usar ''.format()para lograr lo que @SilentGhost sugirió:

'{0:f}'.format(x/y)

Otra opción, si está utilizando pandas y desea suprimir la notación científica para todos los flotadores, es ajustar las opciones de los pandas.

import pandas as pd
pd.options.display.float_format = '{:.2f}'.format

La mayoría de las respuestas anteriores requieren que especifique precisión. Pero, ¿qué pasa si desea mostrar flotantes como este, sin ceros innecesarios:

1
0.1
0.01
0.001
0.0001
0.00001
0.000001
0.000000000001

numpy tiene una respuesta: np.format_float_positional

import numpy as np

def format_float(num):
    return np.format_float_positional(num, trim='-')

Esto funcionará para cualquier exponente:

def getExpandedScientificNotation(flt):
    str_vals = str(flt).split('e')
    coef = float(str_vals[0])
    exp = int(str_vals[1])
    return_val = ''
    if int(exp) > 0:
        return_val += str(coef).replace('.', '')
        return_val += ''.join(['0' for _ in range(0, abs(exp - len(str(coef).split('.')[1])))])
    elif int(exp) < 0:
        return_val += '0.'
        return_val += ''.join(['0' for _ in range(0, abs(exp) - 1)])
        return_val += str(coef).replace('.', '')
    return return_val

Esto está usando la respuesta del Capitán Pepino , pero con 2 adiciones.

1) permitir que la función obtenga números de notación no científica y simplemente devolverlos como están (para que pueda arrojar una gran cantidad de información de que algunos de los números son 0.00003123 vs 3.123e-05 y todavía tienen función de trabajo.

2) soporte agregado para números negativos. (en función original, un número negativo terminaría como 0.0000-108904 desde -1.08904e-05)

def getExpandedScientificNotation(flt):
    was_neg = False
    if not ("e" in flt):
        return flt
    if flt.startswith('-'):
        flt = flt[1:]
        was_neg = True 
    str_vals = str(flt).split('e')
    coef = float(str_vals[0])
    exp = int(str_vals[1])
    return_val = ''
    if int(exp) > 0:
        return_val += str(coef).replace('.', '')
        return_val += ''.join(['0' for _ in range(0, abs(exp - len(str(coef).split('.')[1])))])
    elif int(exp) < 0:
        return_val += '0.'
        return_val += ''.join(['0' for _ in range(0, abs(exp) - 1)])
        return_val += str(coef).replace('.', '')
    if was_neg:
        return_val='-'+return_val
    return return_val

Además de la respuesta de SG, también puede usar el módulo Decimal:

from decimal import Decimal
x = str(Decimal(1) / Decimal(10000))

# x is a string '0.0001'

Si es un, stringentonces use el incorporado floatpara hacer la conversión, por ejemplo: print( "%.5f" % float("1.43572e-03")) respuesta:0.00143572

Como este es el mejor resultado en Google, publicaré aquí después de no encontrar una solución para mi problema. Si desea formatear el valor de visualización de un objeto flotante y mantenerlo como flotante, no como una cadena, puede usar esta solución:

Cree una nueva clase que modifique la forma en que se muestran los valores flotantes.

from builtins import float
class FormattedFloat(float):

    def __str__(self):
        return "{:.10f}".format(self).rstrip('0')

Puede modificar la precisión usted mismo cambiando los valores enteros en {:f}

Usando 3.6.4, estaba teniendo un problema similar que aleatoriamente, un número en el archivo de salida se formateará con notación científica al usar esto:

fout.write('someFloats: {0:0.8},{1:0.8},{2:0.8}'.format(someFloat[0], someFloat[1], someFloat[2]))

Todo lo que tuve que hacer para solucionarlo fue agregar 'f':

fout.write('someFloats: {0:0.8f},{1:0.8f},{2:0.8f}'.format(someFloat[0], someFloat[1], someFloat[2]))

A partir de 3.6 (probablemente también funciona con versiones 3.x ligeramente más antiguas), esta es mi solución:

import locale
locale.setlocale(locale.LC_ALL, '')

def number_format(n, dec_precision=4):
    precision = len(str(round(n))) + dec_precision
    return format(float(n), f'.{precision}n')

El propósito de precision cálculo es garantizar que tengamos suficiente precisión para mantenernos fuera de la notación científica (la precisión predeterminada sigue siendo 6).

El dec_precisionargumento agrega precisión adicional para usar con puntos decimales. Como esto hace uso del nformato, no se agregarán ceros insignificantes (a diferencia de los fformatos).ntambién se encargará de representar enteros redondos sin un decimal.

nrequiere floatentrada, por lo tanto, el elenco.