Programación Orientada a Objetos

 1class Perro:
 2    """Representa a un perro con nombre y edad."""
 3
 4    # Atributo de clase (compartido por todos los perros)
 5    especie = "Canis lupus familiaris"
 6
 7    def __init__(self, nombre, edad):
 8        """Inicializa un nuevo perro."""
 9        # Atributos de instancia (únicos para cada perro)
10        self.nombre = nombre
11        self.edad = edad
12
13    def ladrar(self):
14        """El perro ladra."""
15        return f"{self.nombre} dice: ¡Guau!"
16
17    def cumplir_anos(self):
18        """El perro cumple un año más."""
19        self.edad += 1
20        return f"¡Feliz cumpleaños {self.nombre}! Ahora tienes {self.edad} años."

 1# Creamos dos perros usando la clase como molde
 2mi_perro = Perro("Max", 3)
 3tu_perro = Perro("Luna", 5)
 4
 5# Cada perro tiene sus propios atributos
 6print(mi_perro.nombre)  # Max
 7print(tu_perro.nombre)  # Luna
 8
 9# Pero comparten el atributo de clase
10print(mi_perro.especie)  # Canis lupus familiaris
11print(tu_perro.especie)  # Canis lupus familiaris
12
13# Cada perro puede ejecutar sus métodos
14print(mi_perro.ladrar())  # Max dice: ¡Guau!
15print(tu_perro.cumplir_anos())  # ¡Feliz cumpleaños Luna! Ahora tienes 6 años.

 1class CuentaBancaria:
 2    def __init__(self, titular, saldo_inicial):
 3        self.titular = titular          # Público: acceso libre
 4        self._saldo = saldo_inicial     # "Privado": no tocar desde fuera
 5        self.__pin = "1234"             # "Muy privado": name mangling
 6
 7    def depositar(self, cantidad):
 8        if cantidad > 0:
 9            self._saldo += cantidad
10            return True
11        return False
12
13    def retirar(self, cantidad):
14        if 0 < cantidad <= self._saldo:
15            self._saldo -= cantidad
16            return True
17        return False
18
19cuenta = CuentaBancaria("Ana", 1000)
20
21# Público: acceso normal
22print(cuenta.titular)  # Ana
23
24# "Privado": técnicamente accesible, pero no deberías
25print(cuenta._saldo)  # 1000 (funciona, pero es mala práctica)
26
27# "Muy privado": Python lo renombra internamente
28# print(cuenta.__pin)  # Error: AttributeError
29print(cuenta._CuentaBancaria__pin)  # 1234 (name mangling)

 1class Temperatura:
 2    def __init__(self, celsius):
 3        self._celsius = celsius
 4
 5    @property
 6    def celsius(self):
 7        """Getter: se ejecuta al leer temperatura.celsius"""
 8        return self._celsius
 9
10    @celsius.setter
11    def celsius(self, valor):
12        """Setter: se ejecuta al asignar temperatura.celsius = valor"""
13        if valor < -273.15:
14            raise ValueError("¡No existe temperatura menor al cero absoluto!")
15        self._celsius = valor
16
17    @property
18    def fahrenheit(self):
19        """Propiedad calculada (solo lectura)."""
20        return self._celsius * 9/5 + 32
21
22temp = Temperatura(25)
23print(temp.celsius)     # 25 (usa el getter)
24print(temp.fahrenheit)  # 77.0
25
26temp.celsius = 30       # Usa el setter
27print(temp.celsius)     # 30
28
29# temp.celsius = -300   # ValueError: ¡No existe temperatura menor al cero absoluto!

 1class Animal:
 2    """Clase base para todos los animales."""
 3
 4    def __init__(self, nombre, edad):
 5        self.nombre = nombre
 6        self.edad = edad
 7
 8    def presentarse(self):
 9        return f"Soy {self.nombre} y tengo {self.edad} años."
10
11    def hacer_sonido(self):
12        raise NotImplementedError("Las subclases deben implementar este método")
13
14
15class Perro(Animal):
16    """Un perro es un animal con raza."""
17
18    def __init__(self, nombre, edad, raza):
19        super().__init__(nombre, edad)  # Llama al __init__ del padre
20        self.raza = raza
21
22    def hacer_sonido(self):
23        return "¡Guau!"
24
25    def buscar_pelota(self):
26        return f"{self.nombre} va a buscar la pelota."
27
28
29class Gato(Animal):
30    """Un gato es un animal con color de pelaje."""
31
32    def __init__(self, nombre, edad, color):
33        super().__init__(nombre, edad)
34        self.color = color
35
36    def hacer_sonido(self):
37        return "¡Miau!"
38
39    def ronronear(self):
40        return f"{self.nombre} está ronroneando..."
41
42
43# Uso
44max_perro = Perro("Max", 3, "Labrador")
45mishi = Gato("Mishi", 2, "naranja")
46
47print(max_perro.presentarse())   # Soy Max y tengo 3 años. (heredado)
48print(max_perro.hacer_sonido())  # ¡Guau! (sobrescrito)
49print(max_perro.buscar_pelota()) # Max va a buscar la pelota. (nuevo)
50
51print(mishi.presentarse())       # Soy Mishi y tengo 2 años. (heredado)
52print(mishi.hacer_sonido())      # ¡Miau! (sobrescrito)
53print(mishi.ronronear())         # Mishi está ronroneando... (nuevo)

1# isinstance() verifica si un objeto es de una clase (o sus padres)
2print(isinstance(max_perro, Perro))   # True
3print(isinstance(max_perro, Animal))  # True
4print(isinstance(max_perro, Gato))    # False
5
6# issubclass() verifica relación entre clases
7print(issubclass(Perro, Animal))      # True
8print(issubclass(Gato, Perro))        # False

 1class Forma:
 2    """Clase base para formas geométricas."""
 3
 4    def area(self):
 5        raise NotImplementedError
 6
 7    def perimetro(self):
 8        raise NotImplementedError
 9
10
11class Rectangulo(Forma):
12    def __init__(self, ancho, alto):
13        self.ancho = ancho
14        self.alto = alto
15
16    def area(self):
17        return self.ancho * self.alto
18
19    def perimetro(self):
20        return 2 * (self.ancho + self.alto)
21
22
23class Circulo(Forma):
24    def __init__(self, radio):
25        self.radio = radio
26
27    def area(self):
28        return 3.14159 * self.radio ** 2
29
30    def perimetro(self):
31        return 2 * 3.14159 * self.radio
32
33
34class Triangulo(Forma):
35    def __init__(self, base, altura, lado1, lado2, lado3):
36        self.base = base
37        self.altura = altura
38        self.lados = (lado1, lado2, lado3)
39
40    def area(self):
41        return (self.base * self.altura) / 2
42
43    def perimetro(self):
44        return sum(self.lados)
45
46
47# Polimorfismo en acción
48formas = [
49    Rectangulo(4, 5),
50    Circulo(3),
51    Triangulo(6, 4, 5, 5, 6)
52]
53
54for forma in formas:
55    # Mismo código, diferente resultado según el tipo de forma
56    print(f"Área: {forma.area():.2f}, Perímetro: {forma.perimetro():.2f}")
57
58# Salida:
59# Área: 20.00, Perímetro: 18.00
60# Área: 28.27, Perímetro: 18.85
61# Área: 12.00, Perímetro: 16.00

 1class Vector:
 2    """Un vector 2D con operaciones matemáticas."""
 3
 4    def __init__(self, x, y):
 5        self.x = x
 6        self.y = y
 7
 8    def __repr__(self):
 9        """Representación técnica (para desarrolladores)."""
10        return f"Vector({self.x}, {self.y})"
11
12    def __str__(self):
13        """Representación amigable (para usuarios)."""
14        return f"({self.x}, {self.y})"
15
16    def __eq__(self, otro):
17        """Comparación de igualdad: v1 == v2"""
18        return self.x == otro.x and self.y == otro.y
19
20    def __add__(self, otro):
21        """Suma de vectores: v1 + v2"""
22        return Vector(self.x + otro.x, self.y + otro.y)
23
24    def __sub__(self, otro):
25        """Resta de vectores: v1 - v2"""
26        return Vector(self.x - otro.x, self.y - otro.y)
27
28    def __mul__(self, escalar):
29        """Multiplicación por escalar: v * 3"""
30        return Vector(self.x * escalar, self.y * escalar)
31
32    def __len__(self):
33        """Longitud (magnitud) del vector: len(v)"""
34        return int((self.x**2 + self.y**2)**0.5)
35
36    def __bool__(self):
37        """Valor booleano: if v:"""
38        return self.x != 0 or self.y != 0
39
40
41# Uso natural gracias a los métodos especiales
42v1 = Vector(3, 4)
43v2 = Vector(1, 2)
44
45print(v1)           # (3, 4) - usa __str__
46print(repr(v1))     # Vector(3, 4) - usa __repr__
47print(v1 == v2)     # False - usa __eq__
48print(v1 + v2)      # (4, 6) - usa __add__
49print(v1 * 2)       # (6, 8) - usa __mul__
50print(len(v1))      # 5 - usa __len__
51
52if v1:              # usa __bool__
53    print("v1 no es el vector cero")

 1from dataclasses import dataclass, field
 2from typing import List
 3
 4@dataclass
 5class Pedido:
 6    cliente: str
 7    productos: List[str] = field(default_factory=list)  # Lista mutable
 8    id_pedido: int = field(default=0, repr=False)       # No se muestra en repr
 9
10    def agregar_producto(self, producto):
11        self.productos.append(producto)
12
13@dataclass(frozen=True)  # Inmutable (no se puede modificar después de crear)
14class Coordenada:
15    x: float
16    y: float
17
18# Uso
19pedido = Pedido("Ana")
20pedido.agregar_producto("Laptop")
21pedido.agregar_producto("Mouse")
22print(pedido)  # Pedido(cliente='Ana', productos=['Laptop', 'Mouse'])
23
24coord = Coordenada(10.5, 20.3)
25# coord.x = 15  # Error: FrozenInstanceError (inmutable)