Understanding the Python %g in string formatting, achieving Java String.format behavior

Question

In Java:

String test1 = String.format("%7.2g", 3e9);
System.out.println(test1);

This prints 3.0e+09

In Python 2.7, if I run this code

for num in [3e9, 3.1e9, 3.01e9, 3e2, 3.1e2, 3.01e2]:
   print '%7.2g %7.2f %7.2e' % (num, num, num)

I get

  3e+09 3000000000.00 3.00e+09
3.1e+09 3100000000.00 3.10e+09
  3e+09 3010000000.00 3.01e+09
  3e+02  300.00 3.00e+02
3.1e+02  310.00 3.10e+02
  3e+02  301.00 3.01e+02

Huh? It looks like the precision (.2) argument is treated totally differently in Python's %g than in Python's %f, Python's %e, or Java's %g. Here's the doc (my emphasis):

General format. For a given precision p >= 1, this rounds the number to p significant digits and then formats the result in either fixed-point format or in scientific notation, depending on its magnitude.

The precise rules are as follows: suppose that the result formatted with presentation type 'e' and precision p-1 would have exponent exp. Then if -4 <= exp < p, the number is formatted with presentation type 'f' and precision p-1-exp. Otherwise, the number is formatted with presentation type 'e' and precision p-1. In both cases insignificant trailing zeros are removed from the significand, and the decimal point is also removed if there are no remaining digits following it.

Positive and negative infinity, positive and negative zero, and nans, are formatted as inf, -inf, 0, -0 and nan respectively, regardless of the precision.

A precision of 0 is treated as equivalent to a precision of 1. The default precision is 6.

WTF? Is there any way to prevent those trailing zeros from being removed? The whole point of string formatting is to achieve some consistency, e.g. for text alignment.

Is there any way to get the Java behavior (essentially the number of significant digits to the right of the decimal point) without having to rewrite the whole thing from scratch?

Mike Müller · Accepted Answer · 2017-01-25 06:20:49Z

11

With the format method, you can do something like this:

for num in [3e9, 3.1e9, 3.01e9, 3e2, 3.1e2, 3.01e2]:
    print ('{n:7.2{c}} {n:7.2f} {n:7.2e}'.format(n=num, c='e' if num > 1e4 else 'f'))

Output:

3.00e+09 3000000000.00 3.00e+09
3.10e+09 3100000000.00 3.10e+09
3.01e+09 3010000000.00 3.01e+09
 300.00  300.00 3.00e+02
 310.00  310.00 3.10e+02
 301.00  301.00 3.01e+02

There are two parts to it that might not be so well known.

1. Parametrizing the string formatting

In addition to simple formatting:

>>> '{}'.format(3.5)
'3.5'

and formatting with more detailed specification of the result:

>>> '{:5.2f}'.format(3.5)
' 3.50'

you can use keyword arguments in formatthat you can access in the string :

>>> '{num:5.2f}'.format(num=3.5)
' 3.50'

You can use these also for the format specification itself:

>>> '{:5.{deci}f}'.format(3.5, deci=3)
'3.500'

2. The `if` expression

In addition to the if statement there is an if expression, a.k.a. ternary operator.

So, this expression:

a = 1
b = 2
res = 10 if a < b else 20

is equivalent to this statement:

if a < b:
    res = 10
else:
    res= 20

Putting both together yields something like this:

'{num:7.2{c}}'.format(num=num, c='e' if num > 1e4 else 'f')

edited Jan 25, 2017 at 6:20

answered Jan 24, 2017 at 23:37

Mike Müller

86k21 gold badges174 silver badges165 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Jason S Over a year ago

huh... interesting! I think once I grok your answer I will accept it.

Mike Müller Over a year ago

Added some explanation for facilitate the grokking. ;)

Jason S Over a year ago

hmmmm... oh, so you're just choosing %7.2e vs %7.2f depending on the magnitude of num (you need abs by the way). That won't do it, there's a fundamental difference here between the languages' string formatting logic.

mata · Accepted Answer · 2017-01-25 14:59:31Z

The formatting that python does is more consistent with C's printf style formatting, which also drops trailing zeros for the g conversion. Since python's reference implementation is in C, why should it be consistent with Java in this case?

When using the % operator for string formatting, the relevant documentation is String Formatting Operations, which has some differences to the one you linked to, notably that it allows the # alternate form for g:

The alternate form causes the result to always contain a decimal point, and trailing zeroes are not removed as they would otherwise be.

The precision determines the number of significant digits before and after the decimal point and defaults to 6.

So in your case:

>>> "%#7.2g" % 3e9
3.0e+09

This is different from what is allowed by str.format(), where # is used to enable prefixes for binary, octal or hexadecimal output (at least in python2, this was changed in python3).

Collectives™ on Stack Overflow

Understanding the Python %g in string formatting, achieving Java String.format behavior

2 Answers 2

1. Parametrizing the string formatting

2. The `if` expression

3 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1. Parametrizing the string formatting

2. The if expression

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related

2. The `if` expression