Resumen esencial de Programación Orientada a Objetos en Python

Tabla de contenido

📌 ¿Qué es una función? #

Una función es un bloque de código reutilizable que realiza una tarea específica.

def saludar(nombre):
    return f"¡Hola, {nombre}!"

print(saludar("Ana"))

📌 ¿Qué es una clase? #

Una clase es un molde o plantilla para crear objetos. Define sus atributos y métodos.

class Animal:
    def __init__(self, especie):
        self.especie = especie

    def hacer_sonido(self):
        return "Sonido genérico"

perro = Animal("Perro")
print(perro.hacer_sonido())

📌 ¿Qué es un objeto? #

Un objeto es una instancia de una clase. Contiene datos (atributos) y comportamientos (métodos).

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

persona1 = Persona("Carlos")
print(persona1.nombre)

📌 ¿Qué es una entidad, propiedad y atributo? #

Entidad: representación de un objeto real o conceptual (ej: un auto, una persona).
Propiedad: característica de la entidad (ej: color, nombre).
Atributo: implementación concreta de una propiedad en código.

class Auto:
    def __init__(self, marca, modelo):
        self.marca = marca  # propiedad representada como atributo
        self.modelo = modelo

📌 ¿Qué es un método? #

Un método es una función definida dentro de una clase que opera sobre instancias de esa clase.

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

    def saludar(self):
        return f"Hola, soy {self.nombre}"

p = Persona("Luis")
print(p.saludar())

📌 ¿Qué es un constructor? #

Un constructor es un método especial __init__ que se ejecuta al crear un objeto.

class Usuario:
    def __init__(self, nombre):
        self.nombre = nombre

u = Usuario("Valeria")
print(u.nombre)

📌 ¿Qué es encapsulamiento? #

El encapsulamiento protege el estado interno de un objeto, evitando su acceso o modificación directa desde fuera de la clase.

class Cuenta:
    def __init__(self):
        self.__saldo = 0  # atributo privado

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

    def obtener_saldo(self):
        return self.__saldo

cuenta = Cuenta()
cuenta.depositar(100)
print(cuenta.obtener_saldo())

📌 ¿Qué es un getter y un setter? #

En la Programación Orientada a Objetos, los getters y setters permiten acceder y modificar atributos privados de forma controlada, respetando el principio de encapsulamiento.

Getter: método que devuelve el valor de un atributo privado.
Setter: método que permite modificar el valor de un atributo privado.

🧱 Forma clásica (funciona en cualquier versión de Python)

class Producto:
    def __init__(self):
        self.__precio = 0

    def get_precio(self):
        return self.__precio

    def set_precio(self, nuevo_precio):
        if nuevo_precio > 0:
            self.__precio = nuevo_precio

# Uso
p = Producto()
p.set_precio(150)
print(p.get_precio())  # 👉 150

✨ Forma moderna con @property (recomendada en Python)

class Producto:
    def __init__(self):
        self.__precio = 0

    @property
    def precio(self):
        return self.__precio

    @precio.setter
    def precio(self, nuevo_precio):
        if nuevo_precio > 0:
            self.__precio = nuevo_precio


p = Producto()
p.precio = 150
print(p.precio)  # 👉 150

✅ ¿Cuál forma es mejor?

✅ Forma moderna con @property: más clara, legible y pythonic¹. Permite usar atributos como si fueran públicos, manteniendo el control interno.
🧱 Forma clásica: aún útil en algunos entornos o para quienes están comenzando y quieren ser explícitos.

📌 ¿Qué es herencia? #

La herencia permite que una clase hija reciba atributos y métodos de una clase padre.

class Vehiculo:
    def encender(self):
        return "Vehículo encendido"

class Auto(Vehiculo):
    def tocar_bocina(self):
        return "Beep beep"

mi_auto = Auto()
print(mi_auto.encender())
print(mi_auto.tocar_bocina())

📌 ¿Qué es polimorfismo? #

El polimorfismo permite usar el mismo método con diferentes comportamientos según el objeto.

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

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

def hacer_hablar(animal):
    print(animal.hablar())

hacer_hablar(Gato())
hacer_hablar(Perro())

📌 ¿Qué es abstracción? #

La abstracción consiste en mostrar solo los detalles esenciales y ocultar lo complejo.

from abc import ABC, abstractmethod

class Figura(ABC):
    @abstractmethod
    def area(self):
        pass

class Cuadrado(Figura):
    def __init__(self, lado):
        self.lado = lado

    def area(self):
        return self.lado * self.lado

c = Cuadrado(4)
print(c.area())

📌 ¿Qué es una clase abstracta? #

Una clase abstracta no se puede instanciar directamente y obliga a las subclases a implementar ciertos métodos.

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def sonido(self):
        pass

class Vaca(Animal):
    def sonido(self):
        return "Muuu"

v = Vaca()
print(v.sonido())

📌 ¿Qué es un decorador? #

Un decorador es una función que modifica el comportamiento de otra función o método.

def decorador(func):
    def nueva_funcion():
        print("Antes de ejecutar")
        func()
        print("Después de ejecutar")
    return nueva_funcion

@decorador
def saludar():
    print("Hola mundo")

saludar()

Se refiere a escribir código que sigue el estilo, las buenas prácticas y la filosofía de Python, de manera clara, legible y elegante. No es solo que el código funcione, sino que se vea como “natural” en Python. ↩︎