FULL STACK PYTHON

Clase 30
PYTHON 6
Colaboración entre clases y
encapsulamiento
Les damos la bienvenida
Vamos a comenzar a grabar la clase
 Clase 29 Clase 30 Clase 31

Clases y objetos Colaboración entre clases y Herencia y Polimorfismo

Encapsulamiento
● Paradigmas de programación. ● Herencia.
Programación estructurada vs ● Mensajes y Métodos. ● Polimorfismo.
POO. ● Colaboración entre clases. ● Herencia simple y múltiple.
● Clases, objetos y atributos. ● Atributos de clase. ● Clases Abstractas.
● Métodos de clase y métodos ● Composición. ● Diagrama de Clases.
especiales: init, del y str. ● Encapsular atributos y
métodos.
● Decorators.
Colaboración de clases
Normalmente en un problema resuelto con la metodología de
programación orientada a objetos no interviene una sola clase, sino que
hay muchas clases que interactúan y se comunican.
Esta colaboración entre clases se manifiesta como la posibilidad de
utilizar en una clase objetos que son instancias de una clase diferente.
Este mecanismo potencia el alcance que tiene la Programación
Orientada a Objetos, facilitando aún más el desarrollo de soluciones a
problemas complejos sin necesidad de escribir código extenso o difícil
de leer.
Colaboración de clases
Para entender cómo se produce la colaboración entre clases vamos a
desarrollar algunos ejemplos, explicando paso a paso que estamos haciendo.

Enunciado 1:

● Un banco tiene 3 clientes que pueden hacer depósitos y extracciones.

● El banco necesita obtener, al final del día, un reporte de la cantidad de
dinero que sus clientes han depositado.

Del enunciado se deduce que necesitamos objetos de dos clases: clientes y

bancos. Para cada una de estas entidades necesitamos crear una clase, y
luego instanciar la cantidad necesaria de cada objeto.
Colaboración de clases
Identificadas las clases, que llamaremos Cliente y Banco respectivamente,
definimos qué atributos y métodos necesitamos implementar en cada una.

monto 3 objetos
de la clase
nombre Cliente
Atributos Atributos

__init__
Cliente Banco __init__
depositar
Métodos Métodos operar
extraer
depositos_t
retornar_mo otales
nto
Colaboración de clases | Clase Cliente
Clase Cliente
En el método __init__ se inicializan
class Cliente:
los atributos nombre con el valor del def __init__(self,nombre):
self.nombre=nombre
parámetro, y monto con el valor cero. self.monto=0

Los métodos depositar, extraer, def depositar(self,monto):

self.monto=self.monto+monto
retornar_monto e imprimir se
def extraer(self,monto):
definen como se ve a la derecha. self.monto=self.monto-monto

No se instancian objetos de esta def retornar_monto(self):

return self.monto
clase en el cuerpo del programa, ya
def imprimir(self):
que serán atributos de la clase print("{} tiene depositada la suma de
{}".format(self.nombre,self.monto))
Banco.
Colaboración de clases | Banco
Al definir la clase Banco se incluye en su constructor la instancia de tres
objetos de la clase Cliente. Estos objetos serán utilizados por la clase Banco
para que su instancia (sólo se instancia un objeto de la clase Banco) sea
capaz de operar con los clientes.

En el método operar se invocan algunos métodos de la clase Cliente, para

generar las transacciones (depósitos y extracciones).

Con el método depositos_totales se calcula la suma de los montos

depositados por los objetos de la clase Cliente, y se guardan en la variable
total, que luego se muestra en la terminal mediante print()
Colaboración de clases | Banco
Clase Banco
class Banco:
def __init__(self):
self.cliente1=Cliente("Juan")
self.cliente2=Cliente("Ana")
self.cliente3=Cliente("Diego")

def operar(self):
self.cliente1.depositar(100)
self.cliente2.depositar(150)
self.cliente3.depositar(200)
self.cliente3.extraer(150)

def depositos_totales(self):
total=self.cliente1.retornar_monto()+self.cliente2.retornar_monto()+self.cliente3.retornar_monto()
print("El total de dinero en el banco es: {}".format(total))
self.cliente1.imprimir()
self.cliente2.imprimir()
self.cliente3.imprimir()
Colaboración de clases | Programa principal
En el programa principal se instancia un objeto de la clase Banco, y se invocan
sus métodos operar() y depositos_totales():
Programa principal Terminal
# Programa principal: El total de dinero en el banco es: 300
banco1 = Banco() Juan tiene depositada la suma de 100
banco1.operar() Ana tiene depositada la suma de 150
banco1.depositos_totales() Diego tiene depositada la suma de 50

Al invocar el método operar() de la clase Banco se llama a los métodos

depositar() y extraer() de la clase Cliente. Al llamar al método
depositos_totales() de la clase Banco se llama al método retornar_monto() e
imprimir() de la clase Cliente. Ambas clases colaboran para resolver la
situación planteada en el enunciado.
Atributos de clase
Los atributos de clase, a diferencia de los atributos de instancia, son
compartidos por todos los objetos de dicha clase. Los atributos de clase se
definen dentro de la clase pero fuera de sus métodos:

Programa principal Terminal Importante: p1.variable = 30 no modifica

class Persona: el valor del atributo de clase del mismo
variable=20 # Atributo de clase nombre, sino que crea un atributo de
def __init__(self, nombre): instancia que existe solo para ese objeto.
self.nombre=nombre Por lo tanto, cuando volvemos a consultar
su valor, vemos “30” que es el valor de su
p1 = Persona("Aldo") atributo de instancia.
p2 = Persona("Berta")
Valor en p1: 20 Si existe un atributo de clase y uno de
print("Valor en p1:",p1.variable)
print("Valor en p2:",p2.variable) Valor en p2: 20 instancia con el mismo nombre, tiene
p1.variable = 30 prioridad el de la instancia. El cambio de
print("Valor en p1:",p1.variable) Valor en p1: 30 valor no afecta a p2, que sigue mostrando el
print("Valor en p2:",p2.variable) Valor en p2: 20 valor del atributo de clase.
Atributos de clase
Apliquemos el concepto de atributo de clase en un caso concreto, que
implementa una lista compartida entre los objetos de esa clase:

Enunciado 2:

● Define una clase Cliente que almacena un código de cliente y un

nombre.
● En la clase Cliente define un atributo de clase de tipo lista que
almacene todos los clientes con sus cuentas corrientes suspendidas.
● Imprimir por pantalla todos los datos de clientes y el estado en que se
encuentra su cuenta corriente.
Atributos de clase | Clase Cliente
La clase Cliente posee varios atributos de instancia, métodos y un atributo
de clase, que es del tipo lista:

suspendidos codigo
(lista)
nombre
Atributos

Atributos __init__
Cliente
de clase
imprimir
Métodos
suspender

esta_suspendida
Atributos de clase | Clase Cliente
Clase Cliente (Parte I)
La lista suspendidos es compartida
class Cliente:
por todos los objetos de la clase. suspendidos=[] #Atributo de Clase

def __init__(self,codigo,nombre):
El método imprimir muestra los self.codigo=codigo #Atributo de instancia
datos y estado de la cuenta de cada self.nombre=nombre #Atributo de instancia

instancia de la clase Cliente. def imprimir(self):

print(f"Codigo: {self.codigo}")
print(f"Nombre: {self.nombre}")
El método suspender agrega el self.esta_suspendido()
código de un cliente a la lista del def suspender(self):
cliente suspendido. Cliente.suspendidos.append(self.codigo)
Atributos de clase | Clase Cliente y programa ppal.
Clase Cliente (Parte I) y programa ppal:
El método esta_suspendido verifica
def esta_suspendido(self):
si el código del cliente se encuentra if self.codigo in
Cliente.suspendidos:
en la lista suspendidos, que es un print("Esta suspendido")
atributo de clase. else:
print("No esta suspendido")
print("_"*20)
Dentro del cuerpo principal del
# Programa principal:
programa se instancian cuatro cliente1 = Cliente(1,"Juan")
clientes, y se suspenden dos de ellos cliente2 =
cliente3 =
Cliente(2,"Ana")
Cliente(3,"Diego")
mediante el método cliente4 = Cliente(4,"Pedro")

correspondiente: cliente3.suspender()
cliente4.suspender()
Atributos de clase | Ejecución
Si en este punto invocamos el método imprimir de cada instancia, vemos:
Programa principal Terminal Es importante recordar que todos los
# Programa principal: Codigo: 1 objetos acceden a una única lista
cliente1 = Cliente(1,"Juan") Nombre: Juan
cliente2 = Cliente(2,"Ana") No esta suspendido llamada suspendidos gracias a que se
cliente3 = Cliente(3,"Diego") ____________________ definió como un atributo de clase.
cliente4 = Cliente(4,"Pedro") Codigo: 2
Nombre: Ana
No esta suspendido Podemos ver el contenido de la lista
cliente3.suspender()
____________________ con:
cliente4.suspender() Codigo: 3
Nombre: Diego Programa principal Terminal
cliente1.imprimir() Esta suspendido
cliente2.imprimir() print(Cliente.suspendidos) [3, 4]
____________________
cliente3.imprimir() Codigo: 4
cliente4.imprimir() Nombre: Pedro
Esta suspendido
____________________
Composición
Cada clase que definimos es un nuevo tipo de datos, con sus atributos y
métodos. Y al igual que los demás tipos de datos, los objetos instanciados a
partir de ellas se pueden utilizar como parte de colecciones o incluso ser parte
de otras clases.
La composición es uno de los conceptos fundamentales de la POO. Tiene
lugar cuando una clase (clase “que tiene”) hace referencia a uno o más objetos
de otras clases (clases “que son parte de”), como una variable de instancia.
+info
Al usar el nombre de la clase o al crear el objeto, se accede a los miembros de
una clase dentro de otra clase. La composición permite crear tipos complejos
mediante la combinación de objetos de diferentes clases.
Composición
Mediante la composición solo se puede utilizar la otra clase (la “que es parte
de”), no se puede modificar ni extender la funcionalidad de la misma. No
proporciona funciones adicionales. Así, cuando se necesita usar otra clase sin
ninguna modificación, se recomienda la composición

Enunciado 3:
● Define una clase Pelicula que gestione datos de películas
● La clase Película tiene los atributos título, duración y lanzamiento, e
implementa __str__ para mostrar sus datos.
● Define la clase Catalogo, que administra una lista de películas. Estas
películas son objetos de la clase Película. Debe implementar los métodos
mostrar y agregar películas.
Composición
Se implementan dos clases, que llamaremos Pelicula (“es parte de”) y
Catalogo (clase “que tiene”) respectivamente

peliculas peliculas titulo

(lista) (objeto de
la clase duracion
Atributos Peliculas) Atributos

lanzamiento
Atributos
Catalogo Peliculas
de clase __init__
__init__
Métodos agregar Métodos
__str__
mostrar
Composición | Clase Pelicula
Definición de la clase Pelicula. Esta es la clase que, en la composición, se
comporta como “clase que es parte de”, ya que sus instancias serán parte de
la clase Catalogo.
Clase Pelicula
class Pelicula:
# Constructor de clase
def __init__(self, titulo, duracion, lanzamiento):
self.titulo = titulo
self.duracion = duracion
self.lanzamiento = lanzamiento
print(f'Se ha creado la película: {self.titulo}')

def __str__(self):
return f'{self.titulo} ({self.lanzamiento})'
Composición | Clase Catalogo
Definición de la clase Catalogo. En la composición se comporta como “clase
que tiene”, ya uno de sus atributos de instancia es un objeto de la clase
Pelicula.
Clase Catalogo
class Catalogo:
peliculas = [] # Esta de objetos de la clase Pelicula
# Constructor de clase
def __init__(self, peliculas=[]):
Catalogo.peliculas = peliculas

def agregar(self, p): # p es un objeto Pelicula

Catalogo.peliculas.append(p)

def mostrar(self):
for p in Catalogo.peliculas:
print(p) # Print toma por defecto str(p)
Composición | Programa principal
Definición de la clase Catalogo. En la composición se comporta como “clase
que tiene”, ya uno de sus atributos de instancia es un objeto de la clase
Pelicula.
Programa principal Terminal
# Instanciamos una película
peli1 = Pelicula("El Padrino", 175, 1972)
Se ha creado la película: El Padrino
# Instanciamos un catálogo que contiene una pelicula
c = Catalogo([peli1]) El Padrino (1972)
c.mostrar()
Se ha creado la película: El Padrino: Parte 2
# Añadimos una nueva película al catálogo:
El Padrino (1972)
c.agregar(Pelicula("El Padrino: Parte 2", 202, 1974)) El Padrino: Parte 2 (1974)
c.mostrar()
Encapsulación | Atributos protegidos
Si el nombre de un atributo está precedido por un guión bajo, significa que es
un atributo protegido. Solo puede ser accedido por esa clase y es una buena
práctica para los atributos (o métodos) de uso interno, sobre todo en
programas que recurren a muchas clases. De lo contrario, resulta, en realidad,
innecesario.
Programa principal Terminal
class Vehiculo: Traceback (most recent call last):
def __init__(self, marca, color, placa): File "prueba.py", line 13, in <module>
self._marca = marca print(coche.marca)
self._color = color AttributeError: 'Vehiculo' object has no attribute
self._placa = placa
'marca'. Did you mean: '_marca'?
coche = Vehiculo("Ford", "Rojo", "AB123CD")
print(coche.marca)
Encapsulación
Encapsulación se refiere al ocultamiento de los atributos o métodos de una
clase al exterior, para que no se puedan acceder ni modificar desde fuera. Por
defecto Python no oculta los atributos y métodos de una clase al exterior:
Programa principal Terminal
class Clase:
atributo_clase = "Hola"
def __init__(self, atributo_instancia):
self.atributo_instancia = atributo_instancia

mi_clase = Clase("Que tal") Hola

print(mi_clase.atributo_clase) Que tal
print(mi_clase.atributo_instancia)

Para ocultar métodos y atributos del exterior se usa doble guión bajo __ en el
comienzo de su nombre. Esto hará que Python los interprete como “privados”.
Encapsulación | Decoradores - setters
Getters y setters:
Un setter permite crear métodos que
class Bebidas:
permiten modificar el valor de un def __init__(self):
atributo privado. self.__bebida = 'Naranja'

@property
En Python se declaran escribiendo def favorita(self):
return f"La bebida preferida es:
antes del método un decorador con {self.__bebida}"
su nombre seguido de .setter.
@favorita.setter
def favorita(self, bebida):
Junto con el decorador @property self.__bebida = bebida

permiten leer y escribir los atributos # Programa principal

privados de manera segura. obj1 = Bebidas()
obj1.favorita = "Pomelo"
print(obj1.favorita) # Pomelo
Encapsulación
Programa principal Terminal
class Clase:
atributo_clase = "Hola" # Accesible desde el exterior
__atributo_clase = "Hola" # No accesible

def __mi_metodo(self): # No accesible desde el exterior

print("Haz algo")
self.__variable = 0

def metodo_normal(self): # Accesible desde el exterior

self.__mi_metodo()

mi_clase = Clase()
#mi_clase.__atributo_clase #AttributeError (atributo no accesible)
#mi_clase.__mi_metodo() #AttributeError (método no accesible)
print(mi_clase.atributo_clase) Hola
mi_clase.metodo_normal() Que tal
Encapsulación
En el ejemplo se ve como los atributos y métodos de la clase Clase cuyos
nombres comienzan con __ no son “visibles” desde el exterior de la clase.
En efecto, __atributo_clase y __mi_metodo() están “encapsulados” en la Clase.
Se puede acceder y modificar desde su interior, pero cuando intentamos
hacerlo desde el exterior Python arroja un error explicando que no es posible.
Por ejemplo, en el código anterior al intentar usar __atributo_clase:

Terminal
Traceback (most recent call last):
File "prueba.py", line 13, in <module>
mi_clase.__atributo_clase
AttributeError: 'Clase' object has no attribute '__atributo_clase' Did you mean:
'atributo_clase'?
Encapsulación
Entonces, los atributos de una clase pueden presentar tres niveles de
privacidad:

● Públicos: Creando un objeto de dicha clase y usando la sintaxis del punto,

podemos acceder y modificar desde otra clase cualquier atributo.
● Protegidos: Un atributo solo puede ser accedido y modificado por la clase
en sí misma (y sus clases hijas, como veremos). Para definir un atributo
como protegido, se declara con un “guión bajo”.
● Privados: Pueden ser accedidos únicamente desde la clase donde fueron
definidos. Su nombre empieza con “dobles guiones bajo”.

Los últimos necesitan implementar getters y setters para implementar el

acceso a ellos.
Encapsulación | Decoradores - getters
Un getter es un mecanismo que permite acceder a un método o atributo
privado. En Python se declaran creando un método con el decorador
@property:
Ejemplo del decorador @property Terminal
class Bebidas:
def __init__(self):
self.__bebida = 'Naranja'

@property
def favorita(self):
return f"La bebida preferida es:
{self.__bebida}"
La bebida
obj1 = Bebidas() preferida es:
print(obj1.favorita) Naranja
Colaboración y encapsulación
Para finalizar, vamos a analizar un nuevo ejemplo:
Enunciado 4:
● Crear una clase Carrera, que tenga un método constructor y otro que
permita agregar materias a la carrera.
● Crear otra clase, Materia, que tenga los atributos privados nombre,
profesor y fecha_inicio. Proporcionar un método para acceder a la
fecha_inicio.
Del enunciado se deduce que necesitamos objetos de dos clases: Carrera y
Materia. Para cada una de estas entidades necesitamos crear una clase, con
sus atributos y métodos.
Colaboración y encapsulación
Identificadas las clases, que llamaremos Cliente y Banco respectivamente,
definimos qué atributos y métodos necesitamos implementar en cada una.

nombre
nombre
Atributos profesor

Atributos materias
(es un conjunto fecha_inicio
de tuplas) Materia
Carrera __init__
__init__
fecha_inicio
Métodos Métodos
(getter)
agregar_materia
fecha_inicio
(setter)
Colaboración y encapsulación
Clase Materia Clase Carrera
class Materia: class Carrera:
def __init__(self, nombre, profesor, fecha): def __init__(self, nombre):
self.nombre = nombre self.nombre = nombre
self.profesor = profesor
#Fecha no puede ser anterior a 2006 #Contendrá tuplas (código, materia)
self.fecha_inicio = fecha self.materias = {}

@property # Este método agrega materias a la

def fecha_inicio(self): # colección de materias
#print("Estoy obteniendo la fecha de inicio") def agregar_materia(self, materia, codigo):
return self._fecha_inicio self.materias[codigo] = materia

@fecha_inicio.setter
def fecha_inicio(self, fecha):
# print("Estoy seteando la fecha de inicio")
if fecha < 2006:
self._fecha_inicio = 2006
else:
self._fecha_inicio = fecha
Colaboración y encapsulación
Clase Materia Terminal
#Creamos una carrera y tres materias
carrera1 = Carrera("Ingeniería en Sistemas")
algebra = Materia("Algebra", "Juan Quinteros", 2004)
fisica = Materia("Física", "Pedro Perez", 2012)
programacion = Materia("Programación", "Lorena Ríos",2022)

#Agregamos las materias a la carrera:

carrera1.agregar_materia(201,algebra)
carrera1.agregar_materia(202,fisica)
carrera1.agregar_materia(203,programacion)

# Veomos la fecha de inicio de dictado de algunas materias:

print(f"La fecha de inicio de {algebra.nombre} es La fecha de inicio de Álgebra es 2006
{algebra.fecha_inicio}") La fecha de inicio de Física es 2012
print(f"La fecha de inicio de {fisica.nombre} es La fecha de inicio de Programación es 2022
{fisica.fecha_inicio}")
print(f"La fecha de inicio de {programacion.nombre} es
{programacion.fecha_inicio}")
Material extra
Artículos de interés
Material extra:

● Guía de la Programación Orientada a Objetos (POO), en Kinsta

● ¿Qué es el encapsulamiento en Python?, en pythones.net
● Programación Orientada a Objetos, en carmoreno.com

Videos:

● Objetos parte III, parte IV y parte V en Píldoras informáticas

● Clases y Objetos en Python, por yacklyon
No te olvides de dar el presente
Recordá:
● Revisar la Cartelera de Novedades.
● Hacer tus consultas en el Foro.
● Realizar los Ejercicios obligatorios.

Todo en el Aula Virtual.