Zahlen formatieren

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Benutzeravatar
jens
Moderator
Beiträge: 8458
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Beitragvon jens » Donnerstag 7. Juli 2005, 10:16

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?

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
Benutzeravatar
jens
Moderator
Beiträge: 8458
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Beitragvon jens » Donnerstag 7. Juli 2005, 13:32

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

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

1.234.567,89
12.345,100000
1.234


EDIT: Kann es sein, das eine Stringumkehrung mit [::-1] nicht mit älteren Python Versionen funktioniert :(

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
Benutzeravatar
Leonidas
Administrator
Beiträge: 16023
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Beitragvon Leonidas » Donnerstag 7. Juli 2005, 13:53

jens hat geschrieben:EDIT: Kann es sein, das eine Stringumkehrung mit [::-1] nicht mit älteren Python Versionen funktioniert :(


Sie dir mal NeuereVersionen an, dort steht das unter "Slice Syntax".
My god, it's full of CARs! | Leonidasvoice vs Modvoice
Benutzeravatar
jens
Moderator
Beiträge: 8458
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Beitragvon jens » Donnerstag 7. Juli 2005, 14:12

Leonidas hat geschrieben:Sie dir mal NeuereVersionen an, dort steht das unter "Slice Syntax".


Also gibt's das erst seid Python v2.4 :( Schade... Nunja, hier eine Version, dich auch mit >2.4 läuft:

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

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
HarryH
User
Beiträge: 266
Registriert: Freitag 23. Mai 2003, 09:08
Wohnort: Deutschland

re:

Beitragvon HarryH » Donnerstag 7. Juli 2005, 14:27

Hi,

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




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.
Gruß, Harry
Benutzeravatar
jens
Moderator
Beiträge: 8458
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Beitragvon jens » Donnerstag 7. Juli 2005, 15:41

OK, und hier nochmal die Variante für Python >v2.3

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


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?
Zuletzt geändert von jens am Donnerstag 7. Juli 2005, 15:45, insgesamt 2-mal geändert.

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
Benutzeravatar
Leonidas
Administrator
Beiträge: 16023
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Beitragvon Leonidas » Donnerstag 7. Juli 2005, 15:43

jens hat geschrieben:OK, und hier nochmal die Variante für Python >v2.4

Du meinst wohl 2.3 denn 2.3 kennt schon [::-1].
My god, it's full of CARs! | Leonidasvoice vs Modvoice
Benutzeravatar
jens
Moderator
Beiträge: 8458
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Beitragvon jens » Donnerstag 7. Juli 2005, 15:46

Leonidas hat geschrieben:Du meinst wohl 2.3 denn 2.3 kennt schon [::-1].

Oh :oops:

Hab ich oben korregiert...

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5554
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Telfs (Tirol)
Kontaktdaten:

Beitragvon gerold » Donnerstag 7. Juli 2005, 20:47

Hi!

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


Ergebnis:

Code: Alles auswählen

1: 4.18799996376
2: 2.64100003242


mfg
Gerold
:-)
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Benutzeravatar
jens
Moderator
Beiträge: 8458
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Beitragvon jens » Donnerstag 7. Juli 2005, 21:19

Halt, da fehlt noch die ursprüngliche Version und sowieso und überhaupt:

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


Ein guter kompromiss (wenn Python >v2.3) ist wohl die 1b Version... Dort hab ich die reverse() Funktion von Milan eingebaut...

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
BlackJack

Beitragvon BlackJack » Donnerstag 7. Juli 2005, 22:20

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)


`list` ist hier ein ganz schlechter Name, weil man genau hier das eingebaute `list()` benutzen kann, um ohne den regulären Ausdruck auszukommen:

Code: Alles auswählen

In [6]: list("hallo")
Out[6]: ['h', 'a', 'l', 'l', 'o']
Benutzeravatar
jens
Moderator
Beiträge: 8458
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Beitragvon jens » Freitag 8. Juli 2005, 06:18

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

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
HarryH
User
Beiträge: 266
Registriert: Freitag 23. Mai 2003, 09:08
Wohnort: Deutschland

re:

Beitragvon HarryH » Freitag 8. Juli 2005, 06:38

Hi,

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

Ich hatte nämlich ganz vergessen das es auch negative Zahlen gibt :oops:
Jetzt werden auch diese korrekt wiedergegeben.
Gruß, Harry
Benutzeravatar
jens
Moderator
Beiträge: 8458
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Beitragvon jens » Freitag 8. Juli 2005, 06:46

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.

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
cime
User
Beiträge: 152
Registriert: Dienstag 24. Mai 2005, 15:49

Beitragvon cime » Freitag 8. Juli 2005, 07:39

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?

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: "))


das hier macht exakt das, was er haben will, oder?


Hi,

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


Ergebnis:

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

Wer ist online?

Mitglieder in diesem Forum: Google [Bot]