Clases Python

Clases en Python

¿Qué es una clase en Python?

Una clase es una plantilla o molde para crear objetos (instancias) que agrupan datos (atributos) y funciones (métodos) relacionados.

Los objetos son las copias o instancias creadas a partir de esa clase.

Sintaxis básica

class Persona:
def __init__(self, nombre, edad):  # Constructor
self.nombre = nombre           # Atributos
self.edad = edad

def saludar(self):                 # Método
print(f"Hola, soy (self.nombre) y tengo (self.edad) años")

# Crear objeto
p1 = Persona("Francisco", 17)
p1.saludar()

Explicación

class Persona: → define la clase.
init → constructor, se ejecuta al crear el objeto.
self → referencia al objeto actual (similar a this en otros lenguajes).
p1 → instancia de la clase Persona.

Atributos

1. De instancia

Son únicos para cada objeto:

class Coche:
def __init__(self, marca):
self.marca = marca

2. De clase

Son compartidos por todas las instancias:

class Coche:
ruedas = 4  # atributo de clase
def __init__(self, marca):
self.marca = marca

a = Coche("Toyota")
b = Coche("Honda")
print(a.ruedas, b.ruedas)  # ambos tienen 4

Métodos

Método de instancia

Opera sobre el objeto (self).

def mostrar(self):
print(self.nombre)

Método de clase

Opera sobre la clase, no sobre un objeto.

@classmethod
def crear_desde_edad(cls, edad):
return cls("Desconocido", edad)

Método estático

No usa self ni cls. Funciona como una función normal dentro de la clase.

@staticmethod
def es_mayor(edad):
return edad >= 18

Herencia

Permite crear una clase nueva basada en otra (reutiliza código).

class Animal:
def hablar(self):
print("El animal hace un sonido")

class Perro(Animal):  # Hereda de Animal
def hablar(self):
print("Guau")

p = Perro()
p.hablar()

✔️ La clase hija sobrescribe métodos de la clase padre. ✔️ Se puede usar super() para llamar métodos del padre.

Polimorfismo

Diferentes clases pueden usar el mismo método con comportamientos distintos:

class Gato:
def hablar(self): print("Miau")

class Perro:
def hablar(self): print("Guau")

for animal in [Gato(), Perro()]:
animal.hablar()

Encapsulación

Controla la visibilidad de los atributos/métodos.

class Persona:
def __init__(self, nombre):
self.__nombre = nombre  # privado

def mostrar(self):
print(self.__nombre)

Propiedades (@property)

Permiten acceder a métodos como sí fueran atributos.

class Rectangulo:
def __init__(self, base, altura):
self.base = base
self.altura = altura

@property
def area(self):
return self.base * self.altura

r = Rectangulo(4, 5)
print(r.area)  # No se usa paréntesis

Composición

Una clase contiene objetos de otras clases:

class Motor:
def arrancar(self):
print("Motor encendido")

class Coche:
def __init__(self):
self.motor = Motor()

c = Coche()
c.motor.arrancar()

Ejemplo completo

class CuentaBancaria:
tasa_interes = 0.05  # atributo de clase

def __init__(self, titular, saldo=0):
self.titular = titular
self.__saldo = saldo  # privado

def depositar(self, cantidad):
self.__saldo += cantidad

def retirar(self, cantidad):
if cantidad <= self.__saldo:
self.__saldo -= cantidad
else:
print("Fondos insuficientes")

@property
def saldo(self):
return self.__saldo

# Uso
cuenta = CuentaBancaria("Francisco", 1000)
cuenta.depositar(500)
cuenta.retirar(200)
print(cuenta.saldo)