Wie kann man Zahlen mit Kommas als Tausendertrennzeichen drucken?
Ich versuche, eine Ganzzahl in Python 2.6.1 mit Kommas als Tausendertrennzeichen zu drucken. Zum Beispiel möchte ich die Nummer 1234567 als 1,234,567 anzeigen. Wie würde ich das machen? Ich habe viele Beispiele bei Google gesehen, suche aber den einfachsten praktischen Weg.
Es muss nicht länderspezifisch sein, um zwischen Punkten und Kommas zu entscheiden. Ich würde es vorziehen, so einfach wie möglich zu sein.
Für Python ≥ 2,7:
"{:,}".format(value)
Per Formatspezifikation Mini-Sprache ,
Die Option
','signalisiert die Verwendung eines Kommas für ein Tausendertrennzeichen. Verwenden Sie für ein Gebietsschema-Trennzeichen stattdessen den Ganzzahl-Präsentationstyp'n'.
Ich habe das zum Laufen gebracht:
>>> import locale
>>> locale.setlocale(locale.LC_ALL, 'en_US')
'en_US'
>>> locale.format("%d", 1255000, grouping=True)
'1,255,000'
Sicher, Sie brauchen keine Internationalisierungsunterstützung, aber es ist klar, prägnant und verwendet eine eingebaute Bibliothek.
P.S. Dieses "% d" ist das übliche Formatierungsprogramm im% -Stil. Sie können nur einen Formatierer haben, aber es kann alles sein, was Sie in Bezug auf die Feldbreite und die Präzisionseinstellungen benötigen.
P.P.S. Wenn Sie locale nicht zum Laufen bringen können, würde ich eine modifizierte Version von Marks 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 mir ein bisschen übertrieben zu sein.
Für Ineffizienz und Unlesbarkeit ist es 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 der Code für die Ländereinstellung, nachdem irrelevante Teile entfernt und ein wenig aufgeräumt wurden:
(Das 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'
Hier gibt es schon einige gute Antworten. Ich möchte dies nur als Referenz hinzufügen. In Python 2.7 wird es einen Formatbezeichner für Tausendertrennzeichen geben. Nach python docs funktioniert es so
>>> '{:20,.2f}'.format(f)
'18,446,744,073,709,551,616.00'
In python3.1 können Sie dasselbe tun:
>>> format(1234567, ',d')
'1,234,567'
Ich bin überrascht, dass niemand erwähnt hat, dass Sie dies mit f-Strings in Python 3.6 so einfach tun können:
>>> num = 10000000
>>> print(f"{num:,d}")
10,000,000
... wobei der Teil nach dem Doppelpunkt der Formatbezeichner ist. Das Komma ist das Trennzeichen, das Sie möchten, daher verwendet f"{num:_d}" Unterstriche anstelle eines Kommas.
Dies entspricht der Verwendung von 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 integrierte Ausgaben:
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'
Bei Floats mit weniger als 4 Ziffern ändern Sie den Formatbezeichner in %.3f:
re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%.3f" % val)
# Returns: '1,234,567,890.123'
NB: Funktioniert nicht mehr als drei Dezimalstellen, da versucht wird, den Dezimalteil zu gruppieren:
re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%.5f" % val)
# Returns: '1,234,567,890.12,346'
Wie es funktioniert
Brechen wir es auf:
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
Das mache ich für Schwimmer. Ehrlich gesagt bin ich mir nicht sicher, für welche Version es funktioniert - ich verwende 2.7:
my_number = 4385893.382939491
my_string = '{:0,.2f}'.format(my_number)
Rückgaben: 4.385.893,38
Update: Ich hatte kürzlich ein Problem mit diesem Format (konnte nicht den genauen Grund angeben), konnte es jedoch beheben, indem der 0: gelöscht wurde
my_string = '{:,.2f}'.format(my_number)
Sie können auch '{:n}'.format( value ) für eine Gebietsschema-Darstellung verwenden. Ich denke, das ist der einfachste Weg für eine lokale Lösung.
Um weitere Informationen zu erhalten, suchen Sie in Python DOC nach thousands.
Für die Währung können Sie locale.currency verwenden und das Flag grouping setzen:
Code
import locale
locale.setlocale( locale.LC_ALL, '' )
locale.currency( 1234567.89, grouping = True )
Ausgabe
'Portuguese_Brazil.1252'
'R$ 1.234.567,89'
Ich bin mir sicher, dass es dafür eine Standard-Bibliotheksfunktion geben muss, aber es hat Spaß gemacht, selbst mit Rekursion zu schreiben.
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)
Wenn jedoch jemand anderes eine Standardmethode findet, sollten Sie diese Option verwenden.
Aus den Kommentaren Rezept aktivieren 498181 Ich habe dies überarbeitet:
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 Funktion für reguläre Ausdrücke: Lookahead d. H. (?=\d), um sicherzustellen, dass nur Gruppen von drei Ziffern, die eine Ziffer 'nach' haben, ein Komma erhalten. Ich sage 'after', weil die Zeichenfolge an dieser Stelle umgekehrt ist.
[::-1] kehrt nur eine Zeichenfolge um.
Die Antwort von Ian Schneider etwas erweitern:
Wenn Sie ein benutzerdefiniertes Tausendertrennzeichen verwenden möchten, lautet die einfachste Lösung:
'{:,}'.format(value).replace(',', your_custom_thousands_separator)
Beispiele
'{:,.2f}'.format(123456789.012345).replace(',', ' ')
Wenn Sie die deutsche Darstellung so 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
-
Ganzzahlen (ohne Dezimalstelle):
"{:,d}".format(1234567)
-
Floats (mit Dezimalstelle):
"{:,.2f}".format(1234567)
dabei gibt die Zahl vor f die Anzahl der Dezimalstellen an.
-
Bonus
Schnellstartfunktion für das indische Lakhs/Crores-Nummerierungssystem (12,34,567):
Die akzeptierte Antwort ist in Ordnung, aber ich bevorzuge format(number,','). Einfacher für mich zu interpretieren und zu erinnern.
ab Python Version 2.6 können Sie Folgendes tun:
def format_builtin(n):
return format(n, ',')
Für Python-Versionen <2.6 und nur zu Ihrer Information, hier sind 2 manuelle Lösungen, die Floats zu Ints machen, aber negative Zahlen funktionieren korrekt:
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)
ein paar Dinge, die Sie hier beachten sollten:
- diese Zeile: string = '% d'% number wandelt eine Zahl in eine Zeichenfolge um, unterstützt Negative und lässt Brüche von Floaten fallen, wodurch sie ints umgewandelt werden.
- dieses Slice indexes [:: - 3] gibt jedes dritte Element ausgehend von dem Ende zurück. Daher habe ich ein anderes Slice [1:] verwendet, um das letzte Element zu entfernen cuz I don Nach der letzten Zahl ist kein Komma erforderlich;
- diese Bedingung wenn l [Index]! = '-' zur Unterstützung negativer Zahlen verwendet wird, setzen Sie nach dem Minuszeichen kein Komma.
Und noch mehr 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)
Ich bin ein Python-Anfänger, aber ein erfahrener Programmierer. Ich habe Python 3.5, also kann ich einfach das Komma verwenden, aber das ist trotzdem eine interessante Programmierübung. Betrachten Sie den Fall einer vorzeichenlosen Ganzzahl. Das am besten lesbare Python-Programm zum Hinzufügen von Tausendertrennzeichen 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, ein Listenverstä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 One-Liner sein, aber Sie müssen einige mentale Gymnastik machen, um 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 vernünftigere Wahl, wenn das Programm verstanden werden soll.
Ein Liner für Python 2.5+ und Python 3 (nur positive int):
''.join(reversed([x + (',' if i and not i % 3 else '') for i, x in enumerate(reversed(str(1234567)))]))
Hier ist auch eines, das für Floats 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'
Italienische Zahlen: Tausendertrennzeichen ist ein '.'
Ich habe es so gelöst ... für einen Dikton
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)
out: le immobilizzazioni valgono 419.168 €. ich debiti per TFR sono pari a 13.255 €. l'attivo circolante è di 195.443 euro. Zu diesem Zeitpunkt war es 13.374 Euro. Ich debiti sono 180.947 €. Ich habe einen Preis von 2.271 Euro. Ich habe eine Rate von 1.864 Euro. Ich habe einen Kredit in Höhe von 17.630 Euro.
Ich verwende Python 2.5, so dass ich keinen Zugriff auf die integrierte Formatierung habe.
Ich habe mir den Django-Code intcomma (intcomma_recurs im Code unten) angesehen und erkannte, dass er ineffizient ist, weil er rekursiv ist und auch das Regex in jedem Lauf zu kompilieren ist keine gute Sache. Dies ist nicht unbedingt ein "Problem", da Django nicht wirklich auf diese Art von Low-Level-Performance ausgerichtet ist. Ich hatte auch einen Faktor 10-Unterschied in der Leistung erwartet, aber er ist nur dreimal langsamer.
Aus Neugier habe ich einige Versionen von intcomma implementiert, um zu sehen, welche Vorteile die Verwendung von Regex mit sich bringt. Meine Testdaten haben für diese Aufgabe einen leichten Vorteil, aber überraschenderweise nicht viel.
Ich war auch sehr erfreut zu sehen, was ich vermutete: Die Verwendung des umgekehrten Xrange-Ansatzes ist im No-Regex-Fall nicht erforderlich, macht den Code jedoch bei einem Preis von ~ 10% etwas besser.
Außerdem gehe ich davon aus, dass Sie eine Zeichenfolge verwenden, die wie eine Zahl aussieht. Ergebnisse sonst unbestimmt.
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 __== '__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
dies wird in Python per PEP gebacken -> https://www.python.org/dev/peps/pep-0378/
verwenden Sie einfach format (1000, ', d'), um eine Ganzzahl mit Tausendertrennzeichen anzuzeigen
es gibt weitere Formate, die im PEP beschrieben werden
Ich habe eine Python 2- und Python 3-Version dieses Codes. Ich weiß, dass die Frage nach Python 2 gestellt wurde, aber jetzt (8 Jahre später) werden die Leute wahrscheinlich Python 3 verwenden.
Python 3-Code:
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 anders ist).
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)
Nur die Unterklasse long (oder float oder was auch immer). Dies ist sehr praktisch, da Sie Ihre Zahlen auf diese Weise immer noch in mathematischen Operationen (und damit in vorhandenem Code) verwenden können, aber alle in Ihrem Terminal gut gedruckt werden.
>>> 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
Das macht 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)