PROCESO DE GESTIÓN DE FORMACIÓN PROFESIONAL INTEGRAL

FORMATO GUÍA DE APRENDIZAJE – MATERIAL DE APOYO

PROGRAMACIÓN ORIENTADA A OBJETOS EN PYTHON

Programación Orientada a Objetos

Paradigma de programación que permite organizar el código de una manera que se

asemeja bastante a como pensamos en la vida real, utilizando las famosas clases. Estas
nos permiten agrupar un conjunto de variables y funciones.

Cualquier cosa u objeto del mundo real puede ser representada mediante una clase. Las
clases representadas tienen diferentes características que se conocen como atributos. Por
otro lado, las clases tienen diferentes funcionalidades o acciones que pueden realizar,
conocidas en la POO como métodos.

La programación orientada a objetos se basa en 6 principios o pilares básicos:

• Herencia
• Cohesión
• Abstracción
• Polimorfismo
• Acoplamiento
• Encapsulamiento

Herencia:

Es el mecanismo por el cual una clase permite heredar las características (atributos y
métodos) de otra clase

Abstracción:

La abstracción son las características especificas de un objeto, aquellas que lo distinguen

de los demás tipos de objetos y que logran definir límites conceptuales respecto a quien
está haciendo dicha abstracción del objeto.

Cohesión:

Medida que indica si una clase tiene una función bien definida dentro del sistema. El objetivo
es enfocar de la forma más precisa posible el propósito de la clase. Cuanto más
enfoquemos el propósito de la clase, mayor será su cohesión.

GFPI-F-135 V01
Polimorfismo:

Es la capacidad que tienen los objetos de una clase en ofrecer respuesta distinta e
independiente en función de los parámetros (diferentes implementaciones) utilizados
durante su invocación. Dicho de otro modo el objeto como entidad puede contener valores
de diferentes tipos durante la ejecución del programa.

Acoplamiento:

El acoplamiento entre clases es una medida de la interconexión o dependencia entre esas

clases. El acoplamiento fuerte significa que las clases relacionadas necesitan saber detalles
internos unas de otras, los cambios se propagan por el sistema y el sistema es posiblemente
más difícil de entender. Como recomendación se debe siempre intentar que nuestras clases
tengan un acoplamiento bajo. Cuantas menos cosas conozca la clase A sobre la clase B,
menor será su acoplamiento.

Encapsulamiento:

Es el proceso que consiste en organizar los datos y operaciones (métodos) de una clase
que constituyen su estructura y su comportamiento con el fin de evitar el acceso a datos
por cualquier otro medio que no sea el especificado y por esto el encapsulamiento de datos
asegura la integridad de los datos que contiene el objeto

Definición de una Clase

GFPI-F-135 V01
Representación en Python

class Perro:

# El método __init__ es el método constructor

def __init__(self, nombre, raza):
print(f"Creando perro {nombre}, {raza}")
# Atributos de instancia
self.nombre = nombre
self.raza = raza

def ladrar(self):
print("Guau")

def caminar(self, pasos):

print(f"Caminando {pasos} pasos")

Creación de objetos de la clase Perro

self es un parámetro especial que siempre se utilizará como una referencia al objeto mismo.
Debe ser siempre el primer parámetro formal; no obstante, nunca se le dará un valor de
parámetro real en la invocación.

#creando un objeto llamado perro 1 de tipo Perro

perro1 = Perro("Tango", "Beagle")

#creando un objeto llamado perro2 de tipo Perro

perro2 = Perro("Zeus", "Pastor Alemán")

Accediendo a atributos

#accediendo a los atributos del objeto perro1

print(f"{perro1.nombre} es de raza {perro1.raza}" )

#accediendo a los atributos del objeto perro2

print(f"{perro2.nombre} es de raza {perro2.raza}" )

#modificando el atributo nombre

perro2.nombre = "Tony"
print(f"{perro2.nombre} es de raza {perro2.raza}" )

GFPI-F-135 V01
Accediendo a los métodos

#se llama al método camina y se pasa como el valor de 5

#que corresponde al número de pasos
perro1.caminar(5)
# se llama al método ladra
perro1.ladrar()

Encapsulación de Atributos

Para definir un atributo como privado debemos anteponer dos guiones seguidos al nombre
del atributo como se muestra a continuación con el atributo identificación; y para poder
acceder al atributo creamos un método que retorne o modifique su valor.

class Persona():

def __init__(self,identificacion, nombre, correo):

self.__identificacion=identificacion
self.nombre=nombre
self.correo=correo

def getIdentificacion(self):
return self.__identificacion

def setIdentificacion(self, identificacion):

self.__identificacion=identificación

GFPI-F-135 V01
 def getNombre(self):
return self.nombre

def setNombre(self,nombre):
self.nombre=nombre

def getCorreo(self):
return self.correo

def setCorreo(self,correo):
self.correo=correo

como el atributo es privado no podemos acceder a él de forma directa sino que tenemos
que hacerlo a partir de un método.

p = Persona(11,"Pedro","pedro@yahoo.com")

#Aquí genera error no podemos acceder directamente

print(p.__identificacion)

#Obteniendo el valor del atributo __identificacion

print(p.getIdentificacion())

# modificando el atributo __identificacion

p.setIdentificacion(12)

#Obteniendo el valor del atributo __identificacion y # se verifica el

nuevo valor
print(p.getIdentificacion())

Uso del Decorador @property

Se usa para modificar un método y haga que actue como un atributo.

@property
def identificacion(self):
return self.__identificacion

En el código anterior parece un método pero en realidad no lo es, debe ser tratado como
un atributo. Por lo tanto al llamado no debemos colocar los paréntesis.

Ejemplo de implementación:

#Llamado método @property

print(p.identificacion)

GFPI-F-135 V01
Representación de Herencia

Proceso mediante el cual se puede crear una clase hija que hereda de una clase padre,
compartiendo sus métodos y atributos. Además de ello, una clase hija puede sobreescribir
los métodos o atributos, o incluso definir unos nuevos.

GFPI-F-135 V01
Representación en Python

class Persona():

def __init__(self,identificacion, nombre, correo):

self.__identificacion=identificacion
self.__nombre=nombre
self.__correo=correo

def getIdentificacion(self):
return self.__identificacion

def setIdentificacion(self, identificacion):

self.__identificacion=identificacion

def getNombre(self):
return self.__nombre

def setNombre(self,nombre):
self.__nombre=nombre

def getCorreo(self):
return self.__correo

def setCorreo(self,correo):
self.__correo=correo

class Aprendiz(Persona):

def __init__(self, identificacion, nombre, correo, puntajeIcfes):

super().__init__(identificacion, nombre, correo)
self.__puntajeIcfes=puntajeIcfes

def getPuntajeIcfes(self):
return self.__puntajeIcfes

def setPuntajeIcfes(self, puntajeIcfes):

self.__puntajeIcfes=puntajeIcfes

GFPI-F-135 V01
class Instructor(Persona):

def __init__(self, identificacion, nombre, correo, especialidad):

super().__init__(identificacion, nombre, correo)
self.__especialidad=especialidad

def getEspecialidad(self):
return self.__especialidad

def setEspecialidad(self, especialidad):

self.__especialidad=especialidad

Polimorfismo

def saludar(self):
print(f"Desde Persona... Hola soy un objeto de tipo {type(self).__
name__}")

def saludar(self):
print(f"Desde Aprendiz... Hola soy un objeto de tipo {type(self)._
_name__}")

def saludar(self):
print(f"Desde Instructor....Hola soy un objeto de tipo {type(self)
.__name__}")

En el escenario anterior tenemos un método que se llama igual tanto en la clase padre
como en la clase Hijo. Si se llama al método desde una clase hija se ejecuta el método
propio y sino llegará a existir ejecuta el método de la clase padre.

apr = Aprendiz(12,"juan","jjj@yahoo.com",300)
apr.saludar()

GFPI-F-135 V01
Relación de Agregación:

GFPI-F-135 V01
Representación en Python

class Alumno():

def __init__(self,nombre,edad):
self.nombre=nombre
self.edad=edad

def __str__(self):
return self.nombre

class Curso():

def __init__(self,nombre):
self.nombre=nombre
self.alumnos=[]

def matricularAlumno(self, alumno):

self.alumnos.append(alumno)

def anularMatricula(self, alumno):

self.alumnos.remove(alumno)

Implementación

#Creación de un curso
nuevoCurso = Curso("ADSI")

#Crear alumnos
alumno1 = Alumno("Maria",15)
alumno2 = Alumno("Jose",23)

#Matricular Alumnos
nuevoCurso.matricularAlumno(alumno1)
nuevoCurso.matricularAlumno(alumno2)

print("Alumnos")
for a in nuevoCurso.alumnos:
print(a)

Ahora implementar el método __del__ de la clase Curso para eliminar la instancia de un

objeto y después se verifica que todavía existen los alumnos.

GFPI-F-135 V01
Relación de Composición

GFPI-F-135 V01
Codificación en Python

class Empleado():

def __init__(self, nombre,cargo,sueldo):

self.nombre=nombre
self.cargo=cargo
self.sueldo=sueldo

def __str__(self):
return self.nombre

class Empresa():

def __init__(self, nombre):

self.nombre=nombre
self.empleados=[]

def agregarEmpleado(self, nombre,cargo, sueldo):

empleado=Empleado(nombre,cargo,sueldo)
self.empleados.append(empleado)

def __str__(self):
return self.nombre

def __del__(self):
print("Eliminado")

Implementación

#Creamos una empresa

elSENA = Empresa("SENA")
#Agregamos empleados
elSENA.agregarEmpleado("Martin","Subdirector",5000000)
elSENA.agregarEmpleado("Rosa","Instructor",2500000)
elSENA.agregarEmpleado("Sofia","Asistente",2000000)

#imprimir los empleados de la empresa

print(f"LISTADO DE EMPLEADOS DE LA EMPRESA {elSENA}")
for empleado in elSENA.empleados:
print(empleado)

#se elimina la empresa

del elSENA

GFPI-F-135 V01
#se imprimen los empleados de la empresa
for empleado in elSENA.empleados:
print(empleado)

Al ejecutar al final debe mostrar algún error por intentar mostrar los empleados de la
empresa elSENA que ya no existe

Referencias:

• Tutorial Python: https://www.w3schools.com/python

• Documentación oficial Python:
https://docs.python.org/es/3.9/library/io.html?highlight=working%20streams
• Programación Orientada a Objetos Python:
https://j2logo.com/python/tutorial/programacion-orientada-a-objetos/
• Tutorial https://j2logo.com/python/tutorial/programacion-orientada-a-objetos/

CONTROL DEL DOCUMENTO

Nombre Cargo Dependencia Fecha

Autor (es) César Marino Cuéllar Chacón Instructor CIES-NEIVA 29-7-2021

GFPI-F-135 V01