Sådan laver du et Tic Tac Toe-spil i Python med Code Eksempel

Af: Anna Blake Anna Blake
Hours Opdateret

⚡ Smart opsummering

Kryds og Tic Tac Toe i Python er et begyndervenligt projekt, der genskaber det klassiske grid-spil for to spillere. At bygge det styrker kernefærdigheder såsom løkker, betingelsesord, lister, funktioner og rekursion, samtidig med at rækker, kolonner og diagonaler kontrolleres for en vinder.

  • 🎮 Gameplay: To spillere markerer X og O på et firkantet gitter, indtil den ene fuldfører en række, kolonne eller diagonal.
  • 🧩 Kernelogik: Indlejrede lister gemmer brættet, mens løkker og betingede vilkår styrer ture og registrerer en sejr eller uafgjort.
  • 🏗️ Byg trin: Opret brættet, vælg den første spiller, tag input, marker felterne, og tjek derefter for en vinder i hver runde.
  • 🔁 Replay: Et rekursivt play()-kald genstarter kampen, og inputvalidering blokerer optagne eller træk uden for rækkevidde.
  • 🤖 AI-relevans: Det samme bræt er en ideel legeplads for minimax-algoritmen og forstærkningslæringsagenter.
  • 🛠️ Værktøjer: Kun Python og en redaktør som f.eks. PyCharm er nødvendige; der kræves ingen eksterne biblioteker.
Læs mere

Tic Tac Toe spil i Python

Tic Tac Toe spil i Python er et interessant projekt, du kan prøve. Det er et fedt og sjovt projekt, hvor du løser en udfordring, og det kan hjælpe dig med at mestre grundlæggende koncepter i PythonAt lave et sjovt Tic Tac Toe-spil hjælper dig med at udvikle dine færdigheder.

Du kan bruge en god Python redaktør som f.eks. PyCharm eller kommandolinjegrænsefladen.

Hvordan spiller man Tic Tac Toe-spillet?

Tic Tac Toe er et simpelt spil for to spillere, som alle kan spille uden at skulle bruge et spillebræt. Det involverer to spillere, der markerer forskellige felter, indtil spillet ender med en sejr eller uafgjort.

Sådan spiller du Tic Tac Toe-spillet.

Trin 1) Kryds-og-tac-toe-spillet starter med tomme felter i et firkantet gitter. Dette er Kryds-og-tac-toe-brættet.

Trin 2) Begge spillere vælger mellem to symboler, normalt Xs eller Os. Du kan bruge et hvilket som helst andet unikt symbol i spillet.

Trin 3) Den nuværende spiller markerer efter tur ved at udfylde cellerne på Tic Tac Toe-brættet, indtil en spiller udfylder en vindende kombination. Det vil sige en hel række, kolonne eller diagonal med samme fortegn.

Trin 4) Uafgjort er også muligt, hvis alle felter er fulde uden nogen åbenlys vinder.

Krav

Bygning af Tic Tac Toe Python projektet kræver en begynderforståelse af Python programmeringssprog. Det omfatter forståelse af "for"-løkker og iterationer, og hvad en if-sætning bruges til i Python.

Du skal også have Python og en Python teksteditor installeret på din computer for at fuldføre Tic Tac Toe Python projekt. Da dette er et Tic Tac Toe-spil på begynderniveau i Python, du behøver ikke nogen Python bibliotek.

Du kan have brug for nogle debugging-færdigheder for at finde løsninger på fejl i din kode, og du bør også have en tilstrækkelig forståelse af spillets komponenter.

Tic Tac Toe Python Algoritme

Følg disse trin for at oprette et Tic Tac Toe-spil i Python programmeringssprog:

Trin 1) Lav brættet for at starte Tic Tac Toe-spillet.

Trin 2) Bed brugeren om at tage stilling til spillepladens dimensioner.

Trin 3) Vælg den første spiller tilfældigt.

Trin 4) Tic Tac Toe-spillet starter.

Trin 5) Spillere spiller ved at vælge et tomt sted på brættet.

Trin 6) Udfyld det tomme valgte sted med spillerens tegn.

Trin 7) Afgør, om en spiller vinder eller får uafgjort i spillet ved hjælp af spillogikken.

Trin 8) Vis spillepladen efter hvert spil, hvis ingen spiller vinder eller får uafgjort til den anden spiller.

Trin 9) Vis henholdsvis uafgjort eller vinder-besked.

Trin 10) Afslut Tic Tac Toe-spillet med muligheder for at starte et nyt spil.

Fuld Python kode til tic tac toe

# Guru99
# Code developed by Guru99.com
# Guru99 tic-tac-toe game
#Get input
def getInput(prompt, cast=None, condition=None, errorMessage=None):
  while True:
      try:
          val = cast(input(prompt))
          assert condition is None or condition(val)
          return val
      except:
          print(errorMessage or "Invalid input.")
# Print the game board
def printBoard(board):
  print()
  for row in board:
      print(*row)
  print()
# Check if player won using the winning combinations
def checkWin(board):
  # Check rows
  for row in range(len(board)):
      for col in range(len(board)-1):
          if board[row][col] == "_" or board[row][col+1] == "_" or board[row][col] != board[row][col+1]:
              break
      else:
          return True
  # Check column numbers
  for col in range(len(board)):
      for row in range(len(board)-1):
          if board[row][col] == "_" or board[row+1][col] == "_" or board[row][col] != board[row+1][col]:
              break
      else:
          return True
  # Check left diagonal
  for cell in range(len(board)-1):
      if board[cell][cell] == "_" or board[cell+1][cell+1] == "_" or board[cell][cell] != board[cell+1][cell+1]:
          break
  else:
      return True
  # Check right diagonal
  for cell in range(len(board)-1):
      emptyCell = board[cell][len(board)-cell-1] == "_" or board[cell+1][len(board)-cell-2] == "_"
      different = board[cell][len(board)-cell-1] != board[cell+1][len(board)-cell-2]
      if emptyCell or different:
          break
  else:
      return True
  # No win
  return False
# Play tic tac toe game
def play():
  # Introduction
  print("------------\nN-DIMENSIONAL TIC TAC TOE game by guru 99.com \n------------")
  # Set up variables
  N = getInput(prompt="Guru99 says>>> Enter N, the dimensions of the board: ",
               cast=int,
               condition=lambda x: x >= 3,
               errorMessage="Invalid input. Please enter an integer greater than or equal to 3 as explained on guru99.com")
  board = [['_'] * N for _ in range(N)]
  used = 0
  turn = 0
  # Play guru99 tic tac toe game in Python using while infinite loop
  while True:
      # Print guru99 tic tac toe game board
      printBoard(board)
      # Get user pick
      pick = getInput(prompt=f"Player {turn+1} - Pick location (row, col): ",
                      cast=lambda line: tuple(map(int, line.split(" "))),
                      condition=lambda pair: min(pair) >= 0 and max(pair) < N and board[pair[0]][pair[1]] == "_",
                      errorMessage="Invalid input. Please enter a valid, unoccupied location as an integer pair.")
      # Populate location
      board[pick[0]][pick[1]] = "X" if turn == 0 else "O"
      used += 1
      # Check for win
      #Guru99 tutorial
      if checkWin(board):
          printBoard(board)
          print(f"Game over, Player {turn+1} wins.")
          break
      # Check for tie
      elif used == N*N:
          printBoard(board)
          print("Game over. Players have tied the match.")
          print("Guru99.com tic tac toe game ")
          break
      # If no win yet, update next user
      turn = (turn+1)%2
  # Check for rematch
  playAgain = getInput(prompt="Play Guru99 tic tac toe_Game again? (y/n): ",
                       cast=str,
                       condition=lambda ans: ans.strip("\n").lower() in {"y", "n"},
                       errorMessage="Invalid input. Please enter 'y' or 'n'.")
  if playAgain == 'n':
      # End the game
      print("\nGuru99 TicTacToe game ended.")
      return
  else:
      # Rematch
      play()
# Main
if __name__ == '__main__':
  play()

RELATEREDE ARTIKLER

Tic Tac Toe Python Code output

Når du har kørt kildekoden ovenfor, er nedenstående det forventede output for et 3 x 3 Tic Tac Toe-bræt:

------------
N-DIMENSIONAL TIC TAC TOE game by guru 99.com
------------
Guru99 says>>> Enter N, the dimensions of the board: 3

_ _ _

_ _ _

_ _ _

Player 1 - Pick location (row, col): 1 1

_ _ _

_ X _

_ _ _

Player 2 - Pick location (row, col): 0 1

_ O _

_ X _

_ _ _

Player 1 - Pick location (row, col): 1 2

_ O _

_ X X

_ _ _

Player 2 - Pick location (row, col): 0 2

_ O O

_ X X

_ _ _

Player 1 - Pick location (row, col): 1 0

_ O O

X X X

_ _ _

Game over, Player 1 wins.
Play Guru99 tic tac toe_Game again? (y/n):

Fuld Code Fordeling

Oprettelse af Kryds og Tic Tac Toe i Python er simpelt. Lad os dissekere de forskellige funktioner i bidder for at forstå, hvad der sker for hver linje:

Udskrivning af tavlen

Kryds- og bollebrættet er spillets primære display. Python, et displayvindue bruges til at vise spillebrættet.

Her er trinene, der hjælper dig med at lave et bræt til Tic Tac Toe i Python:

Python kode til Tic Tac Toe

def getInput(prompt, cast=None, condition=None, errorMessage=None):
   while True:
       try:
           val = cast(input(prompt))
           assert condition is None or condition(val)
           return val
       except:
           print(errorMessage or "Invalid input.")
# Print the board
def printBoard(board):
   print()
   for row in board:
       print(*row)
   print()
N = getInput(prompt="Guru99 says>>> Enter N, the dimensions of the board: ",
            cast=int,
            condition=lambda x: x >= 3,
            errorMessage="Invalid input. Please enter an integer greater than or equal to 3 as explained on guru99.com")
board = [['_'] * N for _ in range(N)]
used = 0
turn = 0
printBoard(board)

Code produktion:

------------
N-DIMENSIONAL TIC TAC TOE game by guru 99.com
------------
Guru99 says>>> Enter N, the dimensions of the board: 3

_ _ _

_ _ _

_ _ _

Tic Tac Toe Game – vindende arrangement

For at kontrollere, om en spiller vandt, skal vi kontrollere de vindende kombinationer på tværs af rækker, kolonner og diagonaler. Hvis der er en vinder, skal vi vise en vindende besked.

Rækker

  • For rækken tager funktionen hvert på hinanden følgende par af kolonner og kontrollerer for en vindende kombination.
  • Den første spiller, der udfylder rækkerne, vinder. Den anden spiller taber dermed.
  • Hvis et par på hinanden følgende kolonner er ens, er det tydeligt, at alle elementer i den række er ens.
  • Hvis to af dem er forskellige, eller rækken indeholder en tom celle, er der stadig ingen vinder.
  • Vi implementerer så tabende forhold og tilføjer en pause. Hvis nogen af ​​disse tabsbetingelser er sande, havde vi ikke en vinder i den afkrydsede række.
  • Den anden erklæring giver et sandt afkast for at vise, at der er en vinder.
  • Pausen bryder ud af denne løkke for at fortsætte til næste række.

Kolonner

For kolonnerne gentager vi den samme funktion som i rækker. Vi tjekker, om en spiller vandt, efter hver spiller har valgt deres plads.

Diagonal række vinder

For den venstre diagonal bliver opgaven enklere. Vi vil altid sammenligne cellerne i diagonalerne. Men hvis der ikke er nogen vinder, kan vi fortsætte til den næste instruktion.

Spil logik

Dette er den vigtigste spilfunktion. Til dette kan vi bruge variabler, der gemmer information.

  • Den første variabel er tavlestørrelsen gemt i "N". Spillet får brættets størrelse efter at have bedt brugeren om at indtaste et tal.
  • Så når du indtaster værdien, behandles den.
  • Vi opretter også en fejlmeddelelse for at vise spillerne, når et ugyldigt tal er indtastet.
  • Vi kan så oprette to variable, der udfylder et "X" eller et "O", når en celle er udfyldt.
  • Vis derefter spillerne spillepladen. Efter dette, få spillerens input.
  • Logikken vil derefter markere den valgte celle som udfyldt og tjekke for en sejr eller uafgjort.
  • Hvis der ikke er nogen vinder, beder spillet den næste spiller om at spille. Hvis der er en sejr eller uafgjort, kan spillet spørge brugerne, om de vil have et nyt spil.

Ofte Stillede Spørgsmål

Ja. Tic Tac Toe er et klassisk begynderprojekt, der forvandler loops, betingede sætninger og funktioner til et fungerende spil. Det opbygger selvtillid, forstærker kernesyntaks og forbereder dig til større projekter uden behov for eksterne biblioteker.

Den forstærker indlejrede lister til brættet, til løkker og while-løkker til ture, if-sætninger til win-tjek, funktioner til struktur og rekursion til genstart. Disse grundlæggende elementer overføres direkte til mere avancerede programmer. Python programmer.

Ja. Ud over konsolversionen tilføjer biblioteker som Tkinter og Pygame klikbare knapper, et tegnet gitter og museindtastning. Spillets logik forbliver den samme; kun visnings- og inputlagene ændres.

Tic Tac Toe er et løst spil. Når begge spillere spiller optimalt, kan enhver trussel blokeres, så ingen kan fremtvinge en sejr. Derfor ender en fejlfri kamp, ​​menneske eller computer, altid uafgjort.

En grundlæggende konsolversion tager en nybegynder en til tre timer, når loops og betingede parametre føles fortrolige. Tilføjelse af inputvalidering, et skalerbart board eller en grafisk brugerflade forlænger projektet til en weekend med øvelse.

Erstat én spiller med en minimax-funktion. Den udforsker rekursivt alle mulige træk, scorer sejre, tab og uafgjorte, og vælger derefter det træk med det bedst garanterede resultat. På et lille bræt gør dette computeren umulig at slå.

Ja. Forstærkende læringsmidler som Q-learning forbedres ved at spille tusindvis af spil og belønne vindende træk. Brædder gemmes som arrays med nusset, hvilket lader modellen lære en næsten optimal strategi uden fastlagte regler.

Ja. GitHub Copilot og lignende AI-assistenter kan scaffolde boardet, dreje loops og vinde checks fra en kort prompt. Behandl outputtet som et første udkast, og test derefter selv edge cases som uafgjorte og ugyldige træk.

Opsummer dette indlæg med: