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.
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()class Persona:→ define la clase.__init__→ constructor, se ejecuta al crear el objeto.self→ referencia al objeto actual (similar athisen otros lenguajes).p1→ instancia de la clasePersona.
Son únicos para cada objeto:
class Coche:
def __init__(self, marca):
self.marca = marcaSon compartidos por todas las instancias:
class Coche:
ruedas = 4 # atributo de clase
def __init__(self, marca):
self.marca = marcaa = Coche("Toyota")
b = Coche("Honda")
print(a.ruedas, b.ruedas) # ambos tienen 4Opera sobre el objeto (self).
def mostrar(self):
print(self.nombre)Opera sobre la clase, no sobre un objeto.
@classmethod
def crear_desde_edad(cls, edad):
return cls("Desconocido", edad)No usa self ni cls. Funciona como una función normal dentro de la clase.
@staticmethod
def es_mayor(edad):
return edad >= 18Permite 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.
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()Controla la visibilidad de los atributos/métodos.
| Tipo | Ejemplo | Acceso |
|---|---|---|
| Público | self.nombre |
libre |
| Protegido | _nombre |
interno/subclases |
| Privado | __nombre |
solo dentro de la clase |
class Persona:
def __init__(self, nombre):
self.__nombre = nombre # privado
def mostrar(self):
print(self.__nombre)Permiten acceder a métodos como si 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éntesisUna 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()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)| Concepto | Descripción |
|---|---|
class |
Define una clase |
__init__ |
Constructor |
self |
Referencia al objeto actual |
| Atributos | Datos de objeto o clase |
| Métodos | Funciones dentro de la clase |
@classmethod, @staticmethod |
Métodos especiales |
| Herencia | Reutilización de código |
| Encapsulación | Control de acceso |
| Polimorfismo | Mismo método, distinto comportamiento |
@property |
Acceso elegante a métodos como atributos |
Autor: Fravelz