Mise en forme des flotteurs en Python sans les zéros à droite

Vous pouvez utiliser %g de réaliser ceci:

'%g'%(3.140)

ou, pour la version 2.6 de Python ou mieux:

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

De la docs pour format: g causes (entre autres choses)

insignifiant zéros [à]
retiré de la significande, et la
point décimal est également supprimé si il y
ne reste plus de chiffres après elle.

Après avoir examiné les réponses à plusieurs questions similaires, ce qui semble être la meilleure solution pour moi:

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

Mon raisonnement:

%g ne pas se débarrasser de la notation scientifique.

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

15 décimales semble à éviter un comportement étrange et a beaucoup de précision pour mes besoins.

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

Je pourrais avoir utilisé format(inputValue, '.15f'). au lieu de '%.15f' % inputValue, mais qui est un peu plus lent (~30%).

Je pourrais avoir utilisé Decimal(inputValue).normalize(), mais cela a quelques questions. Pour l'un, il est BEAUCOUP plus lent (~11x). J'ai aussi trouvé que, même si elle est assez grande précision, il souffre encore de la perte de précision due lors de l'utilisation de normalize().

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

Plus important encore, je serais encore la conversion de Decimal à partir d'un float qui peut faire de vous retrouver avec quelque chose d'autre que le numéro que vous avez mis là-dedans. Je pense que Decimal fonctionne mieux lorsque le calcul reste dans Decimal et la Decimal est initialisé avec une chaîne.

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

Je suis sûr que la question de précision de Decimal.normalize() peut être ajusté à ce qui est nécessaire à l'aide de paramètres de contexte, mais compte tenu de la déjà de la vitesse lente et n'ayant pas besoin de ridicule, de précision et le fait que je serais toujours la conversion à partir d'un flotteur et de perdre la précision de toute façon, je ne pense pas qu'il a été vaut la peine de poursuivre.

Je ne suis pas concerné par la possible "-0" résultat depuis -0.0 est valide d'un nombre à virgule flottante, et qui serait probablement l'une des rares de toute façon, mais puisque vous ne mentionnez que vous voulez garder la chaîne la plus courte possible, vous pouvez toujours utiliser un conditionnel à très peu de vitesse supplémentaire des coûts.

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

Vous pouvez simplement utiliser le format() pour obtenir ceci:

format(3.140, '.10g') où 10 est la précision que vous voulez.

Alors que le formatage est probable que la plupart des Pythonic, voici une solution alternative à l'aide de la more_itertools.rstrip outil.

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"

Le nombre est converti en une chaîne de caractères, qui est dépouillé de caractères de fin qui répondent à un prédicat. La définition de la fonction fmt n'est pas nécessaire, mais il est utilisé ici pour tester affirmations, qui passent toutes. Remarque: il fonctionne sur la chaîne des entrées et accepte facultatif prédicats.

Voir aussi les détails sur ce bibliothèque tierce, more_itertools.

OP souhaitez supprimer superflouous zéros et de rendre la chaîne plus courte possible.

Je trouve le %g exponentielle mise en forme raccourcit la chaîne résultante pour les très grandes et très petites valeurs. Le problème vient de valeurs qui n'ont pas besoin de notation exponentielle, comme 128.0, qui n'est ni très grand ou très petit.

Ici est une façon de forme de nombres en chaînes courtes qui utilise %g de notation exponentielle seulement lorsque les Décimales.normaliser crée des chaînes de caractères qui sont trop longues. Cela pourrait ne pas être la solution la plus rapide (car il ne fait Décimal.normaliser)

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

Utiliser %g avec une assez grande largeur, par exemple '%.99g'.
Il permet d'imprimer en notation à virgule fixe pour toute raisonnablement grand nombre.

EDIT: ça ne fonctionne pas

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

De manutention %f et vous devez les mettre

%.2f

où:
.2f == .00 flotteurs.

Exemple:

print "Prix: %.2f" % prix[produit]

de sortie:

Prix: 1.50