Von Dezimal nach Römisch

[xpilz]

Hallo ich versuche zur Zeit normale Zahlen in das Römische Zählsystem umzuwandeln.
Im Groben geht das ja alles gut. Unter anderem gefällt mir das mit dem Dictionary und dem Tuple nicht, aber das ist mir erstmal egal.

Nur beachtet er manche Subtraktionsregeln nicht. Ohne Subtraktionsregel würde die römische Zahl 4 so aussehen: III. Anstatt: IV
z.B. 49 Ist bei mir IL und nicht XLIX wie es eigentlich sein sollte.

Hier mein Skript: http://python-forum.de/pastebin.php?mode=view&s=48
Hier der Wiki - Eintrag: http://de.wikipedia.org/wiki/R%C3%B6mische_Zahlen
Und hier die Subtraktionsregel : http://de.wikipedia.org/wiki/R%C3%B6mis ... tionsregel

mfg, xpilz

[jbs]

Wenn ich das auf die schnelle richtig sehe vergleichst du den Wert mit 1 geringer als dem nächst höheren.

Das heißt du gehst von 50-1 und nicht von 50-10 aus.

[xpilz]

Danke jbs dein Vorschlag hat mich auf eine Idee gebracht.

Jeweils eine von den Römischen Zahlen dürfen nicht 4 mal hintereinander vorkommen. Da würde normalerweise die Regel mit -1 auftauchen.
Hab ein wenig umgedacht und bis 3999 funktioniert jetzt alles. Ist zwar mit ein paar if's und elif's mehr aber es funktioniert. Was jetzt meine Frage noch wäre:

Wie bekomme ich Zeichen wie zB. hier. (siehe 5.000)
D.h. ein V mit nem Strich drüber. Hab ich nämlich noch nie gesehen. Und in der ascii Tabelle scheint so etwas auch nicht vorhanden zu sein.

Das Script ist also nach meiner Meinung fertig (ausgenommen das die Zahl in einem Bereich von 0 und 3.999 liegen muss).
Der Source Code ist hier verfügbar. Feedback oder Kritik sind erwünscht und willkommen .

Edit: Das mit den Zahlen hat sich erledigt.

[Pascal]

Code: Alles auswählen

            if v_mask == 'M':
                rome_text += 'Mↂ '
            elif v_mask == 'C':
                rome_text += 'CM'
            elif v_mask == 'X':
                rome_text += 'XC'
            elif v_mask == 'I':
                rome_text += 'IX'

könntest du wesentlich kürzer schreiben:

Code: Alles auswählen

d = {'M': 'Mↂ ', 'C': 'CM', 'X': 'XC', 'I': 'IX'}
rome_text += d[v_mask]

[xpilz]

Stimmt, dankeschön.

mfg, xpilz

[snafu]

Ganz genau. `switch ... case`-Anweisungen möchte man in Python in aller Regel mittels Wörterbuch umsetzen, da sowas im Grunde nicht viel mehr als ein Mappen der möglichen Werte darstellt.

[xpilz]

Wusste ich noch nicht. Mal so nebenbei. Ich finde, dass die Sache mit dem Dictionary viel eleganter aussieht .

mfg

[snafu]

Übrigens, wenn man `switch()`-Konstrukte leserlicher findet, lässt sich das Wörterbuch natürlich auch wie folgt schreiben.

Code: Alles auswählen

{
    'ↁ ':
        "Mↁ ",
    'D':
        "CD",
    'L':
        "XL",
    'V':
        "IV"
}

...womit wir hinsichtlich des Zeilenverbrauchs quasi wieder am Anfang wären. ;P

[xpilz]

Nett was für Möglichkeiten es so alles gibt.
Ob switch oder Dictionary ist dann aber nur noch Geschmakssache .

mfg, xpliz

[cofi]

Nein, nicht wirklich. Bei einem `switch` kann beliebiger Code stehen und auch Code für mehrere Faelle ausgefuehrt werden ("durchfallen").
Ein Dictionary ist eben nichts anderes als die Zuordnung von einem Wert zu einem Schlüssel, dass man damit die *meisten* Anwendungsfaelle eines `switch` emulieren kann liegt nur daran, dass man in Python einfach mit Funtionsobjekten arbeiten kann.

In Java bräuchte man da schon wieder Interfaces und anonyme Klassen, um was ähnliches zu benutzen.

Worauf ich raus will ist, dass ein `switch` durchaus seine Existenzberechtigung hat und das nicht nur eine Schoenheitsfrage ist. Und das konkrete Problem hätte man wohl auch in Java mit einer `HashTable' geloest

[snafu]

Eben, und es fehlt auch der `default`-Fall. Den könnte man mittels Abfangen eines `KeyErrors` emulieren. Aber im Prinzip will ja keiner in Python unbedingt zu 100% C-Konstrukte nachbauen. Ich persönlich kann nicht mal sonderlich viel mit dem enum-Modul anfangen, aber wer's mag... Manchmal sind solche Dinge ja auch Inspiration für die Maintainer der Stdlib.

[BlackJack]

@cofi: Wobei sich "das" `switch`-Konstrukt auch von Sprache zu Sprache in Feinheiten unterscheiden kann. Zum Beispiel ist das "durchfallen" zum nächsten Fall nicht in allen Sprachen möglich.

[BlackJack]

@snafu: Den `Enum`-Typ den Java mittlerweile hat, finde ich ehrlich gesagt ganz nett.

Und für so etwas kann man auch in Python Verwendung finden. Ein Typ der "aufzählbar" ist, und dessen Exemplare als Konstanten verwendet werden können, und der eine verständliche Zeichenkettenrepräsentation besitzt. In Python werden da oft nichtssagende "magische Zahlen" verwendet.

[cofi]

@BlackJack: Kannst du mir da welche nennen? Mir fallen da jetzt nur C-artige Sprachen ein.
Ich meinte damit jedenfalls `switch`-Konstrukte nicht `switch`-artige wie Lisp `cond`s oder Haskell `case`s.

[snafu]

@BJ: Schön, dass du so ehrlich zu mir bist. *SCNR*

[Leonidas]

Ein Typ der "aufzählbar" ist, und dessen Exemplare als Konstanten verwendet werden können, und der eine verständliche Zeichenkettenrepräsentation besitzt. In Python werden da oft nichtssagende "magische Zahlen" verwendet.

Ja, das stimmt. Aber noch besser finde ich die Typklassen aus Scala (oder das Equivalent in anderen Sprachen wie Haskell oder OCaml), dort können die Exemplare noch zusätzliche Daten tragen und man wird beim Matchen gewarnt falls man irgendwelche Fälle ausgelassen hat. Ich vermute aber eh, dass Pattern Matching eh mein Lieblingsfeature aus statisch getypten Sprachen ist.

[BlackJack]

@cofi: Wenn Du die Konstrukte auf solche einschränkst wie sie in in C funktionieren, dann funktionieren natürlich alle wie in C.

Ich nenne jetzt trotzdem mal Pascal (``Case``/``Of``), einige BASIC-Dialekte (``Select``/``Case``), Io (``Object switch``), Smalltalk (``Object»caseOf:``), Go (``switch``/``case``), und CoffeeScript (``switch``/``when``).

[xpilz]

Nein, nicht wirklich.

Wenn ich beim nächsten mal keine Ahnung habe, halte ich mich wohl besser zurück.

Apropro:
Ich kann hier eh gerade nicht viel mitreden..

Trotzdem Danke. Die Sache mit dem Dictionary gefällt mir sehr .

Viele grüße, xpilz

[cofi]

@cofi: Wenn Du die Konstrukte auf solche einschränkst wie sie in in C funktionieren, dann funktionieren natürlich alle wie in C.

Oh nein ich meinte damit, dass es `switch` heissen soll und nicht eben nur so arbeiten und ich war wirklich daran interessiert `switch` kennenzulernen, die nicht in dieselbe Grube fallen.

@xpilz: Nein das war nicht meine Absicht, ich wollte dir nur verdeutlichen, dass es doch einen Unterschied macht. Nur weil du falsch lagst brauchst du jetzt keine Angst vorm naechsten Post haben

[xpilz]

Nein das war nicht meine Absicht, ich wollte dir nur verdeutlichen, dass es doch einen Unterschied macht. Nur weil du falsch lagst brauchst du jetzt keine Angst vorm naechsten Post haben

Okay.