Este documento explica los conceptos básicos de la programación orientada a objetos en Python. Introduce los principios de clases, objetos, atributos, métodos, encapsulación, herencia, polimorfismo y sus beneficios. Explica cómo definir clases, crear objetos e instanciarlas para modelar el mundo real.

1. CLASE Y OBJETOS
EN PYTHON
Mg. Richard E. Mendoza G.

4. Ole-Johan Dahl y Kristen Nygaard

5. ● 1960s -> Simula
● 1970s -> SmallTalk
● 1980s -> C++, Eiffel
● 1990s -> Java
● 2000s -> C#, VB.NET,
Processing
● Actualidad -> Implementación
en lenguajes como Javascript
Historia POO

6. 4. Uso de objetos y módulos

7. ● La programación orientada a objetos es un paradigma de
programación que otorga los medios para estructurar
programas de tal manera que las propiedades y
comportamientos estén envueltos en objetos
individuales
○ En pocas palabras, es un enfoque que nos permite modelar objetos concretos y del
mundo real y las relaciones entre ellos
● Los principios básicos son:
○ Encapsulation
○ Abstraction
○ Inheritance
○ Polyphormism
● Todos los objetos son una instancia de una clase
¿Qué es POO?

8. ● Los tipos básicos en Python
(str, int, bool, etc.) están
diseñados para representar
cosas simples
● Cuando necesitamos crear
estructuras más complejas (por
ejemplo, un hotel), podemos
utilizar clases
● La instancia es el objeto concreto
con valores reales
¿Qué es POO?
class Hotel:#keyword class
pass
#instancia constructor de la clase.
hotel = Hotel()

9. ● Mejor organización a través de
pequeños bloques de código.
● Es más limpio y por ende más
fácilmente legible.
● Facilita el mantenimiento del código.
● Permite Reusar código sin reescribir.
● Abstracción y Encapsulación.
● Herencia y Polimorfismo.
Beneficios de POO

10. La clase es un modelo o prototipo
que define las variables y métodos
comunes a todos los objetos de
cierta clase.
● Plantilla genérica para un
conjunto de objetos de similares
características.
● Se pueden crear numerosos
objetos de una misma clase.
● Desde la perspectiva del
lenguaje, la clase es un tipo de
variable.
El nombre de la clase se escribe en Singular y en CamelCase
Clase
# definición de clase
class <nombre_clase>(<super_clase>):
def __init__(self,<params>):
<expresion>
def <nombre_metodo>(self,<params>):
<expresion>

11. ● Un objeto es una unidad que
engloba en sí mismo características
y comportamiento necesarias para
procesar información. Cada objeto
contiene datos y funciones.
● Es una instancia de un clase.
● Variables en memoria que contienen
el objeto creado a partir de la clase
(plantilla)
Objetos
class Persona:
def init(self, nombre, edad):
self.nombre = nombre
self.edad = edad
def saluda(self, otra_persona):
return f'Hola {otra_persona.nombre,
me llamo {self.nombre}.'
david = Persona('David', 35)
erika = Persona('Erika', 32)
david.saluda(erika) #'Hola Erika, me
llamo David’

12. ● Todas las clases crean objetos y
todos los objetos tienen
atributos. Utilizamos el método
especial __init__ para definir el
estado inicial de nuestra
instancia. Recibe como primer
parámetro obligatorio self (que
es simplemente una referencia a
la instancia).
Atributos de la Instancia
class Hotel:
def __init__(self,
numero_maximo_de_huespedes,
lugares_de_estacionamiento):
self.numero_maximo_de_huespedes =
numero_maximo_de_huespedes
self.lugares_de_estacionamiento =
lugares_de_estacionamiento
hotel =
Hotel(numero_maximo_de_huespedes=50,
lugares_de_estacionamiento=20)
print(hotel.lugares_de_estacionamien
to) # 20

13. ● Características intrínsecas del
objeto.
● Básicamente son las variables del
objeto, solo que técnicamente
pasan a llamarse propiedades o
atributos
Propiedades

14. ● Acciones que puede realizar el
objeto.
● Forma de comunicarse con
objetos.
● Se pueden pasar parámetros a
las funciones en forma de
variables.
Métodos
class Hotel:
...
def anadir_huespedes(self,
cantidad_de_huespedes):
self.huespedes += cantidad_de_huespedes
def checkout(self,
cantidad_de_huespedes):
self.huespedes -= cantidad_de_huespedes
def ocupacion_total(self):
return self.huespedes
hotel = Hotel(50, 20)
hotel.anadir_huespedes(3)
hotel.checkout(1)
hotel.ocupacion_total() # 2

15. class Vehiculo:
def __init__(self, placa, marca, modelo):
self.placa=placa
self.marca=marca
def getPlaca(self):#METODOS ACCESORES
return self.placa
def getMarca(self):
return self.marca
def mostrarVehiculo(self):#METODOS TRANSACCIONAL
print('Placa:'+self.getPlaca()
+'Marca:'+self.getMarca())
placa=input('Ingrese placa:') #INGRESAR VARIABLES
marca=input('Ingrese marca:')
carro=Vehiculo(placa,marca) #INSTANCIAR UN OBJETO
carro.mostrarVehiculo()

16. ● Característica de la POO que consiste en crear varios métodos con el
mismo nombre pero con diferentes listas de parámetro.
● Cada método sobrecargado es diferenciado al compilar y se ejecuta
el método con la lista de parámetros correspondiente.
Sobrecarga de Métodos

17. ● Enfocarnos en la información
relevante.
● Separar la información
central de los detalles
secundarios.
● Podemos utilizar variables y
métodos (privados o
públicos)
Abstracción
class Lavadora:
def __init__(self):
pass
def lavar(self, temperatura='caliente'):
self._llenar_tanque_de_agua(temperatura)
self._lavar()
def _llenar_tanque_de_agua(self,
temperatura):
print(f'Llenando el tanque con agua
{temperatura}')
def _lavar(self):
print('Lavando la ropa')
lavadora = Lavadora()
lavadora.lavar()

18. ● Permite agrupar datos y su
comportamiento.
● Controla el acceso a dichos
datos.
● Previene modificaciones no
autorizadas.
Encapsulación
class Empleado:
def__init__(self, nombre, apellido):
self.nombre = nombre
self.apellido = apellido
@property
def nombreCompleto(self):
return'{}.{}'.format(self.nombre,
self.apellido)
@fullname.setter
def nombreCompleto(self, name):
nombre, apellido = nombre.split(" ")
self.nombre = nombre
self.apellido = apellido
emp_1 = Empleado('Pepe', 'Perez')
print(emp_1.nombreCompleto)

19. ● Permite modelar una jerarquía
declases.
● Permite compartir
comportamiento común en la
jerarquía.
● Al padre se le conoce como
superclase y al hijo como
subclase.
class Rectangulo:
def __init__(self, base, altura):
self.base = base
self.altura = altura
def area(self):
return self.base * self.altura
class Cuadrado(Rectangulo):
def __init__(self, lado):
super().__init__(lado, lado)
if __name__ == '__main__':
rectangulo = Rectangulo(base=3, altura=4)
print(rectangulo.area())
cuadrado = Cuadrado(lado=5)
print(cuadrado.area())
Herencia

20. ● La habilidad de tomar
variasformas.
● En Python, nos permite
cambiar el
comportamiento de una
superclase para
adaptarloalasubclase.
class Persona:
def __init__(self, nombre):
self.nombre = nombre
def avanza(self):
print('Ando caminando')
class Ciclista(Persona):
def __init__(self, nombre):
super().__init__(nombre)
def avanza(self):
print('Ando moviendome en mi bicicleta')
persona = Persona('David')
persona.avanza()
ciclista = Ciclista('Daniel')
ciclista.avanza()
Polimorfismo

21. class Estudiante:
#METODO CONSTRUCTOR
def __init__(self, nombres, apellidos, cedula,carrera,edad):
self.nombres=nombres
self.apellidos=apellidos
self.cedula=cedula
self.carrera=carrera
self.edad=edad
#METODOS DE ACCESO
def getNombres(self):
return self.nombres
def getApellidos(self):
return self.apellidos
def getCedula(self):
return self.cedula
def getCarrera(self):
return self.carrera
def getEdad(self):
return self.edad
#METODOS TRANSACCIONALES
def imprimirEstudiante(self):
print('nNombres:'+self.getNombres())
nombres=input('Ingresar nombres:')
apellidos=input('Ingresar apellidos:')
cedula=input('Ingresar cédula:')
carrera=input('Ingresar carrera:')
edad=input('Ingresar edad:')
estudiante1=Estudiante(nombres,apellidos,cedula,carrera,edad)
estudiante1.imprimirEstudiante()

22. "Programar es entender"
"El idioma mundial es el inglés
hablado por extranjeros”
Kristen Nygaard