python human readable large numbers [duplicate]

This question already has answ开发者_运维问答ers here: Get human readable version of file size? (25 answers) Verbally format a number in Python (3 answers) Closed 9 years ago.

The community reviewed whether to reopen this question 4 months ago and left it closed:

Not suitable for this site We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.

is there a python library that would make numbers such as this more human readable

$187,280,840,422,780

edited: for example iw ant the output of this to be 187 Trillion not just comma separated. So I want output to be trillions, millions, billions etc

---

As I understand it, you only want the 'most significant' part. To do so, use floor(log10(abs(n))) to get number of digits and then go from there. Something like this, maybe:

import math

millnames = ['',' Thousand',' Million',' Billion',' Trillion']

def millify(n):
    n = float(n)
    millidx = max(0,min(len(millnames)-1,
                        int(math.floor(0 if n == 0 else math.log10(abs(n))/3))))

    return '{:.0f}{}'.format(n / 10**(3 * millidx), millnames[millidx])

Running the above function for a bunch of different numbers:

for n in (1.23456789 * 10**r for r in range(-2, 19, 1)):
    print('%20.1f: %20s' % (n,millify(n)))
                 0.0:                    0
                 0.1:                    0
                 1.2:                    1
                12.3:                   12
               123.5:                  123
              1234.6:           1 Thousand
             12345.7:          12 Thousand
            123456.8:         123 Thousand
           1234567.9:            1 Million
          12345678.9:           12 Million
         123456789.0:          123 Million
        1234567890.0:            1 Billion
       12345678900.0:           12 Billion
      123456789000.0:          123 Billion
     1234567890000.0:           1 Trillion
    12345678900000.0:          12 Trillion
   123456789000000.0:         123 Trillion
  1234567890000000.0:        1235 Trillion
 12345678899999998.0:       12346 Trillion
123456788999999984.0:      123457 Trillion
1234567890000000000.0:     1234568 Trillion

---

With Python2.7+ or v3 you just use the "," option in your string formatting - see PEP 378: Format Specifier for Thousands Separator for more info:

>>> "{:,}".format(100000000)
'100,000,000'

With Python3.6+ you can also use the "_" format - see PEP 515 for details:

>>> "{:_}".format(100000000)
'100_000_000'

or you can use a similar syntax with f-strings:

>>> number = 100000000
>>>f"{number:,}"
'100,000,000'

So I don't have to squint while reading big numbers, I have the 2.7 version of the code wrapped up in a shell function:

human_readable_numbers () {
    python2.7 -c "print('{:,}').format($1)"
}

Lastly, if for some reason you must work with code from Python versions 2.6 or earlier, you can solve the problem using the locale standard library module:

import locale
locale.setlocale(locale.LC_ALL, 'en_US')
locale.format('%d', 2**32, grouping=True)   # returns '4,294,967,296'

---

That number seems pretty human-readable to me. An unfriendly number would be 187289840422780.00. To add commas, you could create your own function or search for one (I found this):

import re

def comma_me(amount):
    orig = amount
    new = re.sub("^(-?\d+)(\d{3})", '\g<1>,\g<2>', amount)
    if orig == new:
        return new
    else:
        return comma_me(new)

f = 12345678
print comma_me(`f`)
Output: 12,345,678

If you want to round a number to make it more readable, there is a python function for that: round().

You could move even further away from the actual data and say "A very high amount" or "Above 100 trillion" using a function that would return a different value based on your programmed benchmarks.

---

From here:

def commify(n):
    if n is None: return None
    if type(n) is StringType:
        sepdec = localenv['mon_decimal_point']
    else:
        #if n is python float number we use everytime the dot
        sepdec = '.'
    n = str(n)
    if sepdec in n:
        dollars, cents = n.split(sepdec)
    else:
        dollars, cents = n, None

    r = []
    for i, c in enumerate(reversed(str(dollars))):
        if i and (not (i % 3)):
            r.insert(0, localenv['mon_thousands_sep'])
        r.insert(0, c)
    out = ''.join(r)
    if cents:
        out += localenv['mon_decimal_point'] + cents
    return out

---

If by 'readable' you mean 'words'; here's a good solution that you can adapt.

http://www.andrew-hoyer.com/experiments/numbers