Como imprimir números com vírgulas como separadores de milhares?

754

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.

Elias Zamaria
fonte

Respostas:

1739

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.

Ian Schneider
fonte
25
Observe que isso não estará correto fora dos EUA e em alguns outros lugares; nesse caso, o locale.format () escolhido é a resposta correta.
Gringo Suave
11
O formulário de argumento de palavra-chave:{val:,}.format(val=val)
CivFan
11
Muito obrigado. Para quantias em dinheiro, com 2 casas decimais - "{:,. 2f}". Formato (valor)
dlink
3
para Portugal onde usamos o ponto (.) como separador apenas: {:,} ". format (value) .replace (',', '.')
13
No python 3.6 e superior, as strings f adicionam ainda mais conveniência. Por exemplo,f"{2 ** 64 - 1:,}"
CJ Gaconnet
285

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.

Mike DeSimone
fonte
14
Tentei o seu código e, infelizmente, recebo o seguinte: "locale.Error: configuração de local não suportada". : -s
Mark Byers
11
Mark: Se você está no Linux, pode querer ver o que está no seu /etc/locale.gen ou o que a glibc está usando para criar seus locais. Você também pode tentar "" en "," en_US.utf8 "," en_US.UTF-8 ", 'en_UK" (sp?), Etc. mikez: É preciso haver um livro: "Dr. PEP: ou Como eu aprendi a parar de se preocupar e amar docs.python.org. " Eu desisti de memorizar todas as bibliotecas no Python 1.5.6. Quanto a locale, eu uso o mínimo possível.
Mike DeSimone
10
Você pode usar '' para setlocaleusar o padrão, o que, esperamos, será apropriado.
Mark Ransom
24
Tente isto: locale.setlocale (locale.LC_ALL, '') Funcionou para mim
Nadia Alramli
1
Embora inteligente, não gosto de funções que fazem configurações globais ... Usar 'blah'.format () é o melhor caminho a percorrer.
Cerin
132

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('-,','-')
Kasey Kirkham
fonte
171
Votado como o método mais ineficiente e ilegível para responder a esta pergunta.
Psytek 19/01/12
1
seria bom se isso pelo menos funcionasse. tente este número "17371830", ele se torna "173.718.3.0" =)
holms
5
Períodos? Isso nem é possível, holms. Esse pedaço de lixo ignora totalmente a localidade. Eu me pergunto como você conseguiu esse resultado. Seu exemplo produz '17, 371.830 'para mim, conforme o esperado.
Kasey Kirkham
11
Para tornar isso uma função, sugiro: lambda x: (lambda s: ','.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('-,','-'))(str(x))apenas para manter o tema da ofuscação.
Quantum
95

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'
Nadia Alramli
fonte
Sim, as maneiras mais difíceis são principalmente para as pessoas em Pythons mais antigos, como as que acompanham o RHEL e outras distribuições de suporte de longo prazo.
Mike DeSimone 20/05
3
como expressar isso com seqüências de caracteres de formato? "%, d"% 1234567 não funciona
Frederic Bazin
93

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.

Emil Stenström
fonte
Isso é mais fácil do que qualquer uma das respostas mais votadas e não requer importações adicionais.
Nível Z4
39

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
Daniel Fortunov
fonte
1
usar detalhado modo e você pode ter comentários a direita dentro do código
Daniel Stracaboško
Não foi possível substituir o "(?! \ D)" por um "$"?
GL2014 31/01
28

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)
elPastor
fonte
19

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'
DiogoLR
fonte
14

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
Martin Thoma
fonte
Um pouco mais curto:'{:_.2f}'.format(12345.6789).replace('.', ',').replace('_', '.')
Tom Pohl
12

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.

Mark Byers
fonte
Infelizmente, não funciona em todos os casos. intToStringWithCommas (1000.1) -> '1.0001.000'
Nadia Alramli
Ele disse especificamente números inteiros e que deveria ser o mais simples possível, por isso decidi não manipular tipos de dados que não sejam números inteiros. Também expliquei o nome da função _int_ToStringWithCommas. Agora também adicionei um aumento para torná-lo mais claro.
Mark Byers
8

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.

Tom Viner
fonte
8

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

Magenta Nova
fonte
Funciona perfeitamente, evitando também exibir dígitos decimais para carros alegóricos.
Rexcirus 14/08/19
7

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

Adam Starrh
fonte
5

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)
arka
fonte
2

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.

Geoff Fergusson
fonte
1

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'
Edward van Kuik
fonte
1
float2comma(12031023.1323)retornos: '12, 031,023.132,3 '
demux
1

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)))]))
Collin Anderson
fonte
1

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
Manrique
fonte
0

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)
Bob F
fonte
0

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) 
Dinosaur212
fonte
0

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
parity3
fonte
Eu pensei que a solução de um único regex de Daniel Fortunov seria a número 1 e venceria todos os algoritmos porque o regex é tão refinado / otimizado e codificado em C, mas não. Acho que o padrão e a aparência são muito caros. cai aproximadamente o dobro do tempo do intcomma acima, mesmo com a pré-compilação do regex.
Parity3
0

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

Raveen Beemsingh
fonte
-1

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
user650654
fonte
-1

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
twneale
fonte
8
Gosto da ideia da subclasse, mas é __repr__()o método correto para substituir? Eu sugeriria substituir __str__()e sair __repr__()sozinho, porque int(repr(number(928374)))deveria funcionar, mas int()engasgaria com as vírgulas.
Steveha 01/12/2009
@steveha tem um bom argumento, mas a justificativa deveria ter sido que number(repr(number(928374)))não funciona, não int(repr(number(928374))). Mesmo assim, para fazer com que essa abordagem funcione diretamente print, conforme solicitado pelo OP, o __str__()método deve ser substituído e não substituído __repr__(). Independentemente disso, parece haver um erro na lógica de inserção de vírgula principal.
22610 martineau
-1

Itália:

>>> import locale
>>> locale.setlocale(locale.LC_ALL,"")
'Italian_Italy.1252'
>>> f"{1000:n}"
'1.000'
Giovanni G. PY
fonte
-8

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
Jennifer
fonte
5
Isso remove as vírgulas. Embora útil, o OP solicitou uma maneira de adicioná- los. Além disso, algo como float('1,234.52'.translate(None, ','))pode ser mais direto e possivelmente mais rápido.
Pausado até novo aviso.