@Sarapheus: Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst.
Wenn man dann noch das mit dem Buchstaben verdrehen in eine eigene Funktion verschiebt, kann man das Modul auch importieren und diese Funktion interaktiv oder programmatisch testen. Zum Beispiel in einer Python-Shell oder mit Unittests.
Dann kann man beispielsweise schnell feststellen, dass die Funktion einen Fehler hat:
Da sollte nur "a" bei heraus kommen, würde ich mal sagen.
Das ``random.seed`` hat keinen Effekt. Es hätte selbst dann nicht wirklich einen Effekt wenn man diese Funktion tatsächlich aufrufen würde, denn das passiert auch schon automatisch wenn das `random`-Modul das erste mal importiert wird. Wo immer Du das her hast, das scheint von einem Programmierer geschrieben worden zu sein der das so von woanders kennt.
Grunddatentypen haben in Namen nichts zu suchen. Es kommt öfter vor das man den Datentyp im Laufe der Programmentwicklung mal ändert, dann hat man entweder falsche, irreführende Namen im Programm, oder man muss überall alle betroffenen Namen ändern. Das macht nur unnötig Arbeit und ist fehleranfällig.
Hinter dem Namen `buchstabe` vermutet der Leser einen Buchstaben, aber keinen Index.
Der Name `anordnung` wird nicht verwendet. Die Schleife dient ja nur dazu den Code eine bestimmte Anzahl mal auszuführen. Wenn man so eine Variable nicht braucht, ist die Konvention sie `_` zu nennen, damit der Leser weiss dass die nicht verwendet wird, und sich nicht wundert ob der Code fehlerhaft oder unvollständig ist.
Wenn man bei `randint()` grundsätzlich 1 vom zweiten Argument abzieht, will man eigentlich `randrange()` verwenden.
Das ``buchstaben.remove(buchstaben[zufall])`` ist unnötig ineffizient. `remove()` sucht den Index von dem Wert der übergeben wurde, aber diesen Index kennen wir ja schon: `zufall`. ``del buchstaben[zufall]`` wäre da der direkte Weg.
Zwischenbilanz:
Code: Alles auswählen
def buchstaben_mischen(wort):
neues_wort = ""
buchstaben = []
for i in range(len(wort)):
if i == 0:
neues_wort += wort[i]
elif i != len(wort) - 1:
buchstaben.append(wort[i])
if i == len(wort) - 1:
for _ in range(len(buchstaben)):
j = random.randrange(0, len(buchstaben))
neues_wort += buchstaben[j]
del buchstaben[j]
neues_wort += wort[i]
return neues_wort
Was hier furchtbar unübersichtlich ist, ist das *alles* in dieser ``for``-Schleife steckt. Auch die Behandlung vom ersten und letzten Buchstaben die sich ja vom Rest unterscheidet. Aus dem Code wird nur mit Mühe ersichtlich das es eigentlich: Erster Buchstabe + gemischte Mitte + letzter Buchstabe ist. Wobei erster und letzter Buchstabe eben nicht wirklich *in* die Schleife hinein gehört.
Wenn man das nacheinander macht und die ``for``-Schleife über die Anzahl der Mittelbuchstaben durch eine einfacherere ``while``-Schleife ersetzt, kann das so aussehen:
Code: Alles auswählen
def buchstaben_mischen(wort):
neues_wort = ""
mittel_buchstaben = []
for i in range(1, len(wort) - 1):
mittel_buchstaben.append(wort[i])
while mittel_buchstaben:
j = random.randrange(0, len(mittel_buchstaben))
neues_wort += mittel_buchstaben.pop(j)
return wort[0] + neues_wort + wort[-1]
Das erstellen der `mittel_buchstaben` kann man durch „slicing“ und `list()` deutlich abkürzen, und statt die Buchstaben dann einzeln zufällig zu wählen und aus der Liste zu entfernen, kann man auch einfach `random.shuffle()` zum mischen des Listeninhalts verwenden, womit das hier übrig bleibt:
Code: Alles auswählen
def buchstaben_mischen(wort):
mittel_buchstaben = list(wort[1:-1])
random.shuffle(mittel_buchstaben)
wort = wort[0] + "".join(mittel_buchstaben) + wort[-1]
return wort
Da ist immer noch der Fehler aus der ursprünglichen Funktion enthalten ("a" → "aa") und ein neuer — diese Funktion kommt nicht mit der leeren Zeichenkette als eingabe klar. Beides lässt sich aber leicht beheben und das überlasse ich mal als Aufgabe.
