Wie Zahl mit Kommas als Tausendertrennzeichen drucken?

https://stackoverflow.com/questions/1823058

10-07-2019
|

Frage

Ich versuche, eine ganze Zahl in Python 2.6.1 mit Kommas als Tausendertrennzeichen zu drucken. Zum Beispiel möchte ich die Nummer 1234567 als 1,234,567 zeigen. Wie würde ich mich über das tun dies? Ich habe viele Beispiele auf Google gesehen, aber ich bin für die einfachste praktische Art und Weise.

Es muss nicht locale-spezifisch sein zwischen Punkt und Komma zu entscheiden. Ich würde wie vernünftigerweise möglich, etwas so einfach bevorzugen.

Lösung

Locale nicht bewusst

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

Locale beachten

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

Referenz

Format Spezifikation Mini-Language ,

Die ',' Option signalisiert die Verwendung eines Komma für ein Tausendertrennzeichen. Für eine locale bewusst Separator, verwenden Sie die 'n' integer Präsentation statt geben.

Andere Tipps

Ich habe dies funktioniert:

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

Sicher, Sie dies nicht tun Notwendigkeit Unterstützung der Internationalisierung, aber es ist klar, präzise und nutzt eine integrierte Bibliothek.

P. S. Das „% d“ ist die übliche% -Stil Formatierer. Sie können nur eine Formatierer, aber es kann alles, was Sie in Bezug auf Feldbreite und Genauigkeit Einstellungen müssen sein.

P.P.S. Wenn Sie nicht arbeiten können erhalten locale, würde ich eine modifizierte Version von Mark Antwort vorschlagen:

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)

Rekursion ist nützlich für den negativen Fall, aber eine Rekursion pro Komma scheint ein wenig übertrieben zu mir.

Für Ineffizienz und Unlesbarkeit es ist schwer zu schlagen:

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

Hier ist die locale Code Gruppierung nach irrelevanten Teile zu entfernen und es auf ein wenig Reinigung:

(Die folgende funktioniert nur für ganze Zahlen)

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'

Es gibt bereits einige gute Antworten hier. Ich will nur diese für die Zukunft hinzuzufügen. In Python 2.7 es wird eine Formatangabe für Tausendertrennzeichen sein. Nach Python-Dokumentation es funktioniert wie folgt

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

In python3.1 können Sie das Gleiche tun, wie folgt:

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

Ich bin überrascht, dass niemand hat erwähnt, dass Sie dies mit f-Strings in Python tun 3.6 so einfach wie folgt aus:

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

... wo der Teil nach dem Doppelpunkt ist die Formatangabe. Das Komma ist das Trennzeichen Sie wollen, so f"{num:_d}" verwendet unterstreicht statt einem Komma.

Dies entspricht die Verwendung format(num, ",d") für ältere Versionen von Python 3.

Hier ist ein einzeiliger regex Ersatz:

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

Funktioniert nur für inegral Ausgänge:

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'

oder für Schwimmer mit weniger als 4 Ziffern, die Formatbezeichner ändern %.3f:

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

Hinweis: mit mehr als drei Dezimalstellen nicht richtig funktioniert, wie es zur Gruppe der Dezimalteil versuchen werden:

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

Wie es funktioniert

Lassen Sie uns brechen sie:

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

Dies ist, was ich für Schwimmer tun. Obwohl, ehrlich gesagt, ich bin nicht sicher, welche Versionen es funktioniert für - ich bin mit 2.7:

my_number = 4385893.382939491

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

Returns: 4,385,893.38

Update: Vor kurzem hatte ich ein Problem mit diesem Format (könnte man den genauen Grund nicht sagen), aber war in der Lage, es zu beheben, indem Sie den 0 fallen:

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

Sie können auch '{:n}'.format( value ) für eine locale Darstellung verwenden. Ich denke, dass dies der einfachste Weg für eine locale Lösung ist.

Für weitere Informationen suchen thousands in Python DOC .

Für Währung, können Sie locale.currency verwenden, die die Flagge grouping Einstellung:

Code

import locale

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

Output

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

Ich bin sicher, dass es eine Standard-Library-Funktion dafür sein muss, aber es hat Spaß gemacht, zu versuchen, es zu schreiben, mich Rekursion so hier, was ich kam mit:

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)

Having said that, wenn jemand anderes eine Standardmethode findet, es zu tun, Sie, dass stattdessen verwenden solltest.

Von den Kommentare Activestate Rezept 498.181 ich überarbeitete diese:

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

Es verwendet die regulären Ausdrücke kennzeichnen: Vorgriff dh (?=\d) zu machen sicher nur Gruppen von drei Ziffern, die eine Ziffer ‚nach‘ sie ein Komma bekommen haben. Ich sage ‚nach‘, da die Zeichenfolge an dieser Stelle umgekehrt.

[::-1] kehrt nur einen String.

Slightly die Antwort von Ian Schneider erweitert:

Wenn Sie eine benutzerdefinierte Tausender-Trennzeichen verwenden möchten, ist die einfachste Lösung ist:

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

Beispiele

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

Wenn Sie die deutsche Vertretung wie dies wollen, wird es etwas komplizierter:

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

Python 3

Die ganzen Zahlen (ohne Nachkommastellen):

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

Floats (mit dezimal):

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

, wo die Zahl vor f die Anzahl der Dezimalstellen angibt.

Bonus

Schnell-and-dirty Starterfunktion für den indischen lakhs / crores Nummerierungssystem (12,34,567):

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

Die akzeptierte Antwort ist in Ordnung, aber ich ziehe es eigentlich format(number,','). Für mich einfacher zu interpretieren und zu erinnern.

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

aus Python-Version 2.6 können Sie dies tun:

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

Für Python-Versionen <2.6 und nur zu Ihrer Information, hier sind zwei manuelle Lösungen, wenden sie sich Schwimmern Ints aber negative Zahlen korrekt arbeiten:

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)

paar Dinge zu bemerken hier:

Diese Zeile: string = '% d' % Zahl schön wandelt eine Zahl in einen String, es unterstützt Negativen und es fällt Fraktionen aus Schwimmern, sie ints machen;
diese Scheibe Indizes [:: - 3] gibt jeden dritten Punkt ab das Ende, so habe ich ein weiteres Stück [1:] , um den allerletzten Punkt entfernen Cuz ich nicht ein Komma nach der letzten Ziffer muß;
dieser bedingter , wenn l [index] = '-'. verwendet wird, um negative Zahlen zu unterstützen, legen Sie nicht ein Komma nach dem Minuszeichen

Und eine Hardcore-Version:

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)

Hier ist eine, die auch für Schwimmer funktioniert:

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

Verwendungsbeispiel:

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

Ein Liner für Python 2.5 + und Python 3 (positives int only):

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

Ich bin ein Python Anfänger, sondern ein erfahrener Programmierer. Ich habe Python 3.5, so kann ich nur das Komma verwenden, aber das ist dennoch eine interessante Programmierübung. Betrachten wir den Fall eines unsigned integer. Das lesbare Python-Programm für Tausendertrennzeichen hinzugefügt scheint zu sein:

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)

Es ist auch möglich, eine Liste Verständnis zu verwenden:

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)

Dies ist kürzer, und könnte ein Motto sein, aber Sie werden einige geistige Gymnastik zu tun haben, zu verstehen, warum es funktioniert. In beiden Fällen erhalten wir:

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

Die erste Version ist die bessere Wahl, wenn Sie das Programm zu verstehen wollen.

Dies ist in Python gebacken pro PEP -> https: //www.python .org / dev / pep / pep-0378 /

nur Format verwenden (1000, 'd') eine ganze Zahl mit Tausendertrennzeichen zeigen

gibt es mehr Formate in dem PEP beschrieben, haben es

Das tut Geld zusammen mit den Kommas

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)

Ich habe eine Python 2 und Python 3-Version dieses Codes. Ich weiß, dass die Frage für Python gefragt wurde 2, aber jetzt (8 Jahre später lol) Leute werden wahrscheinlich Python 3.
Python 3 Code verwenden:

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 Code: (.. Bearbeiten Der Python-2-Code funktioniert nicht Ich denke, dass die Syntax ist anders).

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)

Ich verwende Python 2.5, so habe ich keinen Zugriff auf die integrierten Formatierungs.

schaute ich auf dem Django-Code intcomma (intcomma_recurs in Code unten) und realisierte es ist ineffizient, weil es rekursiv ist und auch auf jedem Laufe die regex Kompilieren ist auch nicht eine gute Sache. Dies ist nicht notwendig, ein ‚Problem‘, wie django ist nicht wirklich so konzentriert sich auf dieser Art von Low-Level-Performance. Auch ich war ein Faktor von 10 Unterschied in der Leistung erwartet, aber es ist nur 3-mal langsamer.

Aus Neugier implementiert ich einige Versionen von intcomma zu sehen, was die Performance-Vorteile sind, wenn regex. Meine Testdaten schließen einen leichten Vorteil für diese Aufgabe, aber überraschenderweise nicht viel.

Ich war erfreut, auch zu sehen, was ich vermuten: den umgekehrten xrange Ansatz ist nicht notwendig, in dem nicht-regex Fall, aber es macht den Code Look macht etwas besser auf Kosten von ~ 10% mehr Leistung

Auch gehe ich davon aus, was Sie vorbei in ein String ist und sieht etwas wie eine Nummer. Ergebnisse nicht bestimmt anders.

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

Und hier sind die Testergebnisse:

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

Italienisch Zahlen: '' Tausendertrennzeichen ist ein

Ich löste es auf diese Weise ... für eine dictonary

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)

aus: le immobilizzazioni valgono 419,168 €. i debiti pro TFR sono pari a 13,255 €. l'attivo circolante è di 195,443 Euro. il fondo Rischi ed oneri ha un importo Pari a 13,374 Euro. i debiti sono 180,947 €. i Ratei e risconti attivi sono pari ein 2.271 Euro. i Ratei e risconti passivi sono pari ein 1.864 Euro. I crediti verso i soci sono pari a 17,630 Euro.

Hier ist eine weitere Variante mit einer Generatorfunktion, die für ganze Zahlen funktioniert:

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

Und hier ist ein Test:

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

Just Unterklasse long (oder float, oder was auch immer). Dies ist sehr praktisch, weil auf diese Weise Sie noch Ihre Zahlen in Mathe ops (und damit vorhandenen Code) verwenden können, aber sie werden alle Druck gut in der Klemme.

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

Ich ziehe die locale-basierte Lösung für reale Projekte, aber ich denke, der Ansatz mit der Verwendung von Schichtzuordnung sollte hier erwähnt werden:

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 mit Doctests ist hier - https://gist.github.com/ei-grad / b290dc761ae253af69438bbb94d82683

Für Schwimmer:

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

Für Ints:

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

Wenn Sie nicht möchten, dass auf alle externen Bibliotheken abhängen:

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

Dies funktioniert nur für nicht-negative ganze Zahlen.

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow