Kółko i krzyżyk w Pythonie – prosty projekt dla początkujących

Gra w kółko i krzyżyk w Pythonie to idealny pierwszy projekt programistyczny: jest prosty, a jednocześnie pozwala przećwiczyć zmienne, listy, pętle, warunki, funkcje i podstawową logikę programu. Poniżej znajdziesz gotowy, rozbudowany poradnik – od instalacji Pythona, przez analizę krok po kroku, aż po kompletny kod, który możesz od razu uruchomić lub opublikować.

Tu przeczytasz

1. Dlaczego kółko i krzyżyk to dobry projekt na start?
2. Wymagania wstępne
3. Koncepcja gry – co program ma robić?
4. Reprezentacja planszy w Pythonie
5. Układ pól na planszy
6. Funkcje – dzielimy program na logiczne części
7. Gotowy kod gry w kółko i krzyżyk w Pythonie (wersja konsolowa)
8. Jak uruchomić grę – instrukcja dla początkujących
9. Szczegółowe omówienie logiki programu
10. Możliwe rozszerzenia projektu
12. Propozycja struktury artykułu do publikacji

1. Dlaczego kółko i krzyżyk to dobry projekt na start?

Kółko i krzyżyk (tic-tac-toe) to gra dla dwóch osób, które na zmianę stawiają X i O na planszy 3×3. Wygrywa gracz, który jako pierwszy ułoży swój symbol w jednym z poniższych układów:

całym wierszu,
całej kolumnie,
jednej z dwóch przekątnych.

Z perspektywy nauki Pythona taki projekt jest szczególnie wartościowy:

jest krótki – cały kod mieści się w jednym pliku,
wykorzystuje m.in.:
- listy (plansza),
- pętle (tury graczy, ponowna gra),
- instrukcje if/elif/else (sprawdzanie ruchów, zwycięstwa, błędów),
- funkcje (podział logiki na czytelne części),
dobrze nadaje się do rozbudowy (sztuczna inteligencja, grafika, wersja sieciowa).

2. Wymagania wstępne

2.1. Co musisz umieć?

Wystarczy podstawowa znajomość następujących elementów:

uruchamianie Pythona z pliku .py,
zmienne,
listy,
funkcje,
pętle for i while,
instrukcje warunkowe if.

Jeśli dopiero zaczynasz, traktuj ten poradnik jako praktyczne wprowadzenie – przy każdym ważnym fragmencie kodu znajdziesz komentarz.

2.2. Instalacja Pythona

Wykonaj te kroki, aby przygotować środowisko:

Zainstaluj Python 3.x (np. 3.10+).
Sprawdź, czy Python działa; użyj jednego z poleceń:
Wpisz w terminalu:

python --version

Jeśli powyższe nie działa, spróbuj:

python3 --version
Wybierz edytor do pracy z kodem. Polecane opcje:

vs code,
pycharm community,
notepad++, sublime lub inny prosty edytor.

3. Koncepcja gry – co program ma robić?

Program w konsoli ma realizować następujące zadania:

Wyświetlać planszę 3×3.
Umożliwiać grę dwóch osób przy jednym komputerze: Gracz X oraz Gracz O.
W każdej turze pokazywać aktualną planszę, prosić o numer pola (1–9) i odrzucać nieprawidłowe ruchy (zły numer, pole zajęte).
Po każdym ruchu sprawdzać zwycięstwo (3 w linii) oraz remis (pełna plansza).
Po zakończeniu partii ogłosić wynik (wygrana/remis) i zapytać o ponowną grę.

To klasyczne, przejrzyste podejście: tworzymy planszę, obsługę ruchów, wykrywanie zwycięstwa oraz komunikaty o wyniku.

4. Reprezentacja planszy w Pythonie

W skrócie plansza to:

lista 9 elementów (indeksy 0–8),
puste pole oznaczone jako " ",
ruch gracza X oznaczony jako "X",
ruch gracza O oznaczony jako "O".

Przykład pustej planszy:

board = [" "] * 9

Użytkownik podaje wartości 1–9, natomiast w liście używamy indeksów 0–8, więc konwertujemy: pole_uzytkownika - 1.

5. Układ pól na planszy

Ustalmy numerację pól tak, by użytkownikowi było wygodnie:

1 | 2 | 3 ---+---+--- 4 | 5 | 6 ---+---+--- 7 | 8 | 9

Dzięki temu ruchy gracza są intuicyjne.

6. Funkcje – dzielimy program na logiczne części

Program podzielimy na następujące funkcje:

funkcja wyswietl_plansze(board) – wyświetla aktualną planszę,
funkcja czy_wygrana(board, symbol) – sprawdza, czy dany symbol wygrał,
funkcja czy_remis(board) – sprawdza, czy plansza jest pełna bez zwycięzcy,
funkcja pobierz_ruch(board, gracz) – prosi użytkownika o ruch i waliduje dane,
funkcja zagraj_partie() – realizuje logikę jednej pełnej gry,
funkcja main() – uruchamia główną pętlę programu (możliwość ponownej gry).

7. Gotowy kod gry w kółko i krzyżyk w Pythonie (wersja konsolowa)

Poniżej znajdziesz kompletny, gotowy do uruchomienia kod. Zapisz go w pliku kolko_krzyzyk.py i uruchom w terminalu.

# Kółko i krzyżyk w Pythonie – prosta wersja konsolowa dla dwóch graczy

def wyswietl_plansze(board):
"""Wyświetla aktualny stan planszy 3x3."""
print()
print(f" {board[0]} | {board[1]} | {board[2]} ")
print("---+---+---")
print(f" {board[3]} | {board[4]} | {board[5]} ")
print("---+---+---")
print(f" {board[6]} | {board[7]} | {board[8]} ")
print()

def czy_wygrana(board, symbol):
"""Sprawdza, czy dany symbol ('X' lub 'O') wygrał.
Zwraca True, jeśli są 3 w linii, inaczej False."""
zwycieskie_uklady = [
# wiersze
(0, 1, 2), (3, 4, 5), (6, 7, 8),
# kolumny
(0, 3, 6), (1, 4, 7), (2, 5, 8),
# przekątne
(0, 4, 8), (2, 4, 6),
]
for a, b, c in zwycieskie_uklady:
if board[a] == board[b] == board[c] == symbol:
return True
return False

def czy_remis(board):
"""Zwraca True, jeśli plansza jest pełna i nikt nie wygrał."""
return " " not in board

def pobierz_ruch(board, gracz):
"""Prosi użytkownika o ruch (1–9) i weryfikuje poprawność.
Zwraca indeks w liście board (0–8)."""
while True:
ruch = input(f"Gracz {gracz}, wybierz pole (1–9): ").strip()
if not ruch.isdigit():
print("Podaj numer pola jako liczbę od 1 do 9.")
continue
pole = int(ruch)
if pole < 1 or pole > 9:
print("Numer pola musi być w zakresie 1–9.")
continue
indeks = pole - 1
if board[indeks] != " ":
print("To pole jest już zajęte. Wybierz inne.")
continue
return indeks

def zagraj_partie():
"""Rozgrywa jedną pełną partię kółko i krzyżyk."""
board = [" "] * 9
aktualny_gracz = "X" # Gracz 1 – X, Gracz 2 – O

print("=== Kółko i krzyżyk w Pythonie ===")
print("Gracz X kontra Gracz O")
print("Numeracja pól:")
print(" 1 | 2 | 3 ")
print("---+---+---")
print(" 4 | 5 | 6 ")
print("---+---+---")
print(" 7 | 8 | 9 ")
print("Powodzenia!\n")

while True:
wyswietl_plansze(board)
indeks = pobierz_ruch(board, aktualny_gracz)
board[indeks] = aktualny_gracz

if czy_wygrana(board, aktualny_gracz):
wyswietl_plansze(board)
print(f"Gracz {aktualny_gracz} wygrywa! Gratulacje!")
break

if czy_remis(board):
wyswietl_plansze(board)
print("Remis! Plansza jest pełna.")
break

aktualny_gracz = "O" if aktualny_gracz == "X" else "X"

def main():
"""Główna pętla programu – umożliwia wielokrotną grę."""
while True:
zagraj_partie()
odp = input("Czy chcesz zagrać ponownie? (t/n): ").strip().lower()
if odp != "t":
print("Dziękujemy za grę!")
break

if __name__ == "__main__":
main()

8. Jak uruchomić grę – instrukcja dla początkujących

Postępuj zgodnie z poniższymi krokami:

Otwórz edytor i wklej kod do nowego pliku.
Zapisz plik jako kolko_krzyzyk.py.
Otwórz terminal i przejdź do katalogu z plikiem; użyj komendy:
Wejście do katalogu:

cd /sciezka/do/katalogu

Uruchomienie gry (jedno z poniższych):

python kolko_krzyzyk.py python3 kolko_krzyzyk.py
Kieruj się komunikatami na ekranie, w szczególności:

wybieraj pola 1–9,
graj na zmianę jako X i O,
po zakończeniu zdecyduj, czy zagrać ponownie.

9. Szczegółowe omówienie logiki programu

9.1. Wyświetlanie planszy

Funkcja wyswietl_plansze formatuje tekst tak, by lista 9 pól wyglądała jak plansza 3×3. To podejście jest szeroko stosowane w prostych wersjach konsolowych.

Kluczowy fragment:

print(f" {board[0]} | {board[1]} | {board[2]} ") print("---+---+---") print(f" {board[3]} | {board[4]} | {board[5]} ") print("---+---+---") print(f" {board[6]} | {board[7]} | {board[8]} ")

Dzięki temu użytkownik widzi każdą turę w przejrzystej formie.

9.2. Sprawdzanie zwycięstwa

Zwycięstwo oznacza trzy te same symbole w jednym z 8 możliwych układów, w tym:

trzy wiersze,
trzy kolumny,
dwie przekątne.

W kodzie przechowujemy te układy jako listę krotek:

zwycieskie_uklady = [ (0, 1, 2), (3, 4, 5), (6, 7, 8), (0, 3, 6), (1, 4, 7), (2, 5, 8), (0, 4, 8), (2, 4, 6), ]

Pętla po tej liście sprawdza, czy wszystkie trzy pola zawierają dany symbol:

if board[a] == board[b] == board[c] == symbol: return True

To prosta, skuteczna implementacja: po każdym ruchu weryfikujemy linie i przekątne.

9.3. Sprawdzanie remisu

Remis to sytuacja, gdy na planszy nie ma już pustych pól " ", a nikt wcześniej nie wygrał:

def czy_remis(board): return " " not in board

Funkcję wywołujemy dopiero po sprawdzeniu zwycięstwa, aby uniknąć fałszywego remisu przy ostatnim ruchu.

9.4. Pobieranie i walidacja ruchu

To kluczowa część przyjazności programu dla użytkownika. Funkcja pobierz_ruch:

pobiera wartość przez input(),
sprawdza, czy wpis jest liczbą (isdigit()),
konwertuje na int,
weryfikuje zakres 1–9,
sprawdza, czy pole jest wolne.

Dopóki którykolwiek warunek nie jest spełniony, użytkownik dostaje komunikat i jest proszony o ponowny wpis.

9.5. Zmiana gracza

Po każdym poprawnym ruchu następuje zmiana symbolu:

aktualny_gracz = "O" if aktualny_gracz == "X" else "X"

Naprzemienne tury odzwierciedlają standardowe zasady gry.

10. Możliwe rozszerzenia projektu

Gdy podstawowa wersja działa, rozbuduj ją o nowe funkcje i tryby:

losowanie pierwszego gracza – zamiast zawsze zaczynać od „X”, użyj modułu random, by wybierać, kto zaczyna;
większa plansza (4×4, 5×5) – niech użytkownik poda rozmiar siatki, a zwycięstwem może być np. 4 w linii;
statystyki graczy – licznik wygranych, przegranych i remisów oraz podsumowanie sesji;
prosta sztuczna inteligencja – gra przeciw komputerowi: od losowego ruchu po blokowanie i algorytm minimax;
interfejs graficzny (GUI) – wersja z Tkinter lub Pygame dla wygodniejszej, wizualnej rozgrywki;
wersja obiektowa (OOP) – klasa Game przechowująca stan, aktualnego gracza i metody do obsługi gry.

12. Propozycja struktury artykułu do publikacji

Jeśli chcesz opublikować ten poradnik jako artykuł na stronie, wykorzystaj poniższy szkielet:

Wstęp: „Dlaczego kółko i krzyżyk w Pythonie to idealny projekt na start?”
Sekcja o wymaganiach (Python, podstawy)
Omówienie zasad gry (dla pełnej jasności)
Koncepcja reprezentacji planszy w kodzie
Pełen kod z komentarzami
Instrukcja uruchomienia
Szczegółowe wyjaśnienie najważniejszych funkcji
Propozycje rozszerzeń (grafika, AI, plansza 4×4 itd.)
Powiązanie z tematyką internetu (aplikacje webowe, projekty na GitHubie, społeczności)