PYTHON · INTRODUCCIÓN A POO
Programación Orientada
a Objetos
Aprende a pensar en clases y objetos construyendo, paso a paso, un mismo ejemplo en Python.
¿Qué veremos hoy?
Iremos construyendo un mismo ejemplo, paso a paso.
1 ¿Por qué POO? 2 Clases y objetos
De código suelto a objetos El plano y sus instancias
3 Atributos y métodos 4 Encapsulamiento
La anatomía de una clase Proteger los datos internos
5 Herencia y polimorfismo 6 Abstracción
Reutilizar y especializar Ocultar la complejidad + ejemplo final
2
¿Por qué Programación Orientada a Objetos?
Cuando los datos y las funciones viven separados, el código se vuelve difícil de mantener.
Sin POO Con POO
coche1_marca = "Toyota" class Vehiculo:
coche1_velocidad = 0 def __init__(self, marca):
coche2_marca = "Honda" [Link] = marca
coche2_velocidad = 0 [Link] = 0
def acelerar(velocidad): def acelerar(self):
return velocidad + 10 [Link] += 10
coche1_velocidad = acelerar(coche1_velocidad) coche1 = Vehiculo("Toyota")
# ¿y si tengo 100 coches? coche2 = Vehiculo("Honda")
[Link]() # cada objeto es
independiente
3
Una clase, muchos objetos
Vehiculo es el plano. Cada objeto que creamos es una instancia independiente, con sus propios valores.
Vehiculo
la clase (el plano)
mi_coche : Vehiculo mi_moto : Vehiculo
marca = "Toyota" marca = "Yamaha"
velocidad = 0 velocidad = 0
un objeto independiente un objeto independiente
4
Anatomía de una clase en Python
class declara la clase; __init__ se ejecuta automáticamente al crear cada objeto.
class Vehiculo:
def __init__(self, marca):
[Link] = marca # atributo
[Link] = 0 # atributo
def acelerar(self): # método
[Link] += 10
mi_coche = Vehiculo("Toyota") # crear objeto
__init__ self atributo método
Se ejecuta al crear el objeto. Hace referencia al propio objeto. Un dato que vive en el objeto. Función definida dentro de la clase.
5
Pilar 1 · Encapsulamiento
Ocultar los datos internos y exponer solo lo necesario para modificarlos de forma segura.
EN EL MUNDO REAL EN PYTHON
class Vehiculo:
def __init__(self, marca):
No metes la mano en el tanque para repostar: usas la [Link] = marca
manguera del surtidor. Esa "manguera" es el método self.__combustible = 100 # privado
que controla cómo cambia el nivel interno de def repostar(self, litros):
combustible. self.__combustible += litros
def ver_combustible(self):
return self.__combustible
OTRO EJEMPLO
class Persona: mi_coche = Vehiculo("Toyota")
def __init__(self, edad): mi_coche.repostar(20)
self.__edad = edad # privado # mi_coche.__combustible -> no accesible
6
Pilar 2 · Herencia
Una clase puede heredar atributos y métodos de otra, reutilizando código y especializándolo.
EN EL MUNDO REAL EN PYTHON
# Vehiculo ya está definido
class Coche(Vehiculo): # hereda
Todo vehículo motorizado acelera y tiene marca. def tocar_bocina(self):
Pero un coche además toca el claxon, y una moto print("¡Beep beep!")
hace caballito: cada tipo añade su propio class Moto(Vehiculo): # hereda
comportamiento. def hacer_caballito(self):
print("¡Wheelie!")
OTRO EJEMPLO mi_coche = Coche("Toyota")
class Animal: mi_coche.acelerar() # heredado
def comer(self): print("Comiendo") mi_coche.tocar_bocina() # propio
class Perro(Animal):
def ladrar(self): print("Guau")
7
Pilar 3 · Polimorfismo
Distintas clases responden al mismo método, cada una a su manera.
EN EL MUNDO REAL EN PYTHON
# Coche y Moto ya existen
class Coche(Vehiculo):
Frenar significa algo distinto según el vehículo: un def frenar(self):
coche activa frenos de disco, una moto usa frenado print(f"{[Link]}: frenos de disco")
combinado. Misma orden, distinta ejecución. class Moto(Vehiculo):
def frenar(self):
print(f"{[Link]}: frenado combinado")
OTRO EJEMPLO for v in [Coche("Toyota"), Moto("Yamaha")]:
class Circulo: [Link]() # distinta respuesta
def area(self): return 3.14*self.r**2
class Cuadrado:
def area(self): return [Link]**2
8
Pilar 4 · Abstracción
Mostrar solo lo esencial y ocultar los detalles complejos de implementación.
EN EL MUNDO REAL EN PYTHON
# Coche ya hereda de Vehiculo
class Coche(Vehiculo):
Para arrancar el coche giras la llave o pulsas un def arrancar(self):
botón. No necesitas saber cómo se inyecta el self.__inyectar_combustible()
self.__generar_chispa()
combustible o salta la chispa del motor. print("Motor en marcha")
def __inyectar_combustible(self):
... # detalle interno
OTRO EJEMPLO def __generar_chispa(self):
class Cafetera: ... # detalle interno
def hacer_cafe(self):
self.__moler() mi_coche.arrancar() # interfaz simple
print("Café listo")
9
Todo junto: un mini sistema de vehículos
Los 4 pilares trabajando en un mismo programa.
class Vehiculo:
def __init__(self, marca):
[Link] = marca
self.__combustible = 100 # encapsulamiento
def repostar(self, litros):
self.__combustible += litros
class Coche(Vehiculo): # herencia
def frenar(self):
print(f"{[Link]}: frenos de disco")
class Moto(Vehiculo): # herencia
def frenar(self):
print(f"{[Link]}: frenado combinado")
flota = [Coche("Toyota"), Moto("Yamaha")]
for v in flota:
[Link]() # polimorfismo
Resultado: Toyota: frenos de disco / Yamaha: frenado combinado
10
Los 4 pilares de la POO
Un repaso rápido antes de pasar a la práctica.
01 02 03 04
Encapsulamiento Herencia Polimorfismo Abstracción
Protege el combustible interno Coche y Moto reutilizan lo frenar() se comporta distinto en arrancar() oculta los detalles del
del objeto. común de Vehiculo. cada clase. motor.
11
¡Gracias!
Una clase es el plano; un objeto, la instancia real. Encapsulamiento, herencia, polimorfismo y
abstracción son las herramientas para organizar mejor tu código.
Reto para practicar: crea una clase Bicicleta que herede de Vehiculo.