Geekflare wird von unserem Publikum unterstützt. Wir können Affiliate-Provisionen durch den Kauf von Links auf dieser Website verdienen.
Teilen:

Wie erstelle ich ein Tic-Tac-Toe-Spiel in Python?

Tic-Tac-Toe-Python
Invicti Web Application Security Scanner – die einzige Lösung, die eine automatische Verifizierung von Schwachstellen mit Proof-Based Scanning™ bietet.

Lassen Sie uns ein einfaches Tic Tac Toe-Spiel in Python erstellen. Es wird Ihnen helfen, eine Spiellogik aufzubauen und zu verstehen, wie man Code strukturiert.

Gaming ist eine der Unterhaltung, die Menschen haben. Wir können verschiedene Arten von Spielen im Web, auf dem Handy, auf dem Desktop usw. finden. Wir sind jetzt nicht hier, um eines dieser schweren Spiele zu machen. Wir werden ein CLI-Tic-Tac-Toe-Spiel erstellen mit Python.

Wenn Sie mit Tic Tac Toe nicht vertraut sind, spielen Sie es visuell hier verstehen. Keine Sorge, auch wenn Sie es nicht verstehen, wir werden es sehen.

Tic Tac Toe

Das Tutorial ist in drei verschiedene Abschnitte unterteilt. Im ersten Abschnitt lernen Sie das Tic-Tac-Toe-Spiel kennen. Danach sehen wir einen Algorithmus, der uns hilft, die Spiellogik zu entwickeln. Schließlich sehen wir den strukturierten Code und seine Erklärung.

Sie können den ersten Abschnitt überspringen, wenn Sie bereits wissen, wie man Tic Tac Toe spielt.

Lassen Sie uns also ohne weiteres in unseren ersten Abschnitt eintauchen.

Tic Tac Toe spielen

Es werden zwei Spieler in einem Spiel sein. Zwei Zeichen stehen für jeden Spieler. Die im Spiel verwendeten allgemeinen Zeichen sind funktioniert O. Endlich gibt es eine Tafel mit 9 Boxen.

Sehen Sie das Tic-Tac-Toe-Board visuell.

Tic-Tac-Toe-Board
Tic-Tac-Toe-Board

Das Gameplay wird wie folgt sein.

  • Zuerst legt ein Benutzer sein Schild in eines der verfügbaren leeren Kästchen.
  • Als nächstes legt der zweite Benutzer sein Zeichen in eines der verfügbaren leeren Kästchen.
  • Das Ziel der Spieler ist es, ihre jeweiligen Schilder komplett reihen- oder spaltenweise oder diagonal zu platzieren.
  • Das Spiel geht weiter, bis ein Spieler das Spiel gewinnt oder es unentschieden endet, indem alle Kästchen ohne ein gewinnendes Spiel ausgefüllt werden.

Sehen wir uns einige Gameplays visuell an.

Tic-Tac-Toe-Gewinn-Gameplay
Tic-Tac-Toe-Gewinn-Gameplay

Der Spieler gewinnt das Spiel im obigen Gameplay. Alle Kästchen füllen sich diagonal mit Zeichen. Somit gewinnt der jeweilige Spieler das Spiel.

Es gibt insgesamt 8 Möglichkeiten, das gleiche Zeichen zu arrangieren und das Spiel zu gewinnen. Sehen wir uns alle 8 Arrangements an, die das Spiel gewinnen können.

Tic Tac Toe-Gewinnvereinbarungen
Tic Tac Toe-Gewinnvereinbarungen

Und schließlich füllt ein Unentschieden das Brett ohne Gewinnvereinbarung. Ich hoffe, Sie verstehen jetzt, wie man Tic Tac Toe macht.

Jetzt ist es Spielzeit für Sie. Du darfst gehen hier und spielen Sie es, um das Gameplay vollständig zu verstehen. Lassen Sie es, wenn Sie es bereits haben.

Jetzt ist es an der Zeit, den Algorithmusabschnitt zu verschieben.

 Algorithmus

Wir werden nun den Algorithmus zum Schreiben des Codes diskutieren. Dieser Algorithmus hilft Ihnen, Code in jedem zu schreiben Programmiersprache Ihrer Wahl. Mal sehen, wie es gemacht wird.

  • Erstellen Sie ein Board mit einem 2-dimensionalen Array und initialisieren Sie jedes Element als leer.
    • Sie können leer mit einem beliebigen Symbol darstellen. Hier verwenden wir einen Bindestrich. '-'.
  • Schreiben Sie eine Funktion, um zu überprüfen, ob die Tafel gefüllt ist oder nicht.
    • Iteriere über das Board und kehre zurück false wenn die Tafel ein leeres Zeichen enthält oder sonst zurückkehren true.
  • Schreiben Sie eine Funktion, um zu überprüfen, ob ein Spieler gewonnen hat oder nicht.
    • Wir müssen alle Möglichkeiten überprüfen, die wir im vorherigen Abschnitt besprochen haben.
    • Überprüfen Sie alle Zeilen, Spalten und zwei Diagonalen.
  • Schreiben Sie eine Funktion, um das Board anzuzeigen, da wir es den Benutzern während des Spielens mehrmals zeigen.
  • Schreiben Sie eine Funktion, um das Spiel zu starten.
    • Wählen Sie den ersten Zug des Spielers zufällig aus.
    • Schreiben Sie eine Endlosschleife, die unterbrochen wird, wenn das Spiel vorbei ist (entweder Gewinn oder Unentschieden).
      • Zeigen Sie dem Benutzer das Brett, um den Punkt für den nächsten Zug auszuwählen.
      • Bitten Sie den Benutzer, die Zeilen- und Spaltennummer einzugeben.
      • Aktualisiere den Spot mit dem entsprechenden Spielerzeichen.
      • Überprüfen Sie, ob der aktuelle Spieler das Spiel gewonnen hat oder nicht.
      • Wenn der aktuelle Spieler das Spiel gewonnen hat, drucken Sie eine Gewinnnachricht und unterbrechen Sie die Endlosschleife.
      • Überprüfen Sie als nächstes, ob die Tafel gefüllt ist oder nicht.
      • Wenn die Tafel gefüllt ist, drucken Sie die Zeichennachricht aus und unterbrechen Sie die Endlosschleife.
    • Zeigen Sie dem Benutzer schließlich die endgültige Ansicht des Boards.

Vielleicht können Sie sich vorstellen, was passiert. Keine Sorge, auch wenn Sie es nicht ganz verstanden haben. Sie erhalten mehr Klarheit, wenn Sie den Code sehen.

Lassen Sie uns also in den Codeabschnitt springen. Ich nehme an, du hast Python installiert auf Ihrem PC, um den Code auszuprobieren.

Code

Gehen Sie den folgenden Code durch.

import random


class TicTacToe:

    def __init__(self):
        self.board = []

    def create_board(self):
        for i in range(3):
            row = []
            for j in range(3):
                row.append('-')
            self.board.append(row)

    def get_random_first_player(self):
        return random.randint(0, 1)

    def fix_spot(self, row, col, player):
        self.board[row][col] = player

    def is_player_win(self, player):
        win = None

        n = len(self.board)

        # checking rows
        for i in range(n):
            win = True
            for j in range(n):
                if self.board[i][j] != player:
                    win = False
                    break
            if win:
                return win

        # checking columns
        for i in range(n):
            win = True
            for j in range(n):
                if self.board[j][i] != player:
                    win = False
                    break
            if win:
                return win

        # checking diagonals
        win = True
        for i in range(n):
            if self.board[i][i] != player:
                win = False
                break
        if win:
            return win

        win = True
        for i in range(n):
            if self.board[i][n - 1 - i] != player:
                win = False
                break
        if win:
            return win
        return False

        for row in self.board:
            for item in row:
                if item == '-':
                    return False
        return True

    def is_board_filled(self):
        for row in self.board:
            for item in row:
                if item == '-':
                    return False
        return True

    def swap_player_turn(self, player):
        return 'X' if player == 'O' else 'O'

    def show_board(self):
        for row in self.board:
            for item in row:
                print(item, end=" ")
            print()

    def start(self):
        self.create_board()

        player = 'X' if self.get_random_first_player() == 1 else 'O'
        while True:
            print(f"Player {player} turn")

            self.show_board()

            # taking user input
            row, col = list(
                map(int, input("Enter row and column numbers to fix spot: ").split()))
            print()

            # fixing the spot
            self.fix_spot(row - 1, col - 1, player)

            # checking whether current player is won or not
            if self.is_player_win(player):
                print(f"Player {player} wins the game!")
                break

            # checking whether the game is draw or not
            if self.is_board_filled():
                print("Match Draw!")
                break

            # swapping the turn
            player = self.swap_player_turn(player)

        # showing the final view of board
        print()
        self.show_board()


# starting the game
tic_tac_toe = TicTacToe()
tic_tac_toe.start()

Sehen Sie sich die Beispielausgabe des Codes an.

$ python tic_tac_toe.py 
Player X turn
- - -
- - -
- - -
Enter row and column numbers to fix spot: 1 1

Player O turn
X - -
- - -
- - -
Enter row and column numbers to fix spot: 2 1

Player X turn
X - -
O - -
- - -
Enter row and column numbers to fix spot: 1 2

Player O turn
X X -
O - -
- - -
Enter row and column numbers to fix spot: 1 3

Player X turn
X X O
O - -
- - -
Enter row and column numbers to fix spot: 2 2

Player O turn
X X O
O X -
- - -
Enter row and column numbers to fix spot: 3 3

Player X turn
X X O        
O X -        
- - O
Enter row and column numbers to fix spot: 3 2

Player X wins the game!

X X O
O X -
- X O

Einige wichtige Punkte, die Ihnen helfen, die Struktur des Codes zu verstehen.

  • Wir haben eine Klasse verwendet, um alle Methoden an einem Ort zu haben. Es kann auch leicht ein wiederverwendbares Bundle in einem anderen Code sein.
  • Als nächstes haben wir für jede Verantwortung unterschiedliche Funktionen definiert, auch wenn es sich um eine kleine Aufgabe handelt. Es hilft, den Code mit Leichtigkeit zu pflegen.
  • Die beiden oben genannten Ansätze helfen uns, die App mühelos zu aktualisieren, wenn wir das Spiel aktualisieren möchten.

Passen Sie die Struktur gerne an und verbessern Sie sie basierend auf Ihrem Projekt. Die Strukturierung des Codes ist nicht beschränkt.

Zusammenfassung

Hurra! 😎 Du hast ein Spiel komplett von Grund auf neu erstellt. Es ist nicht eines der visuellen Spiele, die wir täglich spielen. Aber es hilft Ihnen, Logik zu schreiben und eine saubere Struktur im Code zu erhalten. Befolgen Sie ähnliche Richtlinien, um einige interessante Spiele wie dieses zu erstellen. Sie können ähnliche Spiele finden, wenn Sie einige Jahre in Ihre Kindheit zurückgehen.

Viel Spaß beim Codieren! 👩💻

Als nächstes untersuchen Sie, wie es geht Zahlenrätselspiel erstellen funktioniert Unit-Tests mit dem Python-Unittest-Modul.

Danke an unsere Sponsoren
Weitere großartige Lektüre zum Thema Entwicklung
Treiben Sie Ihr Geschäft an
Einige der Tools und Dienste, die Ihr Unternehmen beim Wachstum unterstützen.
  • Invicti verwendet das Proof-Based Scanning™, um die identifizierten Schwachstellen automatisch zu verifizieren und innerhalb weniger Stunden umsetzbare Ergebnisse zu generieren.
    Versuchen Sie es mit Invicti
  • Web-Scraping, Wohn-Proxy, Proxy-Manager, Web-Unlocker, Suchmaschinen-Crawler und alles, was Sie zum Sammeln von Webdaten benötigen.
    Versuchen Sie es mit Brightdata
  • Semrush ist eine All-in-One-Lösung für digitales Marketing mit mehr als 50 Tools in den Bereichen SEO, Social Media und Content-Marketing.
    Versuchen Sie es mit Semrush
  • Intruder ist ein Online-Schwachstellenscanner, der Cyber-Sicherheitslücken in Ihrer Infrastruktur findet, um kostspielige Datenschutzverletzungen zu vermeiden.
    MIT DER INTELLIGENTEN SCHADENKALKULATION VON Intruder