Reputation: 6493

Formatting long numbers as strings

What is an easy way in Python to format integers into strings representing thousands with K, and millions with M, and leaving just couple digits after comma?

I'd like to show 7436313 as 7.44M, and 2345 as 2,34K.

Is there some % string formatting operator available for that? Or that could be done only by actually dividing by 1000 in a loop and constructing result string step by step?

Upvotes: 87

Answers (15)

thebadcode

Reputation: 11

Just made a function for this:

Basic:

def format_numbers(num: int):
    digits = f"{num:,}"
    comma = digits.count(",")
    seperates = {
      "1": "K",
      "2": "M",
      "3": "B",
      "4": "T",
      "5": "Q",
      "6": "S",
      "7": "O",
      "8": "N",
    }
    seperate = seperates.get(str(comma), "N/A")
    if seperate == "N/A":
        return digits
    return f'{digits[:digits.find(",")]}{seperate}'

Advanced:

def format_numbers(num: int, max_fraction_digits: int = 1):
    digits = f"{num:,}"
    comma = digits.count(",")
    seperates = {
      "1": "K",
      "2": "M",
      "3": "B",
      "4": "T",
      "5": "Q",
      "6": "S",
      "7": "O",
      "8": "N",
    }
    seperate = seperates.get(str(comma), "N/A")
    if seperate == "N/A":
        return digits
    second = digits.split(",")[1]
    if max_fraction_digits and (p:=second[:max_fraction_digits]) != "0":
        return f'{digits[:digits.find(",")]}.{p}{seperate}'
    else:
        return f'{digits[:digits.find(",")]}{seperate}'
      

print(format_numbers(10100000)) # 10.1M
print(format_numbers(10100, 2)) # 10.1K
print(format_numbers(1700000)) # 1.7M
print(format_numbers(1_751_000_000, 2)) # 1.75B

Upvotes: 0

M.G.Poirot

Reputation: 1155

I know this is an old question but I'd like to add this one-liner:

>>> human_format = lambda num: [f'{num/10**(3*i):.0f}{k}' for i, k in enumerate(' kMGTPEZY') if num >= 10**(3*i) * 0.9995][-1]
>>> human_format(10_000)
'10k'
>>> human_format(12_345_678)
'12M'
>>> human_format(999_999)
'1M'

Upvotes: 1

fabrice houessou

Reputation: 31

def human_format(value):
   num = value
   magnitude = 0
   while abs(num) >= 1000:
      magnitude += 1
      num /= 1000.0
   result = round(value / (1000**magnitude),3)
   return '{}{}'.format(result, ['', 'K', 'M', 'B', 'T'][magnitude])

Upvotes: 0

m-schwob

Reputation: 89

Based on the comments here, I made an improved code for that. It is a little bit longer but gives solutions for more cases including small numbers (m,u,n,p).

Hope it will be helpful for someone

# print number in a readable format.
# default is up to 3 decimal digits and can be changed
# works on numbers in the range of 1e-15 to 1e 1e15 include negatives numbers
# can force the number to a specific magnitude unit
def human_format(num:float, force=None, ndigits=3):
    perfixes = ('p', 'n', 'u', 'm', '', 'K', 'M', 'G', 'T')
    one_index = perfixes.index('')
    if force:
        if force in perfixes:
            index = perfixes.index(force)
            magnitude = 3*(index - one_index)
            num = num/(10**magnitude)
        else:
            raise ValueError('force value not supported.')
    else:
        div_sum = 0
        if(abs(num) >= 1000):
            while abs(num) >= 1000:
                div_sum += 1
                num /= 1000
        else:
            while abs(num) <= 1:
                div_sum -= 1
                num *= 1000
        temp = round(num, ndigits) if ndigits else num
        if temp < 1000:
            num = temp 
        else:
            num = 1
            div_sum += 1
        index = one_index + div_sum
    return str(num).rstrip('0').rstrip('.') + perfixes[index]

tests from here and some more

# some tests
print(human_format(999)              ,' = '         , '999') 
print(human_format(999.999)          ,' = '         , '999.999') 
print(human_format(999.9999)         ,' = '         , '1K')  
print(human_format(999999)           ,' = '         , '999.999K')   
print(human_format(999499)           ,' = '         , '999.499K')   
print(human_format(9994)             ,' = '         , '9.994K')   
print(human_format(9900)             ,' = '         , '9.9K')   
print(human_format(6543165413)       ,' = '         , '6.543G')  
print(human_format(46780.9)          ,' = '         , '46.781K')  
print(human_format(0.001)            ,' = '         , '1m')   
print(human_format(0.000000999999)   ,' = '         , '999.999n')  
print(human_format(1.00394200)       ,' = '         , '1.004')   
print(human_format(0.0999)           ,' = '         , '99.9m')  
print(human_format(0.00000000999999) ,' = '         , '10n') 
print(human_format(0.0000000099995)  ,' = '         , '9.999n')  
print(human_format(0.000000009999)   ,' = '         , '9.999n') 
print(human_format(999999            ,ndigits=2)    ,' = '           , '1M')   
print(human_format(9994              ,force='')     ,' = '           , '9994K')   
print(human_format(6543165413        ,ndigits=5)    ,' = '           , '6.54317G')  
print(human_format(6543165413        ,ndigits=None) ,' = '           , '6.543165413G')  
print(human_format(7436313           ,ndigits=2)    ,' = '           , '7.44M')   
print(human_format(2344              ,ndigits=2)    ,' = '           , '2.34K')
print(human_format(34867123012.13    ,ndigits=2)    ,' = '           , '34.87G')

Upvotes: 1

John Prawyn

Reputation: 1693

Numerize library is good.

from numerize import numerize
a = numerize.numerize(1000)
print(a)
1k

Thanks @tdy for pointing this,

a = numerize.numerize(999999) 
print(a)  # 1000K 
1000K

Upvotes: 6

michauwilliam

Reputation: 845

Variable precision and no 999999 bug:

def human_format(num, round_to=2):
    magnitude = 0
    while abs(num) >= 1000:
        magnitude += 1
        num = round(num / 1000.0, round_to)
    return '{:.{}f}{}'.format(num, round_to, ['', 'K', 'M', 'G', 'T', 'P'][magnitude])

Upvotes: 10

Angus The Car

Reputation: 21

I was kind of confused by some of the stuff that other people showed, so I made the below code. It rounds to the second decimal point, ex. '23.56 Billion', but you can change what decimal place it rounds to by replacing the two '100.0's in the last line with a larger or smaller number, ex. '10.0' rounds to one decimal point and '1000.0' rounds to three decimal points. Also, using this code, it always rounds down from what it actually is. You can change this if you like, by replacing 'floor' with 'ceil' or 'round'.

#make the dictionary to store what to put after the result (ex. 'Billion'). You can go further with this then I did, or to wherever you wish. 
#import the desired rounding mechanism. You will not need to do this for round. 
from math import floor
magnitudeDict={0:'', 1:'Thousand', 2:'Million', 3:'Billion', 4:'Trillion', 5:'Quadrillion', 6:'Quintillion', 7:'Sextillion', 8:'Septillion', 9:'Octillion', 10:'Nonillion', 11:'Decillion'}
def simplify(num):
    num=floor(num)
    magnitude=0
    while num>=1000.0:
        magnitude+=1
        num=num/1000.0
    return(f'{floor(num*100.0)/100.0} {magnitudeDict[magnitude]}')

The 'f' before the string in the last line is to let python know you are formatting it. The result from running print(simplify(34867123012.13)) is this:

34.86 Billion

Please let me know if you have questions! Thanks, Angus

Upvotes: 2

Jordi Riera

Reputation: 101

I had the same need. And if anyone comes on this topic, I found a lib to do so: https://github.com/azaitsev/millify

Hope it helps :)

Upvotes: 1

rtaft

Reputation: 2378

This version does not suffer from the bug in the previous answers where 999,999 gives you 1000.0K. It also only allows 3 significant figures and eliminates trailing 0's.

def human_format(num):
    num = float('{:.3g}'.format(num))
    magnitude = 0
    while abs(num) >= 1000:
        magnitude += 1
        num /= 1000.0
    return '{}{}'.format('{:f}'.format(num).rstrip('0').rstrip('.'), ['', 'K', 'M', 'B', 'T'][magnitude])

The output looks like:

>>> human_format(999999)
'1M'
>>> human_format(999499)
'999K'
>>> human_format(9994)
'9.99K'
>>> human_format(9900)
'9.9K'
>>> human_format(6543165413)
'6.54B'

Upvotes: 124

Roelant

Reputation: 5119

I needed this function today, refreshed the accepted answer a bit for people with Python >= 3.6:

def human_format(num, precision=2, suffixes=['', 'K', 'M', 'G', 'T', 'P']):
    m = sum([abs(num/1000.0**x) >= 1 for x in range(1, len(suffixes))])
    return f'{num/1000.0**m:.{precision}f}{suffixes[m]}'

print('the answer is %s' % human_format(7454538))  # prints 'the answer is 7.45M'

Edit: given the comments, you might want to change to round(num/1000.0)

Upvotes: 6

manugrandio

Reputation: 191

A more "math-y" solution is to use math.log:

from math import log, floor


def human_format(number):
    units = ['', 'K', 'M', 'G', 'T', 'P']
    k = 1000.0
    magnitude = int(floor(log(number, k)))
    return '%.2f%s' % (number / k**magnitude, units[magnitude])

Tests:

>>> human_format(123456)
'123.46K'
>>> human_format(123456789)
'123.46M'
>>> human_format(1234567890)
'1.23G'

Upvotes: 19

Adam Rosenfield

Reputation: 400642

I don't think there's a built-in function that does that. You'll have to roll your own, e.g.:

def human_format(num):
    magnitude = 0
    while abs(num) >= 1000:
        magnitude += 1
        num /= 1000.0
    # add more suffixes if you need them
    return '%.2f%s' % (num, ['', 'K', 'M', 'G', 'T', 'P'][magnitude])

print('the answer is %s' % human_format(7436313))  # prints 'the answer is 7.44M'

Upvotes: 98

zweiterlinde

Reputation: 14779

I don't know of any built-in capability like this, but here are a couple of list threads that may help:

http://coding.derkeiler.com/Archive/Python/comp.lang.python/2005-09/msg03327.html http://mail.python.org/pipermail/python-list/2008-August/503417.html

Upvotes: 0

schnaader

Reputation: 49739

I don't think there are format operators for that, but you can simply divide by 1000 until the result is between 1 and 999 and then use a format string for 2 digits after comma. Unit is a single character (or perhaps a small string) in most cases, which you can store in a string or array and iterate through it after each divide.

Upvotes: 0

Blair Conrad

Reputation: 242100

No String Formatting Operator, according to the docs. I've never heard of such a thing, so you may have to roll your own, as you suggest.

Upvotes: 0

Formatting long numbers as strings

Answers (15)

Related Questions