인쇄하는 방법 숫자를 쉼표로 구분하여 수천으로 분리?

https://stackoverflow.com/questions/1823058

10-07-2019
|

문제

내가 노력하고를 인쇄하는 정수에서 Python2.6.1 쉼표로 구분으로 수천시키는 기능을 제공합니다.예를 들어,내가로 표시하고 싶 1234567 로 1,234,567.는 방법에 대해가 나는 이것을 하고 있는가?본 많은 예로 Google 에서 그러나 내가 찾는 가장 간단한 실제적인 방법입니다.

그것은 필요하지 않습을 로캘-특정 사이에서 결정하는 기간을 쉼표로 구분합니다.내가 선호하는 것으로 간단하게 뭔가가 합리적으로 가능합니다.

해결책

로케일을 알지 못합니다

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

로케일 인식

import locale
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')  # Customize

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

참조

당 형식 사양 미니 언어,

그만큼 ',' 옵션은 수천 개의 분리기에 쉼표를 사용한다는 신호입니다. 로케일 인식 분리기의 경우 사용하십시오 'n' 대신 정수 프리젠 테이션 유형.

다른 팁

나는 이것을 일하게했다 :

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

물론, 당신은 그렇지 않습니다 필요 국제화 지원이지만 명확하고 간결하며 내장 라이브러리를 사용합니다.

PS " %d"는 일반적인 %스타일 포피터입니다. 하나의 포피터 만 가질 수 있지만 필드 너비 및 정밀 설정 측면에서 필요한 모든 것이 될 수 있습니다.

얻을 수 없다면 pps locale 작동하기 위해 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)

재귀는 부정적인 경우에 유용하지만 쉼표 당 하나의 재귀는 나에게 약간 과도한 것으로 보입니다.

비 효율성과 읽기 성을 위해서는 이길 수 없습니다.

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

다음은 관련없는 부품을 제거하고 약간 청소 한 후 로케일 그룹화 코드입니다.

(다음은 정수에만 적용됩니다)

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'

여기에는 이미 좋은 답변이 있습니다. 나중에 참조하기 위해 이것을 추가하고 싶습니다. Python 2.7에는 수천 개의 분리기를위한 형식 지정자가있을 것입니다. 에 따르면 파이썬 문서 이와 같이 작동합니다

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

Python3.1에서는 다음과 같은 작업을 수행 할 수 있습니다.

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

Python 3.6의 F- 스트링 으로이 작업을 수행 할 수 있다고 아무도 언급하지 않았다는 사실에 놀랐습니다.

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

... 여기서 결장 이후의 부품은 형식 지정자입니다. 쉼표는 원하는 분리기 캐릭터이므로 f"{num:_d}" 쉼표 대신 밑줄을 사용합니다.

이것은 사용과 같습니다 format(num, ",d") 구형 버전의 Python 3.

다음은 한 줄 정규식 교체입니다.

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

무적 출력에 대해서만 작동합니다.

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'

또는 4 자리 미만의 플로트의 경우 형식 지정자를 %.3f:

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

NB : 10 진수 부품을 그룹화하려고 시도하므로 10 자리 이상으로 올바르게 작동하지 않습니다.

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

작동 방식

분해합시다 :

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

이것이 내가 부유물을 위해하는 일입니다. 솔직히 말해서 어떤 버전이 작동하는지 잘 모르겠습니다. 2.7을 사용하고 있습니다.

my_number = 4385893.382939491

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

반품 : 4,385,893.38

업데이트 : 최근 에이 형식에 문제가 있었지만 (정확한 이유를 말할 수 없었지만) 0:

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

당신은 또한 사용할 수 있습니다 '{:n}'.format( value ) 로케일 대표를 위해. 나는 이것이 로케일 솔루션의 가장 간단한 방법이라고 생각합니다.

자세한 내용은 검색하십시오 thousands 안에 파이썬 문서.

통화의 경우 사용할 수 있습니다 locale.currency, 깃발 설정 grouping:

암호

import locale

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

산출

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

나는 이것에 대한 표준 라이브러리 기능이 있어야한다고 확신하지만, 재귀를 사용하여 직접 쓰려고하는 것은 재미 있었으므로 다음과 같이 생각해 냈습니다.

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)

다른 사람이 표준 방법을 찾으면 대신 사용해야합니다.

로부터 코멘트 레시피를 활성화합니다 498181 나는 이것을 재 작업했다 :

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

일반 표현식 기능을 사용합니다. 봐 즉 (?=\d) '숫자를 얻은 후'숫자가있는 3 자리 숫자 그룹 만 확인합니다. 이 시점에서 문자열이 반전되기 때문에 '후'라고 말합니다.

[::-1] 단지 문자열을 뒤집습니다.

Ian Schneider의 답변을 약간 확장 :

Custom Tounts 분리기를 사용하려면 가장 간단한 솔루션은 다음과 같습니다.

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

예

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

이와 같은 독일 표현을 원한다면 조금 더 복잡해집니다.

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

파이썬 3

정수 (소수점없이) :

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

수레 (10 진수) :

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

이전의 숫자 f 소수점 이하 자리 수를 지정합니다.

보너스

Indian Lakhs/Crores Numbering System의 빠른 스타터 기능 (12,34,567) :

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

허용 된 대답은 괜찮지 만 실제로 선호합니다. format(number,','). 내가 해석하고 기억하기가 더 쉽습니다.

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

Python 버전 2.6에서 다음을 수행 할 수 있습니다.

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

Python 버전 <2.6의 경우 정보 만 있으면 2 개의 수동 솔루션이 있습니다. 부유물을 Ints로 바꾸지 만 음수는 올바르게 작동합니다.

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)

여기에 눈에 띄는 몇 가지 사항 :

이 라인 : 문자열 = ' % d' % 숫자 숫자를 문자열로 아름답게 변환하고, 부정적인 것을지지하고 플로트에서 분수를 떨어 뜨려서 ints를 만듭니다.
이 슬라이스 인덱스 [:: -3 끝에서 시작하여 각 세 번째 항목을 반환하여 다른 슬라이스를 사용했습니다. [1:] 마지막 항목 cuz를 제거하려면 마지막 번호 후에 쉼표가 필요하지 않습니다.
이 조건부 l [index]! = '-'인 경우 음수를지지하는 데 사용되고, 마이너스 부호 후에 쉼표를 삽입하지 마십시오.

더 하드 코어 버전 :

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)

다음은 플로트에도 적용되는 것입니다.

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

사용 예 :

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

Python 2.5+ 및 Python 3 용 1 개의 라이너 (양수 int 만 해당) :

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

나는 파이썬 초보자이지만 숙련 된 프로그래머입니다. 나는 Python 3.5를 가지고 있으므로 쉼표를 사용할 수 있지만 그럼에도 불구하고 이것은 흥미로운 프로그래밍 운동입니다. 서명되지 않은 정수의 경우를 고려하십시오. 수천 개의 분리기를 추가하기위한 가장 읽기 쉬운 Python 프로그램은 다음과 같습니다.

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)

목록 이해력을 사용하는 것도 가능합니다.

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)

이것은 짧고 하나의 라이너가 될 수 있지만, 왜 그것이 작동하는지 이해하기 위해 정신적 체조를해야합니다. 두 경우 모두 우리는 다음과 같습니다.

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

첫 번째 버전은 프로그램을 이해하려면 더 현명한 선택입니다.

이것은 pep -> 당 파이썬으로 구워졌습니다 https://www.python.org/dev/peps/pep-0378/

형식 (1000, ', d')을 사용하여 수천 개의 분리기가있는 정수를 보여줍니다.

PEP에 설명 된 더 많은 형식이 있습니다.

이것은 쉼표와 함께 돈을합니다

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)

이 코드의 Python 2와 Python 3 버전이 있습니다. 나는이 질문이 Python 2에 대한 요청을 받았다는 것을 알고 있지만 이제 (8 년 후 LOL) 사람들은 아마도 Python 3을 사용할 것입니다.

파이썬 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))

Python 2 코드 : (편집. Python 2 코드가 작동하지 않습니다. 구문이 다르다고 생각합니다).

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)

Python 2.5를 사용하고 있으므로 내장 형식에 액세스 할 수 없습니다.

나는 django 코드 intcomma (아래 코드의 intcomma_recurs)를 살펴보고 그것이 재귀 적이며 모든 달리기에 대한 동정인을 컴파일하는 것도 좋지 않기 때문에 비효율적이라는 것을 깨달았습니다. Django는 실제로 이러한 종류의 저수준 성능에 초점을 맞추지 않았기 때문에 이것은 '문제'가 필요하지 않습니다. 또한 성능이 10의 차이를 기대하고 있었지만 3 배나 느립니다.

호기심으로 인해 Regex를 사용할 때 성능 장점이 무엇인지 확인하기 위해 몇 가지 버전의 Intcomma를 구현했습니다. 내 테스트 데이터는이 작업에 대해 약간의 이점을 얻지 만 놀랍게도 전혀 많지 않습니다.

또한 내가 의심 한 것을 보게되어 기뻤습니다. 리버스 Xrange 접근법을 사용하는 것은리스 즈 비록리스 케이스에서는 불필요하지만 ~ 10% 성능의 비용으로 코드가 약간 더 좋아 보입니다.

또한, 나는 당신이 지나가는 것이 끈이고 다소 숫자처럼 보인다고 가정합니다. 그렇지 않으면 결과가 결정되지 않습니다.

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

테스트 결과는 다음과 같습니다.

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

이탈리아 번호 : 천개 분리기는 '입니다.'

나는 이런 식으로 그것을 해결했다

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 S.p.a. 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)

아웃 : le immobilizzazioni valgono 419.168 €. 나는 tfr sono pari a 13.255 € 당 직불합니다. L 'Attivo Circolante è di 195.443 유로. Il fondo rischi ed Oneri ha un importo pari 13.374 유로. 나는 Sono 180.947 €. 나는 Risconti Attivi Sono Pari를 2.271 유로로 평가합니다. 나는 Risconti Passivi Sono Pari를 1.864 유로로 평가합니다. 나는 17.630 유로를 인정합니다.

다음은 정수에 맞는 생성기 기능을 사용하는 또 다른 변형입니다.

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

그리고 여기 테스트가 있습니다.

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

그냥 하위 클래스 long (나 float, 또 무엇이든).이는 매우 실제적인 때문에,이 방법이 사용할 수 있습니다 숫자에서 수학 ops(므로 기존 코드),하지만 그들은 모든 인쇄에서 당신의 터미널도 있습니다.

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

실제 프로젝트를위한 로케일 기반 솔루션을 선호하지만 슬라이스 할당을 사용한 접근 방식은 여기에 언급되어야한다고 생각합니다.

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)

doctests와 함께 Gist는 여기에 있습니다. https://gist.github.com/ei-grad/b290dc761ae253af69438bbbbbbbb94d82683

플로트 용 :

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

ints :

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

외부 라이브러리에 의존하고 싶지 않은 경우 :

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

이것은 비 음성 정수에만 적용됩니다.

라이센스 : CC-BY-SA ~와 함께 속성

제휴하지 않습니다 StackOverflow