Estou tentando imprimir um número inteiro no Python 2.6.1 com vírgulas como separadores de milhares. Por exemplo, quero mostrar o número 1234567como 1,234,567. Como eu faria isso? Eu já vi muitos exemplos no Google, mas estou procurando a maneira prática mais simples.

Não precisa ser específico do local para decidir entre pontos e vírgulas. Eu preferiria algo o mais simples possível.

Localidade inconsciente

'{:,}'.format(value)  # For Python ≥2.7
f'{value:,}'  # For Python ≥3.6

Local ciente

import locale
locale.setlocale(locale.LC_ALL, '')  # Use '' for auto, or force e.g. to 'en_US.UTF-8'

'{:n}'.format(value)  # For Python ≥2.7
f'{value:n}'  # For Python ≥3.6

Referência

Mini-idioma de especificação por formato ,

A ','opção sinaliza o uso de uma vírgula para um separador de milhares. Para um separador com reconhecimento de localidade, use o 'n'tipo de apresentação inteiro.

Eu fiz isso funcionar:

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

Claro, você não precisa de suporte à internacionalização, mas é claro, conciso e usa uma biblioteca interna.

PS Esse "% d" é o formatador comum do estilo%. Você pode ter apenas um formatador, mas pode ser o que você precisa em termos de largura de campo e configurações de precisão.

PPS Se você não conseguir localetrabalhar, sugiro uma versão modificada da resposta 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)

A recursão é útil para o caso negativo, mas uma recursão por vírgula parece um pouco excessiva para mim.

Por ineficiência e ilegibilidade, é difícil de vencer:

>>> 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('-,','-')

Aqui está o código de agrupamento do código do idioma após remover partes irrelevantes e limpá-lo um pouco:

(O seguinte funciona apenas para números inteiros)

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'

Já existem boas respostas aqui. Eu só quero adicionar isso para referência futura. No python 2.7, haverá um especificador de formato para separador de milhares. De acordo com a documentação do python , funciona assim

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

No python3.1, você pode fazer o mesmo:

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

Estou surpreso que ninguém tenha mencionado que você pode fazer isso com f-strings no Python 3.6 tão fácil quanto isto:

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

... onde a parte após os dois pontos é o especificador de formato. A vírgula é o caractere separador desejado, portanto, f"{num:_}"use sublinhados em vez de vírgula.

Isso é equivalente ao uso format(num, ",")para versões mais antigas do python 3.

Aqui está uma substituição de regex de uma linha:

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

Funciona apenas para saídas inegrais:

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'

Ou para carros alegóricos com menos de 4 dígitos, altere o especificador de formato para %.3f:

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

NB: Não funciona corretamente com mais de três dígitos decimais, pois tentará agrupar a parte decimal:

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

Como funciona

Vamos dividir:

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

Isto é o que faço para carros alegóricos. Embora, honestamente, não tenha certeza para quais versões ele funciona - estou usando o 2.7:

my_number = 4385893.382939491

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

Retorna: 4.385.893,38

Atualização: recentemente, tive um problema com este formato (não sabia o motivo exato), mas consegui corrigi-lo soltando 0:

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

Você também pode usar '{:n}'.format( value )para uma representação de localidade. Eu acho que essa é a maneira mais simples de uma solução de localidade.

Para obter mais informações, procure thousandsno Python DOC .

Para moeda, você pode usar locale.currency, definindo a bandeira grouping:

Código

import locale

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

Resultado

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

Expandindo ligeiramente a resposta de Ian Schneider:

Se você deseja usar um separador de milhares personalizado, a solução mais simples é:

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

Exemplos

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

Se você quer uma representação alemã assim, fica um pouco mais complicado:

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

Tenho certeza de que deve haver uma função de biblioteca padrão para isso, mas foi divertido tentar escrevê-la usando recursão. Aqui está o que eu criei:

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)

Dito isto, se alguém encontrar uma maneira padrão de fazer isso, você deve usá-la.

Dos comentários para ativar a receita 498181 , refiz o seguinte:

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

Ele usa o recurso de expressões regulares: lookahead, ou seja, (?=\d)para garantir que apenas grupos de três dígitos com um dígito 'depois' deles recebam uma vírgula. Eu digo 'depois' porque a cadeia é inversa neste momento.

[::-1] apenas inverte uma string.

A resposta aceita é boa, mas eu realmente prefiro format(number,','). Mais fácil para mim interpretar e lembrar.

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

Python 3

-

Inteiros (sem decimal):

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

-

Flutuadores (com decimal):

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

onde o número anterior fespecifica o número de casas decimais.

-

Bônus

Função de partida rápida e suja para o sistema de numeração lakhs / crores da Índia (12,34,567):

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

do Python versão 2.6, você pode fazer isso:

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

Para versões do Python <2.6 e apenas para sua informação, aqui estão duas soluções manuais: eles transformam flutuadores em ints, mas números negativos funcionam corretamente:

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)

algumas coisas a serem observadas aqui:

• esta linha: string = '% d'% number converte maravilhosamente um número em uma string, suporta negativos e descarta frações de flutuadores, tornando-os ints;
• esse índice de fatia [:: - 3] retorna cada terceiro item a partir do final, então usei outra fatia [1:] para remover o último item, pois não preciso de uma vírgula após o último número;
• esta condição se l [index]! = '-' estiver sendo usado para suportar números negativos, não insira vírgula após o sinal de menos.

E uma versão mais 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)

Sou iniciante em Python, mas um programador experiente. Eu tenho o Python 3.5, então posso usar a vírgula, mas esse é um exercício de programação interessante. Considere o caso de um número inteiro não assinado. O programa Python mais legível para adicionar milhares 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)

Também é possível usar uma compreensão de lista:

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)

Isso é mais curto e pode ser um exemplo, mas você terá que fazer uma ginástica mental para entender por que funciona. Nos dois casos, obtemos:

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

A primeira versão é a escolha mais sensata, se você deseja que o programa seja entendido.

Aqui está um que também funciona para carros alegóricos:

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

Exemplo de uso:

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

Um liner para Python 2.5+ e Python 3 (somente int positivo):

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

Solução universal

Eu encontrei alguns problemas com o separador de pontos nas respostas votadas com mais frequência anteriores. Projetei uma solução universal onde você pode usar o que quiser como separador de milhar sem modificar o código do idioma . Sei que não é a solução mais elegante, mas faz o trabalho. Sinta-se livre para melhorá-lo!

def format_integer(number, thousand_separator='.'):
    def reverse(string):
        string = "".join(reversed(string))
        return string

    s = reverse(str(number))
    count = 0
    result = ''
    for char in s:
        count = count + 1
        if count % 3 == 0:
            if len(s) == count:
                result = char + result
            else:
                result = thousand_separator + char + result
        else:
            result = char + result
    return result


print(format_integer(50))
# 50
print(format_integer(500))
# 500
print(format_integer(50000))
# 50.000
print(format_integer(50000000))
# 50.000.000

Isso ganha dinheiro junto com as vírgulas

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)

Eu tenho uma versão python 2 e python 3 deste código. Eu sei que a pergunta foi feita para python 2, mas agora (8 anos depois, lol) as pessoas provavelmente estarão usando python 3.

Código 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. O código python 2 não está funcionando. Estou pensando que a sintaxe é 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) 

Estou usando o python 2.5 para não ter acesso à formatação interna.

Eu olhei para o código do Django intcomma (intcomma_recurs no código abaixo) e percebi que é ineficiente, porque é recursivo e também compilar o regex em cada execução também não é uma coisa boa. Isso não é necessário, pois o django não está realmente focado nesse tipo de desempenho de baixo nível. Além disso, eu esperava um fator de 10 de diferença de desempenho, mas é apenas três vezes mais lento.

Por curiosidade, implementei algumas versões do intcomma para ver quais são as vantagens de desempenho ao usar o regex. Meus dados de teste concluem uma pequena vantagem para esta tarefa, mas surpreendentemente não muito.

Também fiquei satisfeito ao ver o que eu suspeitava: o uso da abordagem xrange reversa é desnecessário no caso sem regex, mas faz com que o código pareça um pouco melhor com o custo de ~ 10% de desempenho.

Além disso, suponho que o que você está passando é uma string e se parece com um número. Resultados indeterminados de outra forma.

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

E aqui estão os resultados do teste:

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

isso é incorporado em python por PEP -> https://www.python.org/dev/peps/pep-0378/

basta usar o formato (1000, ', d') para mostrar um número inteiro com separador de milhares

existem mais formatos descritos no PEP, têm nele

Aqui está outra variante usando uma função geradora que funciona para números inteiros:

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

E aqui está um teste:

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

Apenas subclasse long(ou float, ou o que for). Isso é altamente prático, pois dessa forma você ainda pode usar seus números nas operações matemáticas (e, portanto, no código existente), mas todos serão impressos de maneira agradável no seu 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

Itália:

>>> import locale
>>> locale.setlocale(locale.LC_ALL,"")
'Italian_Italy.1252'
>>> f"{1000:n}"
'1.000'

Para carros alegóricos:

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

Para ints:

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