Come sopprimere la notazione scientifica durante la stampa di valori float?

Ecco il mio codice:

x = 1.0
y = 100000.0    
print x/y

Il mio quoziente viene visualizzato come 1.00000e-05.

C'è un modo per sopprimere la notazione scientifica e farla visualizzare come 0.00001? Userò il risultato come una stringa.

'%f' % (x/y)

ma devi gestire tu stesso la precisione. per esempio,

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

visualizzerà solo zeri.
i dettagli sono nei documenti

O per Python 3 la vecchia formattazione equivalente o la formattazione di stile più recente

Usando la versione più recente ''.format(ricorda anche di specificare quante cifre dopo .che desideri visualizzare, questo dipende da quanto è piccolo il numero mobile). Vedi questo esempio:

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

come mostrato sopra, il valore predefinito è di 6 cifre! Questo non è utile per il nostro esempio, quindi potremmo usare qualcosa del genere:

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

Aggiornare

A partire da Python 3.6, questo può essere semplificato con la nuova stringa formattata letterale , come segue:

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

Con le versioni più recenti di Python (2.6 e successive), puoi usare ''.format()per realizzare ciò che suggeriva @SilentGhost:

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

Un'altra opzione, se si utilizzano i panda e si desidera sopprimere la notazione scientifica per tutti i float, è regolare le opzioni dei panda.

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

La maggior parte delle risposte sopra richiede di specificare la precisione. Ma cosa succede se si desidera visualizzare i float in questo modo, senza zero inutili:

1
0.1
0.01
0.001
0.0001
0.00001
0.000001
0.000000000001

numpy ha una risposta: np.format_float_positional

import numpy as np

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

Questo funzionerà per qualsiasi esponente:

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

Questo sta usando la risposta del Capitano Cucumber , ma con 2 aggiunte.

1) consentendo alla funzione di ottenere numeri di notazione non scientifici e di restituirli così come sono (in modo da poter inserire un sacco di input che alcuni dei numeri sono 0,00003123 vs 3,123e-05 e hanno ancora il lavoro di funzione.

2) aggiunto supporto per numeri negativi. (nella funzione originale, un numero negativo finirebbe come 0,0000-108904 da -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

Oltre alla risposta di SG, puoi anche usare il modulo Decimale:

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

# x is a string '0.0001'

Se è un stringquindi usa il built-in floatsu di esso per fare la conversione per esempio: print( "%.5f" % float("1.43572e-03")) answer:0.00143572

Poiché questo è il miglior risultato su Google, posterò qui dopo non aver trovato una soluzione al mio problema. Se stai cercando di formattare il valore di visualizzazione di un oggetto float e farlo rimanere un float, non una stringa, puoi usare questa soluzione:

Creare una nuova classe che modifica la modalità di visualizzazione dei valori float.

from builtins import float
class FormattedFloat(float):

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

Puoi modificare tu stesso la precisione modificando i valori interi in {:f}

Usando 3.6.4, stavo avendo un problema simile che casualmente, un numero nel file di output sarebbe stato formattato con notazione scientifica quando usavo questo:

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

Tutto quello che dovevo fare per sistemarlo era aggiungere 'f':

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

A partire da 3.6 (probabilmente funziona anche con 3.x leggermente più vecchi), questa è la mia soluzione:

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

Lo scopo del precisioncalcolo è quello di garantire una precisione sufficiente per evitare la notazione scientifica (la precisione predefinita è ancora 6).

L' dec_precisionargomento aggiunge ulteriore precisione da utilizzare per i punti decimali. Poiché questo utilizza il nformato, non verranno aggiunti zeri insignificanti (a differenza dei fformati). nsi occuperà anche del rendering di numeri interi già arrotondati senza un decimale.

nrichiede floatinput, quindi il cast.