Tic-Tac-Toe in Python programmieren: Schritt-für-Schritt-Tutorial mit Code

Tic-Tac-Toe (Drei gewinnt) ist ein klassisches Einsteigerprojekt, um Python-Grundlagen wie Schleifen, Bedingungen, Funktionen und Datenstrukturen praxisnah anzuwenden. Dieses Tutorial führt Sie durch die Erstellung eines flexiblen, n-dimensionalen Spiels für die Konsole.

Spielregeln kurz & bündig

• Zwei Spieler setzen abwechselnd ihr Symbol (X und O) auf ein quadratisches Spielfeld (Standard 3×3).
• Wer zuerst eine komplette Reihe, Spalte oder Diagonale mit seinem Symbol füllt, gewinnt.
• Sind alle Felder belegt ohne Gewinner → Unentschieden.

Voraussetzungen

• Python 3.x installiert
• Editor/IDE (VS Code, PyCharm, Thonny, …)
• Grundkenntnisse: Variablen, Listen, Schleifen (for, while), Bedingungen (if/else), Funktionen, Eingabe (input())

Algorithmus-Überblick

1. Spielfeldgröße N einlesen (Minimum 3).
2. N x N-Board als Liste von Listen initialisieren (gefüllt mit _ für leer).
3. Startspieler zufällig oder fest (hier: Spieler 1 = X) wählen.
4. Spiel-Schleife:
   1. Board anzeigen.
   2. Aktuellen Spieler nach Zug fragen (Zeile, Spalte).
   3. Eingabe validieren: im Bereich? Feld frei?
   4. Feld besetzen.
   5. Gewinn prüfen (Zeilen, Spalten, Diagonalen).
   6. Bei Gewinn → Board zeigen, Sieger verkünden, Ende.
   7. Bei vollem Board ohne Sieger → Unentschieden, Ende.
   8. Spieler wechseln.
5. Neue Runde anbieten.

Vollständiger, kommentierter Python-Code

""" Tic-Tac-Toe N-dimensional (Konsole) – Guru99 Tutorial """

def get_input(prompt, cast=None, condition=None, error_msg=None):
    """Robuste Eingabe mit Validierung und Typ-Konvertierung."""
    while True:
        try:
            val = cast(input(prompt)) if cast else input(prompt)
            if condition is None or condition(val):
                return val
        except Exception:
            pass
        print(error_msg or "Ungültige Eingabe. Bitte versuchen Sie es erneut.")

def print_board(board):
    """Spielfeld formatiert ausgeben."""
    print()
    for row in board:
        print(" ".join(row))
    print()

def check_win(board):
    """Prüft alle Gewinnkombinationen: Zeilen, Spalten, 2 Diagonalen."""
    n = len(board)
    # Zeilen
    for row in range(n):
        if all(board[row][col] == board[row][0] != "_" for col in range(n)):
            return True
    # Spalten
    for col in range(n):
        if all(board[row][col] == board[0][col] != "_" for row in range(n)):
            return True
    # Hauptdiagonale (links oben → rechts unten)
    if all(board[i][i] == board[0][0] != "_" for i in range(n)):
        return True
    # Nebendiagonale (rechts oben → links unten)
    if all(board[i][n-1-i] == board[0][n-1] != "_" for i in range(n)):
        return True
    return False

def play():
    print("=" * 40)
    print("N-DIMENSIONALES TIC-TAC-TOE (Python)")
    print("=" * 40)

    # Board-Größe einlesen (min. 3)
    n = get_input(
        prompt="Spielfeldgröße N (>= 3): ",
        cast=int,
        condition=lambda x: x >= 3,
        error_msg="Bitte ganze Zahl >= 3 eingeben."
    )

    board = [["_"] * n for _ in range(n)]
    used = 0
    turn = 0  # 0 = Spieler 1 (X), 1 = Spieler 2 (O)

    while True:
        print_board(board)

        # Zug einlesen & validieren
        pick = get_input(
            prompt=f"Spieler {turn+1} ({'X' if turn == 0 else 'O'}) – Zug (Zeile Spalte): ",
            cast=lambda s: tuple(map(int, s.split())),
            condition=lambda p: 0 <= p[0] < n and 0 <= p[1] < n and board[p[0]][p[1]] == "_",
            error_msg=f"Ungültig! Zwei Zahlen 0-{n-1} für freies Feld eingeben."
        )

        # Feld besetzen
        board[pick[0]][pick[1]] = "X" if turn == 0 else "O"
        used += 1

        # Gewinn prüfen
        if check_win(board):
            print_board(board)
            print(f"🎉 Spieler {turn+1} gewinnt!")
            break

        # Unentschieden prüfen
        if used == n * n:
            print_board(board)
            print("🤝 Unentschieden – das Board ist voll.")
            break

        # Spieler wechseln
        turn = 1 - turn

    # Revanche?
    again = get_input(
        prompt="Noch eine Runde? (j/n): ",
        cast=str.lower,
        condition=lambda a: a in ("j", "n"),
        error_msg="Bitte 'j' oder 'n' eingeben."
    )
    if again == "j":
        print()
        play()  # Rekursiver Neustart (einfacher für Demo)
    else:
        print("\nDanke fürs Spielen! Auf Wiedersehen.")

if __name__ == "__main__":
    play()

Code-Analyse: Die Kernfunktionen

get_input() – Robuste Benutzereingabe

Zentrale Hilfsfunktion, die:

• Eingabeaufforderung anzeigt.
• Typ-Konvertierung (cast) durchführt (z. B. int, lambda für Tupel).
• Bedingung (condition) prüft (z. B. Bereich, freies Feld).
• Bei Fehler error_msg anzeigt und Schleife wiederholt.

Vermeidet Abstürze durch falsche Eingaben und hält den Code sauber (DRY).

print_board() – Saubere Ausgabe

Nutzt " ".join(row) für formatierte Zeilen ohne Listen-Klammern/Kommas.

check_win() – Effiziente Gewinnprüfung

Nutzt all() mit Generator-Ausdrücken für prägnante, lesbare Prüfung aller 4 Gewinnrichtungen. Die Bedingung == board[0][0] != "_" stellt sicher, dass nur besetzte, identische Felder zählen.

Hauptschleife in play()

Klare Struktur: Anzeigen → Eingabe → Aktualisieren → Prüfen → Wechseln. Variablen used (Zugzähler) und turn (0/1) steuern den Fluss.

Beispielausgabe (3×3)

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
N-DIMENSIONALES TIC-TAC-TOE (Python)
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
Spielfeldgröße N (>= 3): 3

_ _ _
_ _ _
_ _ _

Spieler 1 (X) – Zug (Zeile Spalte): 1 1

_ _ _
_ X _
_ _ _

Spieler 2 (O) – Zug (Zeile Spalte): 0 1

_ O _
_ X _
_ _ _
... (weiter bis Gewinn/Unentschieden) ...

Erweiterungsideen für Fortgeschrittene

• KI-Gegner: Minimax-Algorithmus mit Alpha-Beta-Pruning implementieren.
• GUI: Mit tkinter, PyQt oder pygame grafische Oberfläche bauen.
• Netzwerk-Multiplayer: socket oder websockets für Online-Spiel.
• Highscores/Statistiken: In Datei (json/sqlite3) speichern.
• Tests: pytest für check_win() & get_input() schreiben.

Fazit

Dieses Tic-Tac-Toe demonstriert Kernkonzepte der Python-Programmierung in einem vollständigen, spielbaren Projekt. Die modulare Struktur (get_input, print_board, check_win) ist vorbildlich für größere Programme. Experimentieren Sie mit Erweiterungen – der beste Weg, Python zu meistern!