En nuestras clases extraescolares, hemos creado el juego del "3 en Raya" junto con los niños, como parte del aprendizaje de los fundamentos de la programación orientada a objetos en Python.
Fue una actividad muy divertida y educativa, donde los alumnos pudieron aplicar conceptos como las clases, objetos y métodos de una manera práctica y entretenida. Los niños no solo aprendieron a programar un juego, sino también a comprender la lógica detrás de las decisiones de un programa y cómo interactuar con la terminal para ejecutarlo.
Esta experiencia les permitió desarrollar habilidades de resolución de problemas, pensamiento crítico y trabajo en equipo, mientras se introducían al mundo de la programación de una forma amena. ¡Una forma fantástica de aprender jugando!
Fuente: Balani Computer® Academy™
La programación orientada a objetos (POO) es un paradigma de programación que organiza el software en "objetos", que pueden tener datos y comportamientos. En Python, los objetos son instancias de clases, que actúan como plantillas o modelos para crear objetos. Este tutorial te introducirá a los conceptos básicos de la POO en Python y terminará con un ejemplo de un programa sencillo: un juego de "3 en raya" (Tic-Tac-Toe).
Conceptos Básicos de Programación Orientada a Objetos (POO)
Clases: Una clase es un modelo o plantilla para crear objetos. Define los atributos (datos) y métodos (comportamientos) que tendrá cada objeto de esa clase.
Sintaxis:
class MiClase:
# Constructor: se ejecuta cuando se crea un objeto
def __init__(self, atributo1):
self.atributo1 = atributo1
Objetos: Un objeto es una instancia de una clase. Cada objeto puede tener sus propios datos y comportamientos.
Sintaxis:
objeto = MiClase("Valor")
Atributos y Métodos:
Atributos: Son variables que pertenecen a la clase o al objeto.
Métodos: Son funciones que pertenecen a la clase y pueden manipular sus atributos.
Encapsulamiento: Se refiere a la idea de proteger los datos dentro de un objeto, haciendo que solo puedan ser modificados a través de métodos de la clase.
Herencia: Una clase puede heredar atributos y métodos de otra clase, reutilizando código.
Polimorfismo: La capacidad de usar un mismo método de diferentes maneras, dependiendo del objeto que lo esté llamando.
Creando el juego de "3 en Raya" en Python (usando POO)
En este ejemplo, crearemos un juego de "3 en raya" con dos jugadores, utilizando la programación orientada a objetos.
Paso 1: Definimos la clase del tablero
class Tablero:
def __init__(self):
# Creamos un tablero 3x3 representado como una lista de listas
self.tablero = [[' ' for _ in range(3)] for _ in range(3)]
def mostrar_tablero(self):
# Mostramos el tablero en pantalla
for fila in self.tablero:
print('|'.join(fila))
print('-' * 5)
def marcar_posicion(self, fila, columna, jugador):
# Comprobamos si la posición está vacía y la marcamos
if self.tablero[fila][columna] == ' ':
self.tablero[fila][columna] = jugador
return True
return False
def verificar_ganador(self):
# Comprobamos si hay un ganador (filas, columnas, diagonales)
for i in range(3):
if self.tablero[i][0] == self.tablero[i][1] == self.tablero[i][2] != ' ':
return self.tablero[i][0]
if self.tablero[0][i] == self.tablero[1][i] == self.tablero[2][i] != ' ':
return self.tablero[0][i]
if self.tablero[0][0] == self.tablero[1][1] == self.tablero[2][2] != ' ':
return self.tablero[0][0]
if self.tablero[0][2] == self.tablero[1][1] == self.tablero[2][0] != ' ':
return self.tablero[0][2]
return None
def tablero_lleno(self):
# Verificamos si ya no quedan espacios vacíos
for fila in self.tablero:
if ' ' in fila:
return False
return True
Paso 2: Definimos la clase del Juego
class JuegoTresEnRaya:
def __init__(self):
self.tablero = Tablero()
self.jugador_actual = 'X' # El jugador 'X' empieza
def alternar_jugador(self):
# Alternamos entre los jugadores 'X' y 'O'
self.jugador_actual = 'O' if self.jugador_actual == 'X' else 'X'
def jugar(self):
print("¡Bienvenidos a 3 en Raya!")
while True:
self.tablero.mostrar_tablero()
fila = int(input(f"Jugador {self.jugador_actual}, ingresa la fila (0, 1, 2): "))
columna = int(input(f"Jugador {self.jugador_actual}, ingresa la columna (0, 1, 2): "))
if self.tablero.marcar_posicion(fila, columna, self.jugador_actual):
ganador = self.tablero.verificar_ganador()
if ganador:
print(f"¡Jugador {ganador} ha ganado!")
self.tablero.mostrar_tablero()
break
elif self.tablero.tablero_lleno():
print("¡Es un empate!")
self.tablero.mostrar_tablero()
break
else:
self.alternar_jugador()
else:
print("Movimiento no válido. Intenta nuevamente.")
Paso 3: Ejecutar el juego
Para ejecutar el juego, simplemente necesitas crear una instancia de la clase JuegoTresEnRaya y llamar al método jugar():
if __name__ == "__main__":
juego = JuegoTresEnRaya()
juego.jugar()
Explicación del código
Clase Tablero: Esta clase se encarga de gestionar el tablero del juego, incluyendo la lógica para mostrar el tablero, marcar posiciones y verificar si hay un ganador o si el tablero está lleno.
Clase JuegoTresEnRaya: Esta clase contiene la lógica del juego, alternando entre los jugadores y llamando a los métodos del tablero para actualizarlo y comprobar el estado del juego.
Conclusión
Este tutorial introduce en los fundamentos de la programación orientada a objetos en Python y cómo aplicarlos en un programa sencillo como el juego "3 en raya". A medida que avanzas en tu aprendizaje de Python, podrás ampliar estos conceptos para crear programas más complejos y flexibles utilizando clases, objetos, y métodos.
Comments