Come posso formattare un float in modo che non contenga zeri finali? In altre parole, voglio che la stringa risultante sia la più corta possibile.

Per esempio:

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

Io, lo farei ('%f' % x).rstrip('0').rstrip('.')- garantisce la formattazione in virgola fissa piuttosto che la notazione scientifica, ecc. Ecc. Sì, non così lucido ed elegante come %g, ma funziona (e non so come forzare %ga non usare mai la notazione scientifica; -).

È possibile utilizzare %gper raggiungere questo obiettivo:

'%g'%(3.140)

oppure, per Python 2.6 o superiore:

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

Dai documenti performat : gcause (tra le altre cose)

zeri finali insignificanti [da] rimuovere dal significato e anche il punto decimale viene rimosso se non ci sono cifre rimanenti che lo seguono.

Che ne dici di provare l'approccio più semplice e probabilmente più efficace? Il metodo normalize () rimuove tutti gli zeri finali più a destra.

from decimal import Decimal

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

Funziona in Python 2 e Python 3 .

- Aggiornato -

L'unico problema, come ha sottolineato @ BobStein-VisiBone, è che numeri come 10, 100, 1000 ... verranno visualizzati in rappresentazione esponenziale. Questo può essere facilmente risolto utilizzando invece la seguente funzione:

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

Dopo aver esaminato le risposte a diverse domande simili, questa sembra essere la soluzione migliore per me:

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

Il mio ragionamento:

%g non si libera della notazione scientifica.

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

15 decimali sembrano evitare comportamenti strani e hanno molta precisione per le mie esigenze.

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

Avrei potuto usare format(inputValue, '.15f').invece di '%.15f' % inputValue, ma è un po 'più lento (~ 30%).

Avrei potuto usare Decimal(inputValue).normalize(), ma questo ha anche alcuni problemi. Per uno, è MOLTO più lento (~ 11x). Ho anche scoperto che sebbene abbia una precisione abbastanza grande, soffre comunque di una perdita di precisione durante l'utilizzo normalize().

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

Ancora più importante, mi convertirei ancora Decimalda un floatche può farti finire con qualcosa di diverso dal numero che hai inserito. Penso che Decimalfunzioni meglio quando l'aritmetica rimane Decimale Decimalviene inizializzata con una stringa.

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

Sono sicuro che il problema della precisione di Decimal.normalize()può essere adattato a ciò che è necessario utilizzando le impostazioni di contesto, ma considerando la già bassa velocità e non avendo bisogno di una precisione ridicola e il fatto che mi sarei comunque convertito da un galleggiante e perdere comunque la precisione, non l'ho fatto penso che valga la pena perseguire.

Non mi preoccupo del possibile risultato "-0" poiché -0,0 è un numero in virgola mobile valido e probabilmente sarebbe comunque un evento raro, ma poiché hai menzionato che vuoi mantenere il risultato della stringa il più breve possibile, tu potrebbe sempre utilizzare un ulteriore condizionale a costi di velocità extra molto ridotti.

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

Ecco una soluzione che ha funzionato per me. È una miscela della soluzione di PolyMesh e l'uso della nuova .format() sintassi .

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

Uscita :

3
3
3
3.1
3.14
3.14

Puoi semplicemente usare format () per raggiungere questo obiettivo:

format(3.140, '.10g') dove 10 è la precisione che desideri.

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

Mentre la formattazione è probabilmente la maggior parte del modo Pythonic, ecco una soluzione alternativa che utilizza lo more_itertools.rstripstrumento.

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"

Il numero viene convertito in una stringa, che è spogliata di caratteri finali che soddisfano un predicato. La definizione della funzionefmt non è richiesta, ma viene utilizzata qui per testare le asserzioni, che passano tutte. Nota: funziona su input di stringa e accetta predicati opzionali.

Vedi anche i dettagli su questa libreria di terze parti, more_itertools.

Se riesci a vivere con 3. e 3.0 che appaiono come "3.0", un approccio molto semplice che sposta a destra gli zeri dalle rappresentazioni float:

print("%s"%3.140)

(grazie @ellimilial per aver sottolineato le eccezioni)

L'uso del pacchetto QuantiPhy è un'opzione. Normalmente QuantiPhy viene utilizzato quando si lavora con numeri con unità e fattori di scala SI, ma ha una varietà di opzioni per la formattazione dei numeri.

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

E non utilizzerà la notazione elettronica in questa situazione:

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

Un'alternativa che potresti preferire è usare i fattori di scala SI, forse con le unità.

    >>> 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 vorrebbe rimuovere gli zeri superflui e rendere la stringa risultante il più corta possibile.

Trovo che la formattazione esponenziale% g accorcia la stringa risultante per valori molto grandi e molto piccoli. Il problema si presenta con valori che non necessitano di notazione esponenziale, come 128.0, che non è né molto grande né molto piccolo.

Ecco un modo per formattare i numeri come stringhe brevi che utilizza la notazione esponenziale% g solo quando Decimal.normalize crea stringhe troppo lunghe. Questa potrebbe non essere la soluzione più veloce (poiché utilizza 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']

Per float puoi usare questo:

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

Provalo:

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

Per Decimal vedi la soluzione qui: https://stackoverflow.com/a/42668598/5917543

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

Lo uso per formattare i float per tracciare gli zeri.

Ecco la risposta:

import numpy

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

uscita "3.14" e "3"

trim='-' rimuove sia gli zero finali sia i decimali.

Usa% g con una larghezza sufficiente, ad esempio '% .99g'. Stamperà in notazione a virgola fissa per qualsiasi numero ragionevolmente grande.

EDIT: non funziona

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

Puoi usare max()così:

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

Puoi raggiungerlo nel modo più pitonico del genere:

python3:

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

Gestisci% f e dovresti metterlo

% .2f

, dove: .2f == .00 float.

Esempio:

stampa "Prezzo:% .2f"% prezzi [prodotto]

produzione:

Prezzo: 1,50