¿Cómo imprimir el número con comas como miles de separadores?

Estoy intentando imprimir un entero en Python 2.6.1 con comas como miles de separadores. Por ejemplo, quiero mostrar el número 1234567 como 1,234,567 . ¿Cómo voy a hacer esto? He visto muchos ejemplos en Google, pero estoy buscando la forma práctica más sencilla.

No es necesario que sea específico de la localidad para decidir entre puntos y comas. Preferiría algo tan simple como razonablemente posible.

Para Python ≥ 2.7:

 "{:,}".format(value) 

Especificación de formato en mini idioma ,

La opción ',' señala el uso de una coma para un separador de miles. Para un separador que tenga en cuenta la configuración regional, use el tipo de presentación entero 'n' lugar.

Tengo esto para trabajar:

 >>> import locale >>> locale.setlocale(locale.LC_ALL, 'en_US') 'en_US' >>> locale.format("%d", 1255000, grouping=True) '1,255,000' 

Claro, no necesita soporte de internacionalización, pero es claro, conciso y utiliza una biblioteca integrada.

PD: “% d” es el formateador de estilo% habitual. Puede tener solo un formateador, pero puede ser lo que necesite en términos de ancho de campo y configuración de precisión.

PPS Si no puede hacer que la locale funcione, sugeriría una versión modificada de la respuesta de Mark:

 def intWithCommas(x): if type(x) not in [type(0), type(0L)]: raise TypeError("Parameter must be an integer.") if x < 0: return '-' + intWithCommas(-x) result = '' while x >= 1000: x, r = divmod(x, 1000) result = ",%03d%s" % (r, result) return "%d%s" % (x, result) 

La recursión es útil para el caso negativo, pero una recursión por coma me parece un poco excesiva.

Por ineficiencia y falta de lectura es difícil de superar:

 >>> import itertools >>> s = '-1234567' >>> ','.join(["%s%s%s" % (x[0], x[1] or '', x[2] or '') for x in itertools.izip_longest(s[::-1][::3], s[::-1][1::3], s[::-1][2::3])])[::-1].replace('-,','-') 

Aquí está el código de agrupación de locale después de eliminar partes irrelevantes y limpiarlo un poco:

(Lo siguiente solo funciona para enteros)

 def group(number): s = '%d' % number groups = [] while s and s[-1].isdigit(): groups.append(s[-3:]) s = s[:-3] return s + ','.join(reversed(groups)) >>> group(-23432432434.34) '-23,432,432,434' 

Ya hay algunas buenas respuestas aquí. Solo quiero añadir esto para futuras referencias. En Python 2.7 habrá un especificador de formato para el separador de miles. Según los documentos de Python , funciona así.

 >>> '{:20,.2f}'.format(f) '18,446,744,073,709,551,616.00' 

En python3.1 puedes hacer lo mismo así:

 >>> format(1234567, ',d') '1,234,567' 

Me sorprende que nadie haya mencionado que puedes hacer esto con f-strings en Python 3.6 tan fácil como esto:

 >>> num = 10000000 >>> print(f"{num:,d}") 10,000,000 

… donde la parte después de los dos puntos es el especificador de formato. La coma es el carácter separador que desea, por lo que f"{num:_d}" usa guiones bajos en lugar de una coma.

Esto es equivalente a usar el format(num, ",d") para versiones anteriores de python 3.

Aquí hay un reemplazo de expresiones regulares de una línea:

 re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%d" % val) 

Funciona solo para salidas internas:

 import re val = 1234567890 re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%d" % val) # Returns: '1,234,567,890' val = 1234567890.1234567890 # Returns: '1,234,567,890' 

O para flotadores con menos de 4 dígitos, cambie el especificador de formato a %.3f :

 re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%.3f" % val) # Returns: '1,234,567,890.123' 

NB: no funciona correctamente con más de tres dígitos decimales, ya que intentará agrupar la parte decimal:

 re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%.5f" % val) # Returns: '1,234,567,890.12,346' 

Cómo funciona

Vamos a descomponerlo:

 re.sub(pattern, repl, string) pattern = \ "(\d) # Find one digit... (?= # that is followed by... (\d{3})+ # one or more groups of three digits... (?!\d) # which are not followed by any more digits. )", repl = \ r"\1,", # Replace that one digit by itself, followed by a comma, # and continue looking for more matches later in the string. # (re.sub() replaces all matches it finds in the input) string = \ "%d" % val # Format the string as a decimal to begin with 

Esto es lo que hago para flotadores. Aunque, honestamente, no estoy seguro de para qué versiones funciona, estoy usando 2.7:

 my_number = 4385893.382939491 my_string = '{:0,.2f}'.format(my_number) 

Devoluciones: 4,385,893.38

Actualización: hace poco tuve un problema con este formato (no podría decirle la razón exacta), pero pude solucionarlo al eliminar el 0 :

 my_string = '{:,.2f}'.format(my_number) 

También puede usar '{:n}'.format( value ) para una representación regional. Creo que esta es la forma más sencilla para una solución de configuración regional.

Para obtener más información, busque thousands en Python DOC .

Para la moneda, puede usar locale.currency , configurando la grouping bandera:

Código

 import locale locale.setlocale( locale.LC_ALL, '' ) locale.currency( 1234567.89, grouping = True ) 

Salida

 'Portuguese_Brazil.1252' 'R$ 1.234.567,89' 

Estoy seguro de que debe haber una función de biblioteca estándar para esto, pero fue divertido tratar de escribirlo yo mismo usando recursión, así que esto es lo que se me ocurrió:

 def intToStringWithCommas(x): if type(x) is not int and type(x) is not long: raise TypeError("Not an integer!") if x < 0: return '-' + intToStringWithCommas(-x) elif x < 1000: return str(x) else: return intToStringWithCommas(x / 1000) + ',' + '%03d' % (x % 1000) 

Habiendo dicho eso, si alguien más encuentra una forma estándar de hacerlo, deberías usarla en su lugar.

De los comentarios a la receta de estado activo 498181, reescribí esto:

 import re def thous(x, sep=',', dot='.'): num, _, frac = str(x).partition(dot) num = re.sub(r'(\d{3})(?=\d)', r'\1'+sep, num[::-1])[::-1] if frac: num += dot + frac return num 

Utiliza la función de expresiones regulares: lookahead ie (?=\d) para asegurarse de que solo los grupos de tres dígitos que tienen un dígito ‘después’ tengan una coma. Digo “después” porque la cadena es inversa en este punto.

[::-1] simplemente invierte una cadena.

Ampliando ligeramente la respuesta de Ian Schneider:

Si desea utilizar un separador de miles personalizado, la solución más sencilla es:

 '{:,}'.format(value).replace(',', your_custom_thousands_separator) 

Ejemplos

 '{:,.2f}'.format(123456789.012345).replace(',', ' ') 

Si quieres una representación alemana como esta, se complica un poco más:

 ('{:,.2f}'.format(123456789.012345) .replace(',', ' ') # 'save' the thousands separators .replace('.', ',') # dot to comma .replace(' ', '.')) # thousand separators to dot 

Python 3

Enteros (sin decimal):

"{:,d}".format(1234567)

Flotadores (con decimal):

"{:,.2f}".format(1234567)

donde el número antes de f especifica el número de decimales.

Prima

Función de inicio rápido y sucio para el sistema de numeración de miles de rupias / millones de indios (12,34,567):

https://stackoverflow.com/a/44832241/4928578

La respuesta aceptada está bien, pero en realidad prefiero el format(number,',') . Más fácil para mí interpretar y recordar.

https://docs.python.org/3/library/functions.html#format

Desde la versión 2.6 de Python puedes hacer esto:

 def format_builtin(n): return format(n, ',') 

Para las versiones de Python <2.6 y solo para su información, aquí hay 2 soluciones manuales, que convierten los flotantes a ints pero los números negativos funcionan correctamente:

 def format_number_using_lists(number): string = '%d' % number result_list = list(string) indexes = range(len(string)) for index in indexes[::-3][1:]: if result_list[index] != '-': result_list.insert(index+1, ',') return ''.join(result_list) 

Algunas cosas para notar aquí:

  • esta línea: string = ‘% d’% number convierte a la perfección un número en una cadena, admite negativos y elimina las fracciones de los flotadores, haciéndolos ints;
  • los índices de este segmento [:: – 3] devuelven cada tercer elemento a partir del final, así que utilicé otro segmento [1:] para eliminar el último elemento porque no necesito una coma después del último número;
  • este condicional, si l [index]! = ‘-‘ se usa para admitir números negativos, no inserte una coma después del signo menos.

Y una versión más hardcore:

 def format_number_using_generators_and_list_comprehensions(number): string = '%d' % number generator = reversed( [ value+',' if (index!=0 and value!='-' and index%3==0) else value for index,value in enumerate(reversed(string)) ] ) return ''.join(generator) 

Aquí hay uno que también funciona para flotadores:

 def float2comma(f): s = str(abs(f)) # Convert to a string decimalposition = s.find(".") # Look for decimal point if decimalposition == -1: decimalposition = len(s) # If no decimal, then just work from the end out = "" for i in range(decimalposition+1, len(s)): # do the decimal if not (i-decimalposition-1) % 3 and i-decimalposition-1: out = out+"," out = out+s[i] if len(out): out = "."+out # add the decimal point if necessary for i in range(decimalposition-1,-1,-1): # working backwards from decimal point if not (decimalposition-i-1) % 3 and decimalposition-i-1: out = ","+out out = s[i]+out if f < 0: out = "-"+out return out 

Ejemplo de uso:

 >>> float2comma(10000.1111) '10,000.111,1' >>> float2comma(656565.122) '656,565.122' >>> float2comma(-656565.122) '-656,565.122' 

Un forro para Python 2.5+ y Python 3 (solo int positivo):

 ''.join(reversed([x + (',' if i and not i % 3 else '') for i, x in enumerate(reversed(str(1234567)))])) 

Soy un principiante de Python, pero un progtwigdor experimentado. Tengo Python 3.5, así que solo puedo usar la coma, pero este es un ejercicio de progtwigción interesante. Considere el caso de un entero sin signo. El progtwig de Python más legible para agregar miles de separadores parece ser:

 def add_commas(instr): out = [instr[0]] for i in range(1, len(instr)): if (len(instr) - i) % 3 == 0: out.append(',') out.append(instr[i]) return ''.join(out) 

También es posible utilizar una lista de comprensión:

 add_commas(instr): rng = reversed(range(1, len(instr) + (len(instr) - 1)//3 + 1)) out = [',' if j%4 == 0 else instr[-(j - j//4)] for j in rng] return ''.join(out) 

Esto es más corto y podría ser de una sola línea, pero tendrá que hacer un poco de gimnasia mental para entender por qué funciona. En ambos casos obtenemos:

 for i in range(1, 11): instr = '1234567890'[:i] print(instr, add_commas(instr)) 
 1 1 12 12 123 123 1234 1,234 12345 12,345 123456 123,456 1234567 1,234,567 12345678 12,345,678 123456789 123,456,789 1234567890 1,234,567,890 

La primera versión es la opción más sensata si desea que se entienda el progtwig.

Esto hace dinero junto con las comas.

 def format_money(money, presym='$', postsym=''): fmt = '%0.2f' % money dot = string.find(fmt, '.') ret = [] if money < 0 : ret.append('(') p0 = 1 else : p0 = 0 ret.append(presym) p1 = (dot-p0) % 3 + p0 while True : ret.append(fmt[p0:p1]) if p1 == dot : break ret.append(',') p0 = p1 p1 += 3 ret.append(fmt[dot:]) # decimals ret.append(postsym) if money < 0 : ret.append(')') return ''.join(ret) 

Tengo una versión de python 2 y python 3 de este código. Sé que se hizo la pregunta para python 2, pero ahora (8 años después, lol) la gente probablemente usará python 3.

Código de Python 3:

 import random number = str(random.randint(1, 10000000)) comma_placement = 4 print('The original number is: {}. '.format(number)) while True: if len(number) % 3 == 0: for i in range(0, len(number) // 3 - 1): number = number[0:len(number) - comma_placement + 1] + ',' + number[len(number) - comma_placement + 1:] comma_placement = comma_placement + 4 else: for i in range(0, len(number) // 3): number = number[0:len(number) - comma_placement + 1] + ',' + number[len(number) - comma_placement + 1:] break print('The new and improved number is: {}'.format(number)) 

Código Python 2: (Editar. El código Python 2 no funciona. Estoy pensando que la syntax es diferente).

 import random number = str(random.randint(1, 10000000)) comma_placement = 4 print 'The original number is: %s.' % (number) while True: if len(number) % 3 == 0: for i in range(0, len(number) // 3 - 1): number = number[0:len(number) - comma_placement + 1] + ',' + number[len(number) - comma_placement + 1:] comma_placement = comma_placement + 4 else: for i in range(0, len(number) // 3): number = number[0:len(number) - comma_placement + 1] + ',' + number[len(number) - comma_placement + 1:] break print 'The new and improved number is: %s.' % (number) 

Estoy usando Python 2.5, así que no tengo acceso al formato incorporado.

Miré el código de Django intcomma (intcomma_recurs en el código de abajo) y me di cuenta de que es ineficiente, porque es recursivo y también comstackr la expresión regular en cada ejecución tampoco es algo bueno. Esto no es necesario como un “problema” ya que django no está realmente enfocado en este tipo de rendimiento de bajo nivel. Además, esperaba un factor de diferencia de 10 en el rendimiento, pero es solo 3 veces más lento.

Por curiosidad, implementé algunas versiones de intcomma para ver cuáles son las ventajas de rendimiento al usar expresiones regulares. Los datos de mi prueba concluyen una ligera ventaja para esta tarea, pero sorprendentemente no mucho.

También me complació ver lo que sospechaba: el uso del enfoque de rango inverso es innecesario en el caso de no-regex, pero hace que el código se vea un poco mejor a un costo de ~ 10% de rendimiento.

Además, asumo que lo que estás pasando es una cadena y se parece a un número. Resultados indeterminados de lo contrario.

 from __future__ import with_statement from contextlib import contextmanager import re,time re_first_num = re.compile(r"\d") def intcomma_noregex(value): end_offset, start_digit, period = len(value),re_first_num.search(value).start(),value.rfind('.') if period == -1: period=end_offset segments,_from_index,leftover = [],0,(period-start_digit) % 3 for _index in xrange(start_digit+3 if not leftover else start_digit+leftover,period,3): segments.append(value[_from_index:_index]) _from_index=_index if not segments: return value segments.append(value[_from_index:]) return ','.join(segments) def intcomma_noregex_reversed(value): end_offset, start_digit, period = len(value),re_first_num.search(value).start(),value.rfind('.') if period == -1: period=end_offset _from_index,segments = end_offset,[] for _index in xrange(period-3,start_digit,-3): segments.append(value[_index:_from_index]) _from_index=_index if not segments: return value segments.append(value[:_from_index]) return ','.join(reversed(segments)) re_3digits = re.compile(r'(?<=\d)\d{3}(?!\d)') def intcomma(value): segments,last_endoffset=[],len(value) while last_endoffset > 3: digit_group = re_3digits.search(value,0,last_endoffset) if not digit_group: break segments.append(value[digit_group.start():last_endoffset]) last_endoffset=digit_group.start() if not segments: return value if last_endoffset: segments.append(value[:last_endoffset]) return ','.join(reversed(segments)) def intcomma_recurs(value): """ Converts an integer to a string containing commas every three digits. For example, 3000 becomes '3,000' and 45000 becomes '45,000'. """ new = re.sub("^(-?\d+)(\d{3})", '\g<1>,\g<2>', str(value)) if value == new: return new else: return intcomma(new) @contextmanager def timed(save_time_func): begin=time.time() try: yield finally: save_time_func(time.time()-begin) def testset_xsimple(func): func('5') def testset_simple(func): func('567') def testset_onecomma(func): func('567890') def testset_complex(func): func('-1234567.024') def testset_average(func): func('-1234567.024') func('567') func('5674') if __name__ == '__main__': print 'Test results:' for test_data in ('5','567','1234','1234.56','-253892.045'): for func in (intcomma,intcomma_noregex,intcomma_noregex_reversed,intcomma_recurs): print func.__name__,test_data,func(test_data) times=[] def overhead(x): pass for test_run in xrange(1,4): for func in (intcomma,intcomma_noregex,intcomma_noregex_reversed,intcomma_recurs,overhead): for testset in (testset_xsimple,testset_simple,testset_onecomma,testset_complex,testset_average): for x in xrange(1000): # prime the test testset(func) with timed(lambda x:times.append(((test_run,func,testset),x))): for x in xrange(50000): testset(func) for (test_run,func,testset),_delta in times: print test_run,func.__name__,testset.__name__,_delta 

Y aquí están los resultados de la prueba:

 intcomma 5 5 intcomma_noregex 5 5 intcomma_noregex_reversed 5 5 intcomma_recurs 5 5 intcomma 567 567 intcomma_noregex 567 567 intcomma_noregex_reversed 567 567 intcomma_recurs 567 567 intcomma 1234 1,234 intcomma_noregex 1234 1,234 intcomma_noregex_reversed 1234 1,234 intcomma_recurs 1234 1,234 intcomma 1234.56 1,234.56 intcomma_noregex 1234.56 1,234.56 intcomma_noregex_reversed 1234.56 1,234.56 intcomma_recurs 1234.56 1,234.56 intcomma -253892.045 -253,892.045 intcomma_noregex -253892.045 -253,892.045 intcomma_noregex_reversed -253892.045 -253,892.045 intcomma_recurs -253892.045 -253,892.045 1 intcomma testset_xsimple 0.0410001277924 1 intcomma testset_simple 0.0369999408722 1 intcomma testset_onecomma 0.213000059128 1 intcomma testset_complex 0.296000003815 1 intcomma testset_average 0.503000020981 1 intcomma_noregex testset_xsimple 0.134000062943 1 intcomma_noregex testset_simple 0.134999990463 1 intcomma_noregex testset_onecomma 0.190999984741 1 intcomma_noregex testset_complex 0.209000110626 1 intcomma_noregex testset_average 0.513000011444 1 intcomma_noregex_reversed testset_xsimple 0.124000072479 1 intcomma_noregex_reversed testset_simple 0.12700009346 1 intcomma_noregex_reversed testset_onecomma 0.230000019073 1 intcomma_noregex_reversed testset_complex 0.236999988556 1 intcomma_noregex_reversed testset_average 0.56299996376 1 intcomma_recurs testset_xsimple 0.348000049591 1 intcomma_recurs testset_simple 0.34600019455 1 intcomma_recurs testset_onecomma 0.625 1 intcomma_recurs testset_complex 0.773999929428 1 intcomma_recurs testset_average 1.6890001297 1 overhead testset_xsimple 0.0179998874664 1 overhead testset_simple 0.0190000534058 1 overhead testset_onecomma 0.0190000534058 1 overhead testset_complex 0.0190000534058 1 overhead testset_average 0.0309998989105 2 intcomma testset_xsimple 0.0360000133514 2 intcomma testset_simple 0.0369999408722 2 intcomma testset_onecomma 0.207999944687 2 intcomma testset_complex 0.302000045776 2 intcomma testset_average 0.523000001907 2 intcomma_noregex testset_xsimple 0.139999866486 2 intcomma_noregex testset_simple 0.141000032425 2 intcomma_noregex testset_onecomma 0.203999996185 2 intcomma_noregex testset_complex 0.200999975204 2 intcomma_noregex testset_average 0.523000001907 2 intcomma_noregex_reversed testset_xsimple 0.130000114441 2 intcomma_noregex_reversed testset_simple 0.129999876022 2 intcomma_noregex_reversed testset_onecomma 0.236000061035 2 intcomma_noregex_reversed testset_complex 0.241999864578 2 intcomma_noregex_reversed testset_average 0.582999944687 2 intcomma_recurs testset_xsimple 0.351000070572 2 intcomma_recurs testset_simple 0.352999925613 2 intcomma_recurs testset_onecomma 0.648999929428 2 intcomma_recurs testset_complex 0.808000087738 2 intcomma_recurs testset_average 1.81900000572 2 overhead testset_xsimple 0.0189998149872 2 overhead testset_simple 0.0189998149872 2 overhead testset_onecomma 0.0190000534058 2 overhead testset_complex 0.0179998874664 2 overhead testset_average 0.0299999713898 3 intcomma testset_xsimple 0.0360000133514 3 intcomma testset_simple 0.0360000133514 3 intcomma testset_onecomma 0.210000038147 3 intcomma testset_complex 0.305999994278 3 intcomma testset_average 0.493000030518 3 intcomma_noregex testset_xsimple 0.131999969482 3 intcomma_noregex testset_simple 0.136000156403 3 intcomma_noregex testset_onecomma 0.192999839783 3 intcomma_noregex testset_complex 0.202000141144 3 intcomma_noregex testset_average 0.509999990463 3 intcomma_noregex_reversed testset_xsimple 0.125999927521 3 intcomma_noregex_reversed testset_simple 0.126999855042 3 intcomma_noregex_reversed testset_onecomma 0.235999822617 3 intcomma_noregex_reversed testset_complex 0.243000030518 3 intcomma_noregex_reversed testset_average 0.56200003624 3 intcomma_recurs testset_xsimple 0.337000131607 3 intcomma_recurs testset_simple 0.342000007629 3 intcomma_recurs testset_onecomma 0.609999895096 3 intcomma_recurs testset_complex 0.75 3 intcomma_recurs testset_average 1.68300008774 3 overhead testset_xsimple 0.0189998149872 3 overhead testset_simple 0.018000125885 3 overhead testset_onecomma 0.018000125885 3 overhead testset_complex 0.0179998874664 3 overhead testset_average 0.0299999713898 

Solo una subclase long (o float , o lo que sea). Esto es muy práctico, porque de esta manera aún puede usar sus números en operaciones matemáticas (y, por lo tanto, en el código existente), pero todos se imprimirán bien en su terminal.

 >>> class number(long): def __init__(self, value): self = value def __repr__(self): s = str(self) l = [x for x in s if x in '1234567890'] for x in reversed(range(len(s)-1)[::3]): l.insert(-x, ',') l = ''.join(l[1:]) return ('-'+l if self < 0 else l) >>> number(-100000) -100,000 >>> number(-100) -100 >>> number(-12345) -12,345 >>> number(928374) 928,374 >>> 345 

Números italianos: separador de mil es un ‘.’

Lo resolví de esta manera … por un dictonario.

 from random import randint voci = { "immobilizzazioni": randint(200000, 500000), "tfr": randint(10000, 25000), "ac": randint(150000, 200000), "fondo": randint(10500, 22350), "debiti": randint(150000, 250000), "ratei_attivi": randint(2000, 2500), "ratei_passivi": randint(1500, 2600), "crediti_v_soci": randint(10000, 30000) } testo_rnd2 = """Nell'azienda Hypermax Spa di Bologna le immobilizzazioni valgono {immobilizzazioni:,} €, i debiti per TFR sono pari a {tfr:,} €, l'attivo circolante è di {ac:,} euro, il fondo rischi ed oneri ha un importo pari a {fondo:,} euro, i debiti sono {debiti:,} €, i ratei e risconti attivi sono pari a {ratei_attivi:,} euro, i ratei e risconti passivi sono pari a {ratei_passivi:,} euro. I crediti verso i soci sono pari a {crediti_v_soci:,} euro.""" print(testo_rnd2) 

fuera: le immobilizzazioni valgono 419.168 €. I debiti per TFR sono pari a 13.255 €. El circuito de circolante es de 195.443 euros. Il fondo rischi ed oneri ha im imto a un precio de 13.374 euros. Me debiti sono 180.947 €. I ratei risconti attivi sono pari a 2.271 euro. I ratei e risconti passivi sono pari a 1.864 euro. I crediti verso i soci sono pari a 17.630 euro.

Aquí hay otra variante que usa una función de generador que funciona para enteros:

 def ncomma(num): def _helper(num): # assert isinstance(numstr, basestring) numstr = '%d' % num for ii, digit in enumerate(reversed(numstr)): if ii and ii % 3 == 0 and digit.isdigit(): yield ',' yield digit return ''.join(reversed([n for n in _helper(num)])) 

Y aquí hay una prueba:

 >>> for i in (0, 99, 999, 9999, 999999, 1000000, -1, -111, -1111, -111111, -1000000): ... print i, ncomma(i) ... 0 0 99 99 999 999 9999 9,999 999999 999,999 1000000 1,000,000 -1 -1 -111 -111 -1111 -1,111 -111111 -111,111 -1000000 -1,000,000 

esto se incluye en python por PEP -> https://www.python.org/dev/peps/pep-0378/

simplemente use el formato (1000, ‘, d’) para mostrar un entero con separador de miles

Hay más formatos descritos en el PEP, tenemos en ello.

Prefiero la solución basada en la localización para proyectos reales, pero creo que el enfoque con el uso de la asignación de sectores debe mencionarse aquí:

 def format_money(f, delimiter=',', frac_digits=2): negative_fix = int(f < 0) s = '%.*f' % (frac_digits, f) if len(s) < 5 + frac_digits + negative_fix: return s l = list(s) l_fix = l[negative_fix:] p = len(l_fix) - frac_digits - 5 l_fix[p::-3] = [i + delimiter for i in l_fix[p::-3]] return ''.join(l[:negative_fix] + l_fix) 

Gist with doctests está aquí: https://gist.github.com/ei-grad/b290dc761ae253af69438bbb94d82683

Para flotadores:

 float(filter(lambda x: x!=',', '1,234.52')) # returns 1234.52 

Para ints:

 int(filter(lambda x: x!=',', '1,234')) # returns 1234 

Si no quieres depender de ninguna biblioteca externa:

  s = str(1234567) print ','.join([s[::-1][k:k+3][::-1] for k in xrange(len(s)-1, -1, -3)]) 

Esto funciona solo para enteros no negativos.