Conversion flottant en chaîne sans notation scientifique et fausse précision

si vous êtes satisfait de la précision de la notation scientifique, alors pourrions-nous simplement prendre une approche de manipulation de chaîne simple? C'est peut-être pas très intelligent, mais il semble fonctionner (passe tous les cas d'utilisation que vous avez présenté), et je pense que c'est assez compréhensible:

def float_to_str(f):
    float_string = repr(f)
    if 'e' in float_string:  # detect scientific notation
        digits, exp = float_string.split('e')
        digits = digits.replace('.', '').replace('-', '')
        exp = int(exp)
        zero_padding = '0' * (abs(int(exp)) - 1)  # minus 1 for decimal point in the sci notation
        sign = '-' if f < 0 else ''
        if exp > 0:
            float_string = '{}{}{}.0'.format(sign, digits, zero_padding)
        else:
            float_string = '{}0.{}{}'.format(sign, zero_padding, digits)
    return float_string

n = 0.000000054321654321
assert(float_to_str(n) == '0.000000054321654321')

n = 0.00000005
assert(float_to_str(n) == '0.00000005')

n = 420000000000000000.0
assert(float_to_str(n) == '420000000000000000.0')

n = 4.5678e-5
assert(float_to_str(n) == '0.000045678')

n = 1.1
assert(float_to_str(n) == '1.1')

n = -4.5678e-5
assert(float_to_str(n) == '-0.000045678')

Performances:

j'avais peur que cette approche soit trop lente, alors j'ai couru timeit et comparé à la solution de contextes décimaux de L'OP. Il apparaît la chaîne la manipulation est en fait un peu plus rapide. Modifier: il semble être seulement beaucoup plus rapide en Python 2. Dans Python 3, les résultats étaient similaires, mais avec l'approche décimale légèrement plus rapide.

Résultat:

• Python 2: à l'aide de ctx.create_decimal():2.43655490875

• Python 2: à l'aide de la manipulation de la chaîne: 0.305557966232

• Python 3: à l'aide de ctx.create_decimal(): 0.19519368198234588

• Python 3: utilisation de la manipulation de la chaîne: 0.2661344590014778

voici le code de synchronisation:

from timeit import timeit

CODE_TO_TIME = '''
float_to_str(0.000000054321654321)
float_to_str(0.00000005)
float_to_str(420000000000000000.0)
float_to_str(4.5678e-5)
float_to_str(1.1)
float_to_str(-0.000045678)
'''
SETUP_1 = '''
import decimal

# create a new context for this task
ctx = decimal.Context()

# 20 digits should be enough for everyone :D
ctx.prec = 20

def float_to_str(f):
    """
    Convert the given float to a string,
    without resorting to scientific notation
    """
    d1 = ctx.create_decimal(repr(f))
    return format(d1, 'f')
'''
SETUP_2 = '''
def float_to_str(f):
    float_string = repr(f)
    if 'e' in float_string:  # detect scientific notation
        digits, exp = float_string.split('e')
        digits = digits.replace('.', '').replace('-', '')
        exp = int(exp)
        zero_padding = '0' * (abs(int(exp)) - 1)  # minus 1 for decimal point in the sci notation
        sign = '-' if f < 0 else ''
        if exp > 0:
            float_string = '{}{}{}.0'.format(sign, digits, zero_padding)
        else:
            float_string = '{}0.{}{}'.format(sign, zero_padding, digits)
    return float_string
'''

print(timeit(CODE_TO_TIME, setup=SETUP_1, number=10000))
print(timeit(CODE_TO_TIME, setup=SETUP_2, number=10000))

Si vous êtes prêt à perdre votre précision arbitraire en appelant str() sur le nombre à virgule, puis c'est le chemin à parcourir:

import decimal

def float_to_string(number, precision=20):
    return '{0:.{prec}f}'.format(
        decimal.Context(prec=100).create_decimal(str(number)),
        prec=precision,
    ).rstrip('0').rstrip('.') or '0'

il n'inclut pas les variables globales et vous permet de choisir vous-même la précision. La précision décimale 100 est choisi comme limite supérieure pour str(float) longueur. La suprématie réelle est beaucoup plus basse. or '0' la partie est pour la situation avec de petits nombres et la précision zéro.

notez qu'il a toujours son conséquences:

>> float_to_string(0.10101010101010101010101010101)
'0.10101010101'

Sinon, si la précision est importante, format c'est très bien:

import decimal

def float_to_string(number, precision=20):
    return '{0:.{prec}f}'.format(
        number, prec=precision,
    ).rstrip('0').rstrip('.') or '0'

il ne manque pas la précision perdue en appelant str(f). or

>> float_to_string(0.1, precision=10)
'0.1'
>> float_to_string(0.1)
'0.10000000000000000555'
>>float_to_string(0.1, precision=40)
'0.1000000000000000055511151231257827021182'

>>float_to_string(4.5678e-5)
'0.000045678'

>>float_to_string(4.5678e-5, precision=1)
'0'

en tout cas, les décimales maximum sont limitées, puisque le float le type lui-même a ses limites et ne peut pas exprimer des flotteurs vraiment longs:

>> float_to_string(0.1, precision=10000)
'0.1000000000000000055511151231257827021181583404541015625'

de plus, les nombres entiers sont formatés tels quels.

>> float_to_string(100)
'100'

question intéressante, pour ajouter un peu plus de contenu à la question, voici un petit test comparant les sorties de @Antti Haapala et @Harold solutions:

import decimal
import math

ctx = decimal.Context()


def f1(number, prec=20):
    ctx.prec = prec
    return format(ctx.create_decimal(str(number)), 'f')


def f2(number, prec=20):
    return '{0:.{prec}f}'.format(
        number, prec=prec,
    ).rstrip('0').rstrip('.')

k = 2*8

for i in range(-2**8,2**8):
    if i<0:
        value = -k*math.sqrt(math.sqrt(-i))
    else:
        value = k*math.sqrt(math.sqrt(i))

    value_s = '{0:.{prec}E}'.format(value, prec=10)

    n = 10

    print ' | '.join([str(value), value_s])
    for f in [f1, f2]:
        test = [f(value, prec=p) for p in range(n)]
        print '\t{0}'.format(test)

ni l'un ni l'autre ne donne de résultats "cohérents" pour tous les cas.

• avec des Anti vous verrez des chaînes comme '-000' ou '000'
• avec Harolds vous verrez des cordes comme"

je préfère la cohérence même si je sacrifie un peu de vitesse. Cela dépend des compromis vous voulez assumer pour votre cas d'utilisation.

je pense que rstrip pouvez obtenir le travail fait.

a=5.4321654321e-08
'{0:.40f}'.format(a).rstrip("0") # float number and delete the zeros on the right
# '0.0000000543216543210000004442039220863003' # there's roundoff error though

Laissez-moi savoir si cela fonctionne pour vous.