Como suprimir a notação científica ao imprimir valores flutuantes?

Aqui está o meu código:

x = 1.0
y = 100000.0    
print x/y

Meu quociente é exibido como 1.00000e-05.

Existe alguma maneira de suprimir a notação científica e torná-la exibida como 0.00001? Vou usar o resultado como uma string.

'%f' % (x/y)

mas você precisa gerenciar a precisão você mesmo. por exemplo,

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

exibirá apenas zeros.
detalhes estão nos documentos

Ou para Python 3 a formatação antiga equivalente ou a formatação de estilo mais recente

Usando a versão mais recente ''.format(lembre-se de especificar quantos dígitos após o que .você deseja exibir, isso depende de quão pequeno é o número flutuante). Veja este exemplo:

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

como mostrado acima, o padrão é 6 dígitos! Isso não é útil para o nosso exemplo de caso; portanto, poderíamos usar algo como isto:

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

Atualizar

A partir do Python 3.6, isso pode ser simplificado com a nova literal de string formatada , da seguinte maneira:

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

Com as versões mais recentes do Python (2.6 e posterior), você pode usar ''.format()para realizar o que o @SilentGhost sugeriu:

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

Outra opção, se você estiver usando pandas e quiser suprimir a notação científica para todos os carros alegóricos, é ajustar as opções de pandas.

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

A maioria das respostas acima exige que você especifique precisão. Mas e se você quiser exibir carros alegóricos como este, sem zeros desnecessários:

1
0.1
0.01
0.001
0.0001
0.00001
0.000001
0.000000000001

numpy tem uma resposta: np.format_float_positional

import numpy as np

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

Isso funcionará para qualquer expoente:

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

Isto está usando a resposta do capitão Pepino , mas com 2 adições.

1) permitir que a função obtenha números de notação não científicos e apenas retorne-os como estão (para que você possa fornecer muitas informações de que alguns dos números são 0,00003123 vs 3,123e-05 e ainda possuem funções funcionais.

2) suporte adicionado para números negativos. (na função original, um número negativo terminaria como 0,0000-108904 de -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

Além da resposta da SG, você também pode usar o módulo Decimal:

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

# x is a string '0.0001'

Se for um string, use o interno floatpara fazer a conversão, por exemplo: print( "%.5f" % float("1.43572e-03")) answer:0.00143572

Como este é o melhor resultado no Google, postarei aqui depois de não encontrar uma solução para o meu problema. Se você deseja formatar o valor de exibição de um objeto flutuante e ele permanecer flutuante - e não uma string, você pode usar esta solução:

Crie uma nova classe que modifique a maneira como os valores flutuantes são exibidos.

from builtins import float
class FormattedFloat(float):

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

Você pode modificar a precisão alterando os valores inteiros em {:f}

Usando 3.6.4, eu estava tendo um problema semelhante que, aleatoriamente, um número no arquivo de saída seria formatado com notação científica ao usar isso:

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

Tudo o que eu tive que fazer para corrigir isso foi adicionar 'f':

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

A partir da versão 3.6 (provavelmente também funciona com a versão 3.x um pouco mais antiga), esta é a minha solução:

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

O objetivo do precisioncálculo é garantir que tenhamos precisão suficiente para manter fora da notação científica (a precisão padrão ainda é 6).

O dec_precisionargumento adiciona precisão adicional a ser usada para pontos decimais. Como isso faz uso do nformato, nenhum zeros insignificante será adicionado (diferente dos fformatos). ntambém cuidará de renderizar números inteiros já redondos sem um decimal.

nrequer floatentrada, portanto, o elenco.