pitón humana gran número legibles

Question

¿Hay una biblioteca de Python que haría números como esto más legible

$ 187.280.840.422.780

editado: por ejemplo iw ANT la salida de este ser 187 billones de dólares no sólo separados por comas . Así que quiero salida sea billones, millones, mil millones etc

Answer 1

lo que tengo entendido, sólo desea la parte 'más importante'. Para hacerlo, use floor(log10(abs(n))) para obtener el número de dígitos y luego vaya desde allí. Algo como esto, tal vez:

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]) 

Ejecución de la función anterior para un montón de diferentes números:

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 

Answer 2

De 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 

Answer 3

Ese número parece bastante legible para mí. Un número antipático sería 187289840422780.00. Para agregar comas, puede crear su propia función o buscar uno (me encontré 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 

Si desea redondear un número para que sea más fácil de leer, hay una función de Python para que: round().

Podría alejarse aún más de los datos reales y decir "Una cantidad muy alta" o "Por encima de los 100 billones" utilizando una función que devolvería un valor diferente en función de sus puntos de referencia programados.

Answer 4

Si con 'legible' quiere decir 'palabras'; aquí hay una buena solución que puedes adaptar.

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

Answer 5

hizo eso el otro día con la configuración regional:

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

Hay una mejor forma de hacerlo en 2.7, consulte PEP 378: Especificador de formato para separador de miles de más información:

http://www.python.org/dev/peps/pep-0378/

Edición (2014): En estos días tengo la siguiente función de shell en su lugar:

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

Enjoy!