TicTacToe in Python

[Atakan2000]

Hallo Leute und zwar habe ich folgendes Problem.

Aufgabenstellung ist das ich eine Funktion schreiben soll die auf einem TicTacToe Board auf einer bestimmten Stelle auf dem Board das Zeichen "X" oder "O" platziert. In dem Fall ist die Funktion set_field(board, row, col, value)

Nun habe ich auch bereits die Funktion geschrieben die das Board erstellt, jetzt weiß ich aber nicht wie ich bei set_field auf dieses Board zugreifen soll damit es an der Stelle [1][2] z.B das Symbol "X" platziert.

Hier ist alles was ich bis jetzt versucht habe:


def make_board(size):
matrix = []
for i in range(size):
matrix.append(['','',''])
return matrix

def printBoard(board):
print('-------')
for i in board:
print('|' + i[0] + '|' + i[1] + '|' + i[2]+ '|')
print('-------')

board = make_board(3)
printBoard(board)


def set_field(board, row, col): # row = zeile ; col = spalte ; value = X oder O
for row in range(len(board)):
for col in range(len(board)):



ich muss halt irgendwie auf die verschachtelte Liste zugreifen und dort das Symbol platzieren aber ich hänge hier leider.
Würde mich freuen wenn ihr mir Tipps geben könntet.

Liebe Grüße Atakan.

[__blackjack__]

@Atakan2000: Der Tipp wäre, dass Du dazu keine Schleifen brauchst. Und das Du im Grunde im Beitragstext schon geschrieben hast wie man auf ein Element gezielt zugreifen kann. Arbeite noch mal Deine Unterlagen (oder das Tutorial in der Python-Dokumentation) durch, wo es um Listen geht. Und wie man auf Elemente zugreift, wenn man den Index hat an dem man zugreifen möchte.

Anmerkungen zum Code: Namen schreibt man in Python klein_mit_unterstrichen. Ausnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (PascalCase). `printBoard()` sollte also `print_board()` heissen. Bei den beiden anderen Funktionen hast Du das ja richtig gemacht.

Auf Modulebene sollte nur Code stehen der Konstanten, Klassen, und Funktionen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst. Noch schlechter als das überhaupt auf Modulebene zu schreiben, ist es das Hauptprogramm unübersichtlich zwischen Funktionsdefinitionen zu verteilen.
ei `make_board()` macht das `size`-Argument so keinen Sinn. Denn wenn man da etwas anderes als 3 übergibt, ändert sich nur die Anzahl der Zeilen des Spielfelds — die Anzahl der Spalten ist weiterhin 3. Entweder sollte `size` auf beides wirken, oder man sollte das nicht als Argument haben.

Die leeren Felder sollten nicht aus leeren Zeichenketten bestehen, sondern aus Zeichenketten mit einem Leerzeichen. Sonst sieht die Ausgabe komisch/unregelmässig aus wenn man anfängt leere Felder durch "X" oder "O" zu ersetzen.

Die Schleife in `make_board()` lässt sich leicht als „list comprehension“ ausdrücken.

`i` ist kein guter Name für irgend etwas das keine ganze Zahl ist. Insbesondere als Laufvariable in einer Schleife. Das in `print_board()` sollte wohl eher `row` heissen, denn dafür steht es: für eine Zeile des Spielfelds.

In der Ausgabefunktion wird auch wieder klar, das `size` in diesem Programm nicht wirklich etwas variables ist, denn auch hier ist fest kodiert, dass das Spielfeld exakt drei Spalten hat.

Zusammenstückeln von Werten und Zeichenketten mit ``+`` ist eher BASIC als Python. Python hat dafür Zeichenkettenformatierung mit der `format()`-Methode und f-Zeichenkettenliteralen. Und hier kann man auch noch die `join()`-Methode von Zeichenketten sinnvoll nutzen statt manuell die drei Indexwerte hinzuschreiben.

Bei `set_field()` fehlt ein Argument. Und man sollte keine Namen kryptisch abkürzen. Wenn man `column` meint, sollte man nicht nur `col` schreiben.

Mit den, wie gesagt völlig unnötigen, Schleifen in der Funktion würdest Du die beiden Argumente auch sofort mit anderen Werten ersetzen, so dass die übergebenen Werte so verloren gingen.

Code: Alles auswählen

#!/usr/bin/env python3


def make_board():
    return [[" ", " ", " "] for _ in range(3)]


def print_board(board):
    print("-------")
    for row in board:
        print(f"|{'|'.join(row)}|")
        print("-------")


def set_field(board, row, column, value):
    ...


def main():
    board = make_board()
    print_board(board)


if __name__ == "__main__":
    main()