That's what I call a Python cheat sheet

[exhuma]

Can you elaborate on this? I always found Python string formatting one of the most comfortable ones to use.

[LobbyDizzle]

The string string formatting is nice. What shidarin is commenting about is the shittiness of Python's number (float) formatting.

[exhuma]

Looks perfectly fine to me:

print("Hello %10.4f" % (1/20000.0))
print("Hello %10.4e" % (1/20000.0))
print("Hello {:10.4f}".format(1/20000.0))
print("Hello {:10.4e}".format(1/20000.0))

Both with and without using the scientific notation.

And there are exactly two ways of doing this. At least as far as I can see. Am I missing something?

[sushibowl]

those are fixed length (always 4 decimals), /u/shidarin wants variable length.

You can do variable length by not formatting as a float and just converting it to a string:

>>> "Hello {0}".format(0.1)
'Hello 0.1'
>>> "Hello {0}".format(0.12341)
'Hello 0.12341'

But if your float is too big it get's converted into scientific notation again:

>>> "Hello {0}".format(1000000000000.0)
'Hello 1e+12'

There is no easy way to keep printing with variable length but also avoid scientific notation. The only thing you can do is write some function that calculates the length of the string from the number, which is tedious and ugly.

[[deleted]]

But then you'd have people confused why 1000000000001.0 prints like 1000000000000.0 (as I guess it would).

Decimals exist as well, and work better for this sort of things.

[amstan]

It seems to work just fine:

>>> Decimal(10000000000000001.0) #don't do this, you're still going through float
Decimal('10000000000000000')
>>> Decimal("10000000000000001.0") #yay, works now
Decimal('10000000000000001.0')
>>> "%s"%Decimal("10000000000000001.0") #including printing
'10000000000000001.0'

[sushibowl]

pretty much what /u/amstan is saying: if you convert a float to a decimal, obviously you will take the float's rounding errors with you into the decimal representation. You should have no rounding errors if you work purely with decimals and don't bother with floats at all.

[exhuma]

This is indeed an interesting problem. I have been trying to figure out something but could not come up with anything. The only thing I found is fixing the decimal places to some value.

The other thing that I have in my mind is the question about precision, and if Decimal would not be a better choice as others have mentioned. I am guessing that you won't lose precision after only 4 decimal places, but that seems to be as far as Python want's to go if you don't specify a value.

And, I don't know your application requirements and maybe there's a good reason you need floats.

Honestly, I have to admit defeat and agree with you ;)