En la segunda parte del curso de programación en Python con Linux (Enlace al final del artículo) habíamos puesto un ejemplo para ilustrar la Programación Orientada a Objetos, el paradigma que se usa para crear programas de manera eficiente. Ahora lo veremos en más detalle

En el paradigma tradicional, el programa consistía en una serie de instrucciones que se ejecutaban de manera secuencial mientras que en la Programación Orientada a Objetos trabajamos con entidades que son capaces de comunicarse entre sí. Estos objetos tienen una función específica y son capaces manipular datos que sean utilizados por otros objetos.

Curso de programación en Python

En la Programación Orientada a Objetos contamos con cuatro elementos: clases, instancias, atributos y métodos. La clase es el molde a partir del cuál se definen diferentes instancias. Cada instancia es un objeto creado a partir de la clase. En nuestro código solo hay una instancia llamada juego perteneciente a la clase TaTeTi. Una clase puede tener diferentes mensajes y son capaces de entender los mismos mensajes y ejecutar las mismas acciones aunque son completamente independientes.

Los atributos son variables asociadas a los objetos y representan un estado interno de la instancia. En nuestro ejemplo serían las diferentes actualizaciones del tablero y la determinación de a quién le corresponde el turno.

En el caso de los métodos, estos determinan el comportamiento de los objetos de cada clase determinando que tipo de operaciones son capaces de realizar. En nuestro código los métodos se ocupan de crear el tablero y actualizarlo y de cambiar de turno entre los usuarios

Explicación de las diferentes partes del programa

class TaTeTi:
Ta Te Tí es como llamamos en Argentina al 3 en raya. Esta instrucción crea una clase que definirá la estructura de los objetos que utilizaremos en el juego.
def __init__(self):
Esto es un método especial que se ejecuta automáticamente cada vez que se crea una instancia (juego = TaTeTi()).
self.tablero = [" " for _ in range(9)]
Esta es la instrucción donde se va a crear el tablero a partir de nueve elementos constituidos por espacios. «_ » es una variable que no tiene utilidad en el programa pero que se pone por que la sintaxis lo exige.
self.turno = "X"
Indica que el primer turno será para las «X»
def mostrar_tablero(self):
Define la forma como se mostrará el tablero.
for i in range(0, 9, 3):
Establece que el tablero será una grilla de 3×3
print(self.tablero[i], "|", self.tablero[i+1], "|", self.tablero[i+2])
Imprime el tablero de 3×3
print()
Imprime una línea vacía para mejorar la visualización.
def jugar(self, posicion):
Este método se ocupa de la colocación de la ficha.
if self.tablero[posicion] == " ":
Verifica si el casillero elegido está ocupado.
self.tablero[posicion] = self.turno
En caso de que el casillero esté disponible coloca la ficha.
self.cambiar_turno()
Alterna el turno entre jugadores.
else:
print("Posición ocupada")
En caso de que el jugador indique una posición ocupada se lo indica.
def cambiar_turno(self):
self.turno = "O" if self.turno == "X" else "X"
Método para cambiar entre «X» y «0»
def hay_ganador(self):
Método para revisar si hay un ganador
combinaciones = [
(0,1,2), (3,4,5), (6,7,8),
(0,3,6), (1,4,7), (2,5,8),
(0,4,8), (2,4,6)

Para determinar si ay un ganador se establece un listado de posiciones ganadoras.
for a, b, c in combinaciones:
Con esta instrucción se repasan todas las combinaciones.
if self.tablero[a] == self.tablero[b] == self.tablero != " ":
Verifica que hay 3 posiciones ubicadas por piezas iguales.
return True
Si encuentra una combinación ganadora termina el método devolviendo TRUE
juego = TaTeTi()
Crea una instancia del juego y lo ejecuta.
while True:
Establece un bucle que no termina hasta que no hay ganadores (O alguien pulsa la techa equivocada)
juego.mostrar_tablero()
Muestra el tablero actualizado
pos = int(input(f»Turno de {juego.turno}. Elegir posición (0-8): «))
Le pide al usuario que ingrese la posición y captura el valor. Input recibe la entrada como texto e Int la convierte a número.
juego.jugar(pos)
Intenta hacer la jugada en la posición indicada.
if juego.hay_ganador():
Verifica si hay un ganador.
juego.mostrar_tablero()
Muestra el resultado final en el tablero.
print("¡Ganó un jugador!")
Muestra el mensaje de ganador.
break
Rompre el bucle.

Un poco más sobre las clases y los métodos

En Python se usan las clases como plantillas para construir los diferentes objetos en los que trabajarán los programas.

Como ya explicamos anteriormente, la tarea de una clase es definir lo que un objeto puede hacer, debe ser y con qué datos necesita trabajar.

En python la clase se define con el comando class. Si queremos hacer una base de datos de sistemas operativos  podemos definirla por ejemplo cno

class Sistemas:
Nota que el nombre de la clase está en mayúsculas. Esto no es una obligación como la indentación pero sirve para facilitar la lectura del código.

Ahora vamos a crear el «molde»

Los métodos describen los comportamientos y operaciones que pueden realizar los objetos de una clase.

Veamos el programa línea por línea

class Sistemas:

Como vimos, este comando crea la clase en la que se definirá la plantilla con la cuál crearemos el objeto.

def __init__(self, nombre, version, derivada):

__init__ es un método interno de Python que se ejecuta al crear una instancia, self es un parámetro que referencia al objeto que se está creando.

self.nombre = nombre

Crea un atributo dentro del objeto llamado nombre y lo guarda dentro del parámetro nombre.

self.version = version

Crea el atributo versión en el objeto y lo guarda en el parámetro versión. Recuerda que no es recomendable usar caracteres especiales como acentos fuera de lso mensajes.

self.derivada = derivada

Hace lo mismo  que las otras dos instrucciones con el parámetro derivada.

def mostrar_info(self):

Define un método para mostrar los atributos del objeto.

print(f"Nombre: {self.nombre}")

Imprime el atributo nombre.

print(f"Versión: {self.version}")
Imprime el atributo version

print(f"Derivada: {self.derivada}")
Imprime el atributo derivada

sistema = Sistemas("Ubuntu", "26.04", "Debian")
Crea el objeto y le asigna los atributos.

sistema.mostrar_info()

Muestra la información sobre los atributos del objeto.

Una de las características más útiles de las clases es que facilitan la reutilización del código. También es posible crear clases que hereden características de otras clases agregándoles sus propios atributos. Es un tema del que hablaremos en la próxima lección. Otro tema que veremos es cómo agregar los atributos de una instancia a partir de un archivo externo lo que nos ahorrará bastante tiempo de codificación.