Zahlen formatieren
- jens
- Python-Forum Veteran
- Beiträge: 8502
- Registriert: Dienstag 10. August 2004, 09:40
- Wohnort: duisburg
- Kontaktdaten:
Ich muß sagen, ich bin etwas enttäuscht... Warum geht's nicht einfach mit einem passendem String-Formatter???
Ich denke es kommt doch häufiger vor, das jemand tausenderpunkte für große Zahlen haben will.
Ist doch nicht's ausßergewäöhnliches...
Wäre es also ein Feature Request?
Ich denke es kommt doch häufiger vor, das jemand tausenderpunkte für große Zahlen haben will.
Ist doch nicht's ausßergewäöhnliches...
Wäre es also ein Feature Request?
- jens
- Python-Forum Veteran
- Beiträge: 8502
- Registriert: Dienstag 10. August 2004, 09:40
- Wohnort: duisburg
- Kontaktdaten:
@HarryH: Deine Lösung ist schon nicht schlecht. Sie funktioniert allerdings nicht richtig, wenn "%i" als Format benutzt wird
Bei mit kommt allerdings beides vor... Deshalb meine Variante:
Bei mit kommt allerdings beides vor... Deshalb meine Variante:
Code: Alles auswählen
def formatter( number, format = "%.2f" ):
"""Formatiert Zahlen mit Tausenderpunkte"""
num_string = format % number # Formatierung anwenden
try:
pre, post = num_string.split(".")
except ValueError: # Ganzzahl liegt vor
pre = num_string
post = False
pre = pre[::-1] # umkehren
no_split = re.findall( r"\d{3,3}|\d{0,2}", pre )[:-1] # Aufsplitten
no = ".".join( no_split )[::-1] # Tausenderpunkte + umkehren
if post: no += ",%s" % post # Nachkommastellen anfügen
return no
print formatter( 1234567.89 )
print formatter( 12345.1,"%f" )
print formatter( 1234.0,"%i" )
EDIT: Kann es sein, das eine Stringumkehrung mit [::-1] nicht mit älteren Python Versionen funktioniert1.234.567,89
12.345,100000
1.234
-
- Python-Forum Veteran
- Beiträge: 16025
- Registriert: Freitag 20. Juni 2003, 16:30
- Kontaktdaten:
Sie dir mal NeuereVersionen an, dort steht das unter "Slice Syntax".jens hat geschrieben:EDIT: Kann es sein, das eine Stringumkehrung mit [::-1] nicht mit älteren Python Versionen funktioniert
My god, it's full of CARs! | Leonidasvoice vs (former) Modvoice
- jens
- Python-Forum Veteran
- Beiträge: 8502
- Registriert: Dienstag 10. August 2004, 09:40
- Wohnort: duisburg
- Kontaktdaten:
Also gibt's das erst seid Python v2.4 Schade... Nunja, hier eine Version, dich auch mit >2.4 läuft:Leonidas hat geschrieben:Sie dir mal NeuereVersionen an, dort steht das unter "Slice Syntax".
Code: Alles auswählen
def formatter( number, format = "%.2f" ):
"""Formatiert Zahlen mit Tausenderpunkte"""
def reverse( string ):
# ersatz für string[::-1] welches erst ab v2.4 gibt :(
l = re.findall(".",string)
l.reverse()
return "".join( l )
num_string = format % number # Formatierung anwenden
try:
pre, post = num_string.split(".")
except ValueError: # Ganzzahl liegt vor
pre = num_string
post = False
pre = reverse( pre ) # umkehren
num_split = re.findall( r"\d{3,3}|\d{0,2}", pre )[:-1] # Aufsplitten
num = ".".join( num_split ) # Tausenderpunkte + umkehren
num = reverse( num )
if post: num += ",%s" % post # Nachkommastellen anfügen
return num
Hi,
Funktioniert nun auch für int-Zahlen.
Außerdem werden auch vorn oder hinten angestellte Leerzeichen mit ausgegeben (z.b. beim Format "%20.2f")
Nun noch eine Frage:
Gibt es bei regex eine Möglichkeit den String von hinten nach vorne zu durchsuchen?
Dann könnte man sich das zweimalige Umkehren des Strings sparen.
Code: Alles auswählen
def __formatter(number, format = "%.2f", decChar = ",", groupChar = ".", groupRange = 3):
"""
Convert to required format
number = number to convert
format = python string formatting (%)
decChar = decimal char for the converted format
groupChar = group char for the converted format
groupRange = group range for the converted format
For example:
__formatter(1234567890.987, "%.2f", ",", ".", 3)
==> 1.234.567.890,99
"""
regex = re.compile("^ *\d*\D\d{1,%s}|\d{1,%s} *" % (groupRange, groupRange))
form_num = groupChar.join(regex.findall((format % number).replace(".", decChar)[::-1]))[::-1]
return form_num
Außerdem werden auch vorn oder hinten angestellte Leerzeichen mit ausgegeben (z.b. beim Format "%20.2f")
Nun noch eine Frage:
Gibt es bei regex eine Möglichkeit den String von hinten nach vorne zu durchsuchen?
Dann könnte man sich das zweimalige Umkehren des Strings sparen.
Gruß, Harry
- jens
- Python-Forum Veteran
- Beiträge: 8502
- Registriert: Dienstag 10. August 2004, 09:40
- Wohnort: duisburg
- Kontaktdaten:
OK, und hier nochmal die Variante für Python >v2.3
Ich hab re.compile() außerhalb der Funktion gemacht, deswegen erübrigt sich der Parameter groupRange
Warum hast du die Funktion __formatter genannt? Was bedeuten die doppelten Unterstriche?
Code: Alles auswählen
import re
formatter_regex = re.compile("^ *\d*\D\d{1,3}|\d{1,3} *")
def formatter(number, format = "%.2f", decChar = ",", groupChar = "."):
"""
Convert to required format
by HarryH modify by Jens Diemer
number = number to convert
format = python string formatting (%)
decChar = decimal char for the converted format
groupChar = group char for the converted format
For example:
formatter(1234567890.987, "%.2f", ",", ".")
==> 1.234.567.890,99
formatter( 1234567890.987, "%i")
==> 1.234.567.890
"""
def reverse( string ):
# ersatz für string[::-1] welches erst ab v2.3 gibt :(
list = re.findall(".",string)
list.reverse()
return "".join( list )
return reverse(
groupChar.join(
formatter_regex.findall(
reverse( (format % number).replace(".", decChar) )
)
)
)
Warum hast du die Funktion __formatter genannt? Was bedeuten die doppelten Unterstriche?
Zuletzt geändert von jens am Donnerstag 7. Juli 2005, 15:45, insgesamt 2-mal geändert.
- gerold
- Python-Forum Veteran
- Beiträge: 5555
- Registriert: Samstag 28. Februar 2004, 22:04
- Wohnort: Oberhofen im Inntal (Tirol)
- Kontaktdaten:
Hi!
Und hier noch eine kleine Übersicht über das Laufzeitverhalten bei 10.000 Durchläufen:
Ergebnis:
mfg
Gerold
:-)
Und hier noch eine kleine Übersicht über das Laufzeitverhalten bei 10.000 Durchläufen:
Code: Alles auswählen
#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
import re
#----------------------------------------------------------------------
def format_number_1(
number,
format = "%0.2f",
decimal_char = ",",
group_char = ".",
group_range = 3
):
"""
Nach einer Idee von Voges, HarryH und Jens.
http://www.python-forum.de/viewtopic.php?t=371
"""
def reverse(string):
# ersatz für string[::-1] welches erst ab v2.3 gibt :(
list = re.findall(".",string)
list.reverse()
return "".join(list)
regex = re.compile(
"^ *\d*\D\d{1,%s}|\d{1,%s} *" % (group_range, group_range)
)
return reverse(
group_char.join(
regex.findall(
reverse( (format % number).replace(
".", decimal_char)
)
)
)
)
#----------------------------------------------------------------------
def format_number_2(
number,
format = "%0.2f",
decimal_char = ",",
group_char = ".",
group_range = 3
):
"""
Nach einer Idee von Milan.
http://www.python-forum.de/viewtopic.php?t=371
"""
def split(s, size = group_range):
return map(lambda i: s[i:i + size], xrange(0, len(s), size))
def reverse(s):
l = map(None, s)
l.reverse()
return ('').join(l)
num = (format % number).replace('.', decimal_char)
int_part = num[:num.find(decimal_char)]
return (
reverse(
group_char.join(
split(reverse(int_part))
)
) + num[num.find(decimal_char):]
).replace(" %s" % group_char, " ")
if __name__ == "__main__":
# Testen welche Funktion schneller ist
import time
zahlen = (
66,
1,
2,
3.4,
-5.678,
612345,
612345.555,
987654321.067
)
begin = time.time()
for i in range(10000):
for zahl in zahlen:
x = format_number_1(zahl)
print "1:", time.time() - begin
print
begin = time.time()
for i in range(10000):
for zahl in zahlen:
x = format_number_2(zahl)
print "2:", time.time() - begin
print
Code: Alles auswählen
1: 4.18799996376
2: 2.64100003242
Gerold
:-)
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
- jens
- Python-Forum Veteran
- Beiträge: 8502
- Registriert: Dienstag 10. August 2004, 09:40
- Wohnort: duisburg
- Kontaktdaten:
Halt, da fehlt noch die ursprüngliche Version und sowieso und überhaupt:
Ein guter kompromiss (wenn Python >v2.3) ist wohl die 1b Version... Dort hab ich die reverse() Funktion von Milan eingebaut...
Code: Alles auswählen
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import re
#----------------------------------------------------------------------
format_number_0a_regex = re.compile("^ *\d*\D\d{1,3}|\d{1,3} *")
def format_number_0a(number, format = "%.2f", decChar = ",", groupChar = "."):
"""
Convert to required format
number = number to convert
format = python string formatting (%)
decChar = decimal char for the converted format
groupChar = group char for the converted format
groupRange = group range for the converted format
For example:
__formatter(1234567890.987, "%.2f", ",", ".", 3)
==> 1.234.567.890,99
"""
form_num = groupChar.join(format_number_0a_regex.findall((format % number).replace(".", decChar)[::-1]))[::-1]
return form_num
#----------------------------------------------------------------------
def format_number_0b(number, format = "%.2f", decChar = ",", groupChar = ".", groupRange = 3):
"""
Convert to required format
number = number to convert
format = python string formatting (%)
decChar = decimal char for the converted format
groupChar = group char for the converted format
groupRange = group range for the converted format
For example:
__formatter(1234567890.987, "%.2f", ",", ".", 3)
==> 1.234.567.890,99
"""
regex = re.compile("^ *\d*\D\d{1,%s}|\d{1,%s} *" % (groupRange, groupRange))
form_num = groupChar.join(regex.findall((format % number).replace(".", decChar)[::-1]))[::-1]
return form_num
#----------------------------------------------------------------------
format_number_1_regex = re.compile( "^ *\d*\D\d{1,3}|\d{1,3} *" )
def format_number_1(
number,
format = "%0.2f",
decimal_char = ",",
group_char = "."
):
"""
Nach einer Idee von Voges, HarryH und Jens.
http://www.python-forum.de/viewtopic.php?t=371
"""
def reverse(string):
# ersatz für string[::-1] welches erst ab v2.3 gibt :(
list = re.findall(".",string)
list.reverse()
return "".join(list)
return reverse(
group_char.join(
format_number_1_regex.findall(
reverse( (format % number).replace(
".", decimal_char)
)
)
)
)
#----------------------------------------------------------------------
format_number_1_regex = re.compile( "^ *\d*\D\d{1,3}|\d{1,3} *" )
def format_number_1b(
number,
format = "%0.2f",
decimal_char = ",",
group_char = "."
):
"""
Nach einer Idee von Voges, HarryH und Jens.
http://www.python-forum.de/viewtopic.php?t=371
"""
def reverse(s):
# ersatz für string[::-1] welches erst ab v2.3 gibt :(
l = map(None, s)
l.reverse()
return ('').join(l)
return reverse(
group_char.join(
format_number_1_regex.findall(
reverse( (format % number).replace(
".", decimal_char)
)
)
)
)
#----------------------------------------------------------------------
def format_number_2(
number,
format = "%0.2f",
decimal_char = ",",
group_char = ".",
group_range = 3
):
"""
Nach einer Idee von Milan.
http://www.python-forum.de/viewtopic.php?t=371
"""
def split(s, size = group_range):
return map(lambda i: s[i:i + size], xrange(0, len(s), size))
def reverse(s):
l = map(None, s)
l.reverse()
return ('').join(l)
num = (format % number).replace('.', decimal_char)
int_part = num[:num.find(decimal_char)]
return (
reverse(
group_char.join(
split(reverse(int_part))
)
) + num[num.find(decimal_char):]
).replace(" %s" % group_char, " ")
if __name__ == "__main__":
# Testen welche Funktion schneller ist
import time
zahlen = (
66,
1,
2,
3.4,
-5.678,
612345,
612345.555,
987654321.067
)
begin = time.time()
for i in range(10000):
for zahl in zahlen:
x = format_number_0a(zahl)
print "0a:", time.time() - begin
print
begin = time.time()
for i in range(10000):
for zahl in zahlen:
x = format_number_0b(zahl)
print "0b:", time.time() - begin
print
begin = time.time()
for i in range(10000):
for zahl in zahlen:
x = format_number_1(zahl)
print "1:", time.time() - begin
print
begin = time.time()
for i in range(10000):
for zahl in zahlen:
x = format_number_1b(zahl)
print "1b:", time.time() - begin
print
begin = time.time()
for i in range(10000):
for zahl in zahlen:
x = format_number_2(zahl)
print "2:", time.time() - begin
print
Code: Alles auswählen
0a: 0.921999931335
0b: 1.31200003624
1: 2.4849998951
1b: 1.32800006866
2: 1.57800006866
`list` ist hier ein ganz schlechter Name, weil man genau hier das eingebaute `list()` benutzen kann, um ohne den regulären Ausdruck auszukommen:jens hat geschrieben:Code: Alles auswählen
def reverse(string): # ersatz für string[::-1] welches erst ab v2.3 gibt :( list = re.findall(".",string) list.reverse() return "".join(list)
Code: Alles auswählen
In [6]: list("hallo")
Out[6]: ['h', 'a', 'l', 'l', 'o']
- jens
- Python-Forum Veteran
- Beiträge: 8502
- Registriert: Dienstag 10. August 2004, 09:40
- Wohnort: duisburg
- Kontaktdaten:
Hier mal ein Test, wie schnell oder langsam die unterschiedlichen reverse() Geschichten sind:
Code: Alles auswählen
import time, re
def reverse0(string):
l = list( string )
l.reverse()
return "".join(l)
def reverse1(s):
l = map(None, s)
l.reverse()
return ('').join(l)
def reverse2(string):
list = re.findall(".",string)
list.reverse()
return "".join(list)
def reverse3(s):
return s[::-1]
TestString = "1234567890abcdefghijklmnopqrstuvwxyz"
loops = 500000
begin = time.time()
for i in xrange(loops): reverse0( TestString )
print "reverse0: %0.3f" % (time.time()-begin)
begin = time.time()
for i in xrange(loops): reverse1( TestString )
print "reverse1: %0.3f" % (time.time()-begin)
begin = time.time()
for i in xrange(loops): reverse2( TestString )
print "reverse2: %0.3f" % (time.time()-begin)
begin = time.time()
for i in xrange(loops): reverse3( TestString )
print "reverse3: %0.3f" % (time.time()-begin)
Code: Alles auswählen
reverse0: 2.594
reverse1: 2.500
reverse2: 12.953
reverse3: 0.609
Hi,
Der in den obigen Beispielen verwendete regex muss noch folgendemaßen abgeändert werden:
Ich hatte nämlich ganz vergessen das es auch negative Zahlen gibt
Jetzt werden auch diese korrekt wiedergegeben.
Der in den obigen Beispielen verwendete regex muss noch folgendemaßen abgeändert werden:
Code: Alles auswählen
regex = re.compile("^ *\d*\D\d{1,%s}|\d{1,%s}[ -]*" % (groupRange, groupRange))
Jetzt werden auch diese korrekt wiedergegeben.
Gruß, Harry
- jens
- Python-Forum Veteran
- Beiträge: 8502
- Registriert: Dienstag 10. August 2004, 09:40
- Wohnort: duisburg
- Kontaktdaten:
Mir ist da gerade eine Idee gekommen...
Man könnte sich die umkehrung ersparen, wenn man die Zahl vor der RE auffüllt, dann durch RE die tausenderpunkte einfügen läßt und danach, die Aufgefüllten Zeichen wieder abschneidet.
Man könnte sich die umkehrung ersparen, wenn man die Zahl vor der RE auffüllt, dann durch RE die tausenderpunkte einfügen läßt und danach, die Aufgefüllten Zeichen wieder abschneidet.
Hi,cime hat geschrieben:darf ich ma fragen warum das hier so kompliziert gemacht wird?
er will doch nur eine einfache formatierung, die man auch selber schreiben kann, ohne irgendwelche module, oder hab ich das falsch verstanden?
das hier macht exakt das, was er haben will, oder?Code: Alles auswählen
#format_number.py def format_number(number): hinter_komma=str(number%1)[2:] if not hinter_komma: hinter_komma="00" elif len(hinter_komma)==1: hinter_komma+="0" else: hinter_komma=hinter_komma[0:2] string=","+hinter_komma number=int(number) x=1 while 1000**x<=number: string="."+str(number%(1000**x))[0:3]+string x+=1 string=str(number/(1000**(x-1)))+string return string print format_number(input("Zahl: "))
wollt ma fragen, warum ihr meinen code einfach ma so ignoriert. Er hat schließlich ein paar Vorteile:
1. er nutzt keine nicht automatisch schon importierten Funktionen (/Module)
2. er ist mit abstand am schnellsten (sieher unten)
Hier ist er nochmal im Vergleich mit den anderen:
Code: Alles auswählen
# -*- coding: cp1252 -*-
#format_number.py
def format_number_0(number):
if number<0:
vorzeichen="-"
number=-number
else:
vorzeichen=""
hinter_komma=str(number%1)[2:]
if not hinter_komma:
hinter_komma="00"
elif len(hinter_komma)==1:
hinter_komma+="0"
else:
hinter_komma=hinter_komma[0:2]
string=","+hinter_komma
number=int(number)
x=1
while 1000**x<=number:
string="."+str(number%(1000**x))[0:3]+string
x+=1
string=vorzeichen+str(number/(1000**(x-1)))+string
return string
#----------------------------------------------------------------------
import re
#----------------------------------------------------------------------
def format_number_1(
number,
format = "%0.2f",
decimal_char = ",",
group_char = ".",
group_range = 3
):
"""
Nach einer Idee von Voges, HarryH und Jens.
http://www.python-forum.de/viewtopic.php?t=371
"""
def reverse(string):
# ersatz für string[::-1] welches erst ab v2.3 gibt :(
list = re.findall(".",string)
list.reverse()
return "".join(list)
regex = re.compile(
"^ *\d*\D\d{1,%s}|\d{1,%s} *" % (group_range, group_range)
)
return reverse(
group_char.join(
regex.findall(
reverse( (format % number).replace(
".", decimal_char)
)
)
)
)
#----------------------------------------------------------------------
def format_number_2(
number,
format = "%0.2f",
decimal_char = ",",
group_char = ".",
group_range = 3
):
"""
Nach einer Idee von Milan.
http://www.python-forum.de/viewtopic.php?t=371
"""
def split(s, size = group_range):
return map(lambda i: s[i:i + size], xrange(0, len(s), size))
def reverse(s):
l = map(None, s)
l.reverse()
return ('').join(l)
num = (format % number).replace('.', decimal_char)
int_part = num[:num.find(decimal_char)]
return (
reverse(
group_char.join(
split(reverse(int_part))
)
) + num[num.find(decimal_char):]
).replace(" %s" % group_char, " ")
if __name__ == "__main__":
# Testen welche Funktion schneller ist
import time
zahlen = (
66,
1,
2,
3.4,
-5.678,
612345,
612345.555,
987654321.067
)
for x in range(10):
begin = time.time()
for i in range(10000):
for zahl in zahlen:
x = format_number_0(zahl)
print "0:", time.time() - begin
print
begin = time.time()
for i in range(10000):
for zahl in zahlen:
x = format_number_1(zahl)
print "1:", time.time() - begin
print
begin = time.time()
for i in range(10000):
for zahl in zahlen:
x = format_number_2(zahl)
print "2:", time.time() - begin
print
Code: Alles auswählen
0: 0.828000068665
1: 3.93799996376
2: 2.9849998951
0: 0.81299996376
1: 4.17199993134
2: 2.70299983025
0: 0.844000101089
1: 4.0
2: 2.7349998951
0: 0.891000032425
1: 4.09299993515
2: 2.68799996376
0: 0.827999830246
1: 4.15600013733
2: 3.17200016975
0: 0.875
1: 4.0
2: 2.78099989891
0: 0.844000101089
1: 3.96900010109
2: 2.81299996376
0: 0.844000101089
1: 4.01499986649
2: 2.79699993134
0: 0.844000101089
1: 3.95300006866
2: 2.8900001049
0: 0.875
1: 4.53200006485
2: 2.73500013351
-
- Python-Forum Veteran
- Beiträge: 1209
- Registriert: Montag 29. September 2003, 17:18
- Wohnort: Purkersdorf (bei Wien [Austria])
Hi!
Ich werf auch mal eine Version ins Rennen ;
Wie's mit der Performance aussieht, weiß ich nicht (ist das überhaupt wichtig?). Von den vielen [::-1] wird mir zwar schlecht, dafür kann man sich die Zeichen für Komma und Tausendertrennung aussuchen (es soll ja Leute geben, bei denen das Komma ein Punkt ist ).
Gruß, mawe
Ich werf auch mal eine Version ins Rennen ;
Code: Alles auswählen
def commify(number, comma=",", thousand="."):
n = str(number).split(comma)
n[0] = list(str(n[0]))[::-1]
n[0] = thousand.join(
["".join(n[0][i:i+3][::-1]) for i in
range(0,len(n[0]),3)][::-1])
return comma.join(n)
print commify(100000000)
print commify(1000.58,comma=".",thousand=",")
print commify("2,45")
print commify(1234567)
print commify("22343435455423423,2344324234")
Gruß, mawe
- jens
- Python-Forum Veteran
- Beiträge: 8502
- Registriert: Dienstag 10. August 2004, 09:40
- Wohnort: duisburg
- Kontaktdaten:
Kommt IMHO drauf an... Wenn man eine große Tabelle "umformen" will, ist es schon nicht schlecht, das es recht schnell geht...mawe hat geschrieben:Wie's mit der Performance aussieht, weiß ich nicht (ist das überhaupt wichtig?).
Der größte Knackpunkt ist wohl, wenn Python's [::-1] zum umdrehen nicht vorliegt!
Aber wie schon geschrieben, was ist mit der Idee den Zahl-String auf zu füllen, das es gerade teilbar durch drei ist? ich hab gerade andere Sachen um das mal zu testen...
@cime: Sorry, hatte deinen Code glatt übersehen... Mir scheint es IMHO nur sehr lang
-
- Python-Forum Veteran
- Beiträge: 1209
- Registriert: Montag 29. September 2003, 17:18
- Wohnort: Purkersdorf (bei Wien [Austria])
jens, ich weiß nicht ob ich verstanden habe was Du meinst, aber ich hab mal das zusammengestoppelt:
Sieht auch recht performant aus
Code: Alles auswählen
def commify(number, comma=",", thousand="."):
n = str(number).split(comma)
x = len(n[0]) % 3
n[0] = "%s%s" % ("0" * (3-x), n[0])
n[0] = thousand.join([n[0][i:i+3]
for i in range(0,len(n[0]),3)]).lstrip("0%s" % thousand)
return comma.join(n)
- gerold
- Python-Forum Veteran
- Beiträge: 5555
- Registriert: Samstag 28. Februar 2004, 22:04
- Wohnort: Oberhofen im Inntal (Tirol)
- Kontaktdaten:
Hi crime!cime hat geschrieben: wollt ma fragen, warum ihr meinen code einfach ma so ignoriert. Er hat schließlich ein paar Vorteile:
1. er nutzt keine nicht automatisch schon importierten Funktionen (/Module)
2. er ist mit abstand am schnellsten (sieher unten)
Ich habe deinen Code deshalb nicht getestet, da es mir wichtig ist, mindestens das Format, das Dezimaltrennzeichen und das Zeichen für die Gruppierung übergeben zu können. Das Einbauen dieser Variablen schien mir bei deinem Code zu kompliert.
Das Format ist wichtig, um auch einfache Listen realisieren zu können. Z.B. mit %15.2f. Oder auch die Rundung besser im Griff zu haben.
lg
Gerold
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
-
- Python-Forum Veteran
- Beiträge: 1209
- Registriert: Montag 29. September 2003, 17:18
- Wohnort: Purkersdorf (bei Wien [Austria])
Formatieren kannst Du's doch auch bevor die Zahl an die Funktion übergeben wird.gerold hat geschrieben: da es mir wichtig ist, mindestens das Format, das Dezimaltrennzeichen und das Zeichen für die Gruppierung übergeben zu können.