Erstes Problem ist so'n typisches Henne-Ei-Problem: Man braucht einen Spielstand um das Programm zu starten, der wird aber erst in dem Programm gespeichert, dass man nicht ohne starten kann.
Es gibt Zeilen die länger als 80 Zeichen sind, eine ist sogar über 500 Zeichen lang. Da hätte sich zum Beispiel eine mehrzeilige Zeichenkette angeboten, vielleicht sogar mit ordentlicher Einrückung des HTML-Quelltextes.
Vor und nach Operatoren sollte ein Leerzeichen stehen und ``<>`` ist extrem ungebräuchlich, für "ungleich" wird üblicherweise ``!=`` verwendet.
Dann sollte man globale Variablen vermeiden. Auf Modulebene sollten möglichst nur Klassen, Funktionen und Konstanten stehen.
Pickle-Dateien müssen als Binärdateien geöffnet werden, sonst sind sie nicht portabel.
Die Namensgebung leidet manchmal an Abkürzungen, die man auch hätte ausschreiben können.
Warum wird `l[4]` in `load()` in `int` umgewandelt? Die Runde wird doch als ganze Zahl gespeichert, also wird sie auch wieder so geladen. `moegl` könnte `MOEGLICHKEITEN` heissen und eine programmweite Konstante sein und sollte nicht durch `load()` "geschleift" werden.
`formulare` wird im Programm immer von `tuple` nach `list` gewandelt, verändert, und dann wieder in ein `tuple` gewandelt. Das Programm wäre etwas effizienter und kürzer wenn es die ganze Zeit eine Liste wäre, die nur an der einen Stelle im Programm, wo man sie als Tupel braucht, in eines wandeln würde. Wobei man an der Stelle vielleicht die Ausgabe programmatischer erzeugen könnte, schliesslich wiederholt sich in der Zeichenkette eine ganze Menge.
`nichtgetippt` in `ki()` sieht von der Verwendung her nach einem guten Kandidaten für `set()` aus. Die beiden ``for``-Schleifen, die `nichtgetippt` berechnen würden zu dieser Zeile schrumpfen:
In `gewonnen()` wird `formulare` nicht benutzt. Die ``while``-Schleife ist eigentlich eine ``for``-Schleife über `moegl`, die verschachtelten ``if``\s kann man als eines mit ``and``-verknüpften Bedingungen schreiben oder mit einer Schleife. Die beiden Fälle unterscheiden sich nur durch `sp1`/`sp2` und welcher Wert an `b` zugewiesen wird. Und man sollte "magische" Literale vermeiden. Symbolische Konstanten sind viel aussagekräftiger. Ungetestet:
Code: Alles auswählen
NIEMAND, SPIELER_A, SPIELER_B, UNENTSCHIEDEN = xrange(4)
def gewonnen(spieler_a, spieler_b, runde):
ergebnis = NIEMAND
for moeglichkeit in MOEGLICHKEITEN:
for gewinner, spieler in ((SPIELER_A, spieler_a),
(SPIELER_B, spieler_b)):
if all(feld in spieler for feld in moeglichkeit):
ergebnis = gewinner
break
else:
if ergebnis == NIEMAND and runde == 6:
ergebnis = UNENTSCHIEDEN
return ergebnis
In `loeschebut()` würde ich den Index entfernen oder zumindest mit `enumerate()` das "manuelle" hochzählen beseitigen.
Code: Alles auswählen
def loeschebut(formulare):
result = list()
for element in formulare:
if 'input type' in element:
result.append('')
else:
result.append(element)
return result
In Python 2.5 könnte man das sogar in einer "list comprehension" lösen:
Code: Alles auswählen
return [('' if 'input type' in element else element)
for element in formulare]
