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
[Link] = nombre
[Link] = 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"{[Link]} es de raza {[Link]}" )
#accediendo a los atributos del objeto perro2
print(f"{[Link]} es de raza {[Link]}" )
#modificando el atributo nombre
[Link] = "Tony"
print(f"{[Link]} es de raza {[Link]}" )
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
[Link](5)
# se llama al método ladra
[Link]()
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
[Link]=nombre
[Link]=correo
def getIdentificacion(self):
return self.__identificacion
def setIdentificacion(self, identificacion):
self.__identificacion=identificación
GFPI-F-135 V01
def getNombre(self):
return [Link]
def setNombre(self,nombre):
[Link]=nombre
def getCorreo(self):
return [Link]
def setCorreo(self,correo):
[Link]=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@[Link]")
#Aquí genera error no podemos acceder directamente
print(p.__identificacion)
#Obteniendo el valor del atributo __identificacion
print([Link]())
# modificando el atributo __identificacion
[Link](12)
#Obteniendo el valor del atributo __identificacion y # se verifica el
nuevo valor
print([Link]())
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([Link])
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@[Link]",300)
[Link]()
GFPI-F-135 V01
Relación de Agregación:
GFPI-F-135 V01
Representación en Python
class Alumno():
def __init__(self,nombre,edad):
[Link]=nombre
[Link]=edad
def __str__(self):
return [Link]
class Curso():
def __init__(self,nombre):
[Link]=nombre
[Link]=[]
def matricularAlumno(self, alumno):
[Link](alumno)
def anularMatricula(self, alumno):
[Link](alumno)
Implementación
#Creación de un curso
nuevoCurso = Curso("ADSI")
#Crear alumnos
alumno1 = Alumno("Maria",15)
alumno2 = Alumno("Jose",23)
#Matricular Alumnos
[Link](alumno1)
[Link](alumno2)
print("Alumnos")
for a in [Link]:
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):
[Link]=nombre
[Link]=cargo
[Link]=sueldo
def __str__(self):
return [Link]
class Empresa():
def __init__(self, nombre):
[Link]=nombre
[Link]=[]
def agregarEmpleado(self, nombre,cargo, sueldo):
empleado=Empleado(nombre,cargo,sueldo)
[Link](empleado)
def __str__(self):
return [Link]
def __del__(self):
print("Eliminado")
Implementación
#Creamos una empresa
elSENA = Empresa("SENA")
#Agregamos empleados
[Link]("Martin","Subdirector",5000000)
[Link]("Rosa","Instructor",2500000)
[Link]("Sofia","Asistente",2000000)
#imprimir los empleados de la empresa
print(f"LISTADO DE EMPLEADOS DE LA EMPRESA {elSENA}")
for empleado in [Link]:
print(empleado)
#se elimina la empresa
del elSENA
GFPI-F-135 V01
#se imprimen los empleados de la empresa
for empleado in [Link]:
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: [Link]
• Documentación oficial Python:
[Link]
• Programación Orientada a Objetos Python:
[Link]
• Tutorial [Link]
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
