Programa ión Orientada a Objetos - Clasess

INF-111- Jorge Terán

Índi e general
1. Programa ión orientada a Ob jetos 2
1.1. Introdu ión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1. Deni ión de lases en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.2. Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2. Tipos de métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.1. Métodos estáti os . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.2. Método de lase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3. Vo abulario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4. Ejemplo Prá ti o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2. Heren ia 8
2.1. Heren ia Múltiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2. Vo abulario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3. En apsula ión 10
3.1. Métodos para omparar objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2. Polimorsmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3. Vo abulario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1
Capítulo 1

Programa ión orientada a Objetos

1.1. Introdu ión
La programa ión orientada a objetos es un paradigma de programa ión que se ha inventado en los años del
1980, sin embargo, hoy en día es muy bien a eptado. Este paradigma es más una forma de diseño de apli a iones
que un me anismo para odi ar algoritmos. Mu has de las librerías de Python siguen este paradigma porque
es una muy buena forma de organizar ódigo. No es el úni o paradigma que soporta Python.
La idea bási a viene de un proye to SmallTalk que onsistía en representar tipos datos omo objetos del
mundo real. En la programa ión orientada a objetos (POO) se ategorizan los objetos imitando la forma
de ategorizar que tienen los humanos. Estas deni iones se denominan lases y los ejemplos se denominan
instan ias.
Para representar objetos se utilizan diagramas re tangulares que representan las lases. La gura representa
una persona:

Persona

nombre : str
edad : int
genero : str

Para la lase persona se han denido los atributos nombre de tipo adena, edad de tipo entero y genero de
tipo adena.
Después se tienen a iones que puede ha er una persona por ejemplo dormir, respirar estos métodos se
anotan omo:

Persona

nombre : str
edad : int
genero : str

dormir()
respirar()

Hay que ha er notar que Python no es un lenguaje que exija la deni ión del tipo de datos. Los tipos se
es riben olo ando dos puntos después del nombre de la variable. Estos tipos no son utilizados por el ompilador.
Estos se utilizan por el entorno de desarrollo para ayudar al programador a no ometer errores.
Las instan ias de una misma lase podrán ha er las mismas a iones:

2
 Instan ia (objeto) Maria Instan ia (objeto) Juan

nombre : Maria nombre : Juan

edad : 25 edad : 23
genero : Femenino genero : mas ulino

dormir() dormir()
respirar() respirar()

Podemos distinguir entre diferentes tipos de personas, por ejemplo, un estudiante tendrá al igual que persona
nombre, edad y genero. Puede tener atributos adi ionales tales omo año, urso y en método tomar examen. Un
profesor puede tener salario, fe ha de ini io y el metodo tomar examen. La gura siguiente muestra dos lases
estudiante y profesor que heredan den atributos y métodos de persona.
Persona Maria

nombre : str nombre : Maria

edad : int edad : 25
genero : str genero : Femenino

dormir() dormir()
respirar() respirar()

Juan

nombre : Juan
edad : 23
genero : mas ulino

dormir()
respirar()

Como se, ve se ha eliminado mu ho ódigo repetido que es una forma de diseño muy de iente.

1.1.1. Deni ión de lases en Python

La deni ión es omo sigue:
lass Persona:
pass
#defini ion de instan ia
Maria=Persona()
Juan=Persona()

En el ejemplo se puso pass para tener una lase va ía. Como ve en la deni ión no se espe i a nada de los
atributos y métodos. Si se imprimen estas variables se obtiene:

print(Persona)
print(Juan)

< lass '__main__.Persona'>

<__main__.Persona obje t at 0x7f226afb48b0>

Si se quiere registrar el nombre utilizamos la nota ión de punto que signi a olo ar un atributo de una
lase después de un punto. Para agregar el nombre a Maria El ódigo es omo sigue:

Maria.nombre='Maria'
print(Maria.nombre)

3
 Esto tiene varios problemas: Juan no tiene un nombre asignado, y es posible que varias instan ias no tengan
todos los atributos que requieren.
Esto se solu iona on un método denominado onstru tor. Este método __init__se dene omo:

lass Persona:
def __init__(self,nombre,edad,genero):
self.nombre=nombre
self.edad=edad
self.genero=genero

EL atributo self se reere a la lase donde se ha olo ado. Ahora para rear instan ias de una lase hay que
pasar los atributos requeridos:

# defini ion de lase

lass Persona:
def __init__(self,nombre,edad,genero):
self.nombre=nombre
self.edad=edad
self.genero=genero
#defini ion de instan ia
Maria=Persona('Maria',25,'femenino')
Juan=Persona('Juan',23,'mas ulino')
print(Maria.nombre)

Un problema que persiste es que para a eder a un atributo; omo se ve en el ódigo para imprimir un
nombre; hay que ono er el nombre del atributo.
Para resolver esto existe el método __str__, que indi a lo que hay que devolver uando se imprime la
instan ia.

# defini ion de lase

lass Persona:
def __init__(self,nombre,edad,genero):
self.nombre=nombre
self.edad=edad
self.genero=genero
def __str__(self):
return f'Nombre={self.nombre}, Edad={self.edad}, Genero={self.genero}'
#defini ion de instan ia
Maria=Persona('Maria',25,'femenino')
Juan=Persona('Juan',23,'mas ulino')
print(Juan)

El resultado es la adena que se devolvió en el método:

Nombre=Juan, Edad=23, Genero=mas ulino

1.1.2. Métodos
Ahora es ne esario implementar los métodos dormir y respirar.

# defini ion de lase

lass Persona:
def __init__(self,nombre,edad,genero):
self.nombre=nombre
self.edad=edad

4
 self.genero=genero
def __str__(self):
return f'Nombre={self.nombre}, Edad={self.edad}, Genero={self.genero}'
def dormir(self):
print(f'{self.nombre} esta durmirndo')
def respirar(self):
print(f'{self.nombre} esta respirando')

#defini ion de instan ia

Maria=Persona('Maria',25,'femenino')
Juan=Persona('Juan',23,'mas ulino')
#uso del metodo
Juan.dormir()

Como ve al llamar al método dormir se pro esa el método. Como se dijo on anterioridad self se reere a la
instan ia que llamó al método.

1.2. Tipos de métodos

Existen tres métodos de lase que son: métodos de lase, métodos estáti os y métodos de instan ia.
Para ejempli ar esto el ejemplo rea una lase al uladora:

lass al uladora:
def __init__(self,version):
self.version=version
def des rip ion(self):
print(f'Esta orriendo la version: {self.version}')

a= al uladora(10)
b= al uladora(20)
a.des rip ion() # 10
b.des rip ion() # 20

El método des rip ión se denomina método de instan ia. Esto dado que ada instan ia utiliza el valor
denido por la variable self

1.2.1. Métodos estáti os

Se agrega el siguiente método que halla la suma de una antidad de números que pasan omo parámetros:

def sumar(self,*numeros):
print(sum(numeros))

Vea que el resultado que éste método produ e, no depende de la lase dado que no utiliza la variable self.
Por esta razón puede ponerse omo un método fuera de la lase, omo sigue:

def sumar(*numeros):
print(sum(numeros))

Por este motivo se denomina método estáti o. También se puede mantenerse denomina en la lase indi ando
que es un método estáti o. Para esto se utilizan anota iones que son instru iones no eje utables que ayudan a
entender el ódigo.

5
 stati method
def sumar(*numeros):
print(sum(numeros))

La instru ión stati method es una anota ión. Esto es una instru ión que se le da al ompilador para que
sepa que ha er. Esto informa a otros desarrolladores que uno ha de idido mantener el método dentro la lase.

1.2.2. Método de lase

En mu has o asiones se requiere más de un onstru tor para una lase. Como ejemplo tome una lase prsona
que onsiste de nombre y edad. Es posible que en algunos asos en lugar de la edad se quiera ini iar on su año
de na imiento. El ejemplo siguiente muestra el ejemplo:

from datetime import date

lass Persona:e denomina
def __init__(self,nombre,edad):
self.nombre,self.edad=nombre,edad
def des rip ion(self):
print(f'Nombre: {self.nombre} Edad: {self.edad}')
 lassmethod
def edad_desde_anio( ls,nombre,anio):
anio_a tual=date.today().year
edad=anio_a tual-anio
return( ls(nombre,edad))

a=Persona.edad_desde_anio('Juan',1975)
a.des rip ion()

En el ejemplo el método def edad_desde_anio devuelve una lase por eso se denomina  lassmethod. Como
ve se ha ambiado self por ls que representa la lase a tual. La instru ión return devuelve la lase reada
on la edad al ulada en el método. Con la anota ión lassmethod se a lara que es un método alternativo para
rear la lase.

1.3. Vo abulario
Clase.- Es una estru tura (plantilla) que dene los atributos y omportamientos de un objeto. Los atributos
se denen omo variables y los omportamientos omo fun iones.
Atributo.- Un atributo es una variable aso iada a una lase. Los atributos alma enan informa ión espe í a
rela ionada on el objeto.
Constru tor.- Un onstru tor es un método espe ial dentro de una lase que se utiliza para dar valores
ini iales a los atributos de un objeto uando se rea una nueva instan ia.
Método.- Es una fun ión que dene las a iones que puede realizar el objeto.
Anota iones.- Las anota iones se reeren a la apa idad de agregar metadatos o informa ión adi ional a
variables, parámetros de fun iones y métodos
Método estáti o.- Es un método de una lase que no requiere una instan ia de lase para ser llamado.
Requiere un de orador @staticmethod
Método de lase.- En un método una lase que puede devolver una instan ia de la lase. Requiere el
de orador @classmethod

6
1.4. Ejemplo Prá ti o
Se va a rear una tienda de zapatillas, que tiene tres produ tos. Cada produ to tiene mar a y pre io. Para
lo ual se reara una lase para manejar los produ tos.

lass Zapatillas:
def __init__(self, mar a: str, pre io: int):
self.mar a=mar a
self.pre io=pre io

Esta lase tiene dos atributos, mar a y pre io. Para fa ilidad de modi a ión se han denido los tipos de
datos para ada atributo: mar a: str y pre io: int. Es ne esario re ordar que Python no veri ara los tipos de
datos, sin embargo el editor los utilizara para mejorar las ayudas que presta.
Para desplegar los elementos de la lase se implementa el método __str__

def __str__(self) -> str:

return f"Mar a:{self.mar a}, Pre io: {self.pre io}"

Ahora rearemos tres produ tos, de pre io bajo, medio, alto:

bajo=Zapatillas('North Start', 250)

medio=Zapatillas('Puma', 300)
alto=Zapatillas('Adidas', 480)

Par poder trabajar on los produ tos los alma enamos en una lista:

prudu tos=[bajo, medio, alto℄

ahora para listar los produ tos:

for zapatilla in prudu tos:

print(zapatilla)

uyo resultado es:

Mar a:North Start, Pre io: 250

Mar a:Puma, Pre io: 300
Mar a:Adidas, Pre io: 480

Ahora se quiere que el usuario ingrese el monto de dinero que tiene para omprar. Luego omenzando por
el produ to de mayor valor omprar todos los produ tos que se se pueda.
Para esto implementamos el método vender:

def vender(self, monto) -> int:

if monto >= self.pre io:
print(f'Compro {self.mar a} a {self.pre io}')
return monto - self.pre io
return monto

Si el monto al anza para el produ to lo ompra y devuelve el dinero que le queda menos lo gastado.
Para omprar quiere primero omprar el produ to de más valor pro lo que re orremos el ve tor en orden
inverso:

dinero_disponible: int=int(input('Ingrese el dinero que tiene: '))

for zapatilla in reversed(prudu tos):
dinero_disponible: int=zapatilla.vender(dinero_disponible)

7
Capítulo 2

Heren ia
Se entiende por heren ia al on epto de que una lase hereda los métodos de otra. En nuestro ejemplo Profesor
tiene sus propios atributos, sin embargo, debe heredar todo lo orrespondiente a persona. Vea el ejemplo:

lass Persona:
def __init__(self, nombre, edad, genero):
self.nombre = nombre
self.edad=edad
self.genero = genero

def imprimeNombre(self):
print(self.nombre)

lass Profesor(Persona):
def __init__(self, nombre,edad,genero,sueldo):
super().__init__(nombre,edad,genero)
self.sueldo = sueldo
x = Profesor('Ramiro',50,'Mas ulino',1500)
x.imprimeNombre()

En la ini ializa ión de la lase Profesor se han puesto los atributos de persona y el atributo espe í o que es
sueldo. Para rear los datos de la persona se usó super().__init__(nombre,edad,genero). Esto permite Profesor
onoz a que pertene e a persona. Cuando se espe i a super se quiere indi ar a que lase a la que pertene e.
La lase Profesor no tiene el método imprimeNombre y este método es heredado de la lase Persona.
Cuando no tiene atributos adi ionales es su iente:

lass Profesor(Persona):
def imprimirNombre(self):
print(f'Profesor: {self.nombre}')
y=Profesor('Ramiro',50,'Mas ulino')
y.imprimirNombre()

En este aso tiene su propio método imprimirNombre y si los mismos atributos de Persona no requiere un
método init.

2.1. Heren ia Múltiple

Heren ia múltiple se denomina uando un objeto puede heredar métodos de dos o más lases diferentes para
omponer una lase nueva. Consideremos dos lases auto y volador para representar un automóvil y un objeto
volador.

8
 lass Auto:
def __init__(self, puerta, pla a):
self.puerta=puerta
self.aro = pla a
def start(self):
print('Arran ar auto:',self.puerta,self.pla a)
def avanza(self):
print('Avanzando')
lass Volador:
def __init__(self, ala):
self.ala = ala
def start(self):
print('Arran a el objeto Volador',self.ala)
super().start()
def vuele(self):
print('Volando')

Ahora se quiere un automóvil volador, éste nuevo objeto será una ombina ión de las lases Auto y Volador.

lass AutoVolador(Volador, Auto):

def __init__(self, puerta, pla a, ala):
super().__init__(ala=ala)
self.puerta = puerta
self.pla a = pla a
def start(self):
super().start()

Ahora es posible rear un auto volador:

auto = AutoVolador('puerta roja','1765 xyz','ala Delta')

auto.start()
print(AutoVolador.__mro__)

La impresión nal nos muestra que, auto volador es un objeto formado de auto y volador.

(< lass '__main__.AutoVolador'>, < lass '__main__.Volador'>, < lass '__main__.Auto'>, < lass 'obje t

La salida de auto.start() se ha e llamando al método start() de la lase auto y volador.

Arran a el objeto Volador ala Delta

Arran ar auto: puerta roja 1765 xyz

2.2. Vo abulario
Heren ia.- La propiedad de heredar métodos de otra lase.
Heren ia múltiple.- La propiedad de métodos de varias lases.
La propiedad __mro__ .- Lista los objetos que forman el objeto a tual.

9
Capítulo 3

En apsula ión
Cuando los datos de una lase son a esible dire tamente existe el riesgo que se modique y que estas
modi a iones no sean ade uadamente validadas. Por este motivo no todos los datos deben ser a esibles
dire tamente. Este pro eso se denomina en apsula ión.
La nalidad es de que no puedan ser modi ado sin el uso de los métodos de su lase. Vea el siguiente
ejemplo:

lass Persona:
def __init__(self,nombre,edad,genero):
self.nombre=nombre # dato publi o
self.__edad=edad #dato privado
self.genero=genero # dato publi o
def __str__(self):
return f'Nombre={self.nombre}, Edad={self.__edad}, Genero={self.genero}'
y=Persona('Ramiro',50,'Mas ulino')
print(y)
print(y.__edad)

En el atributo edad se han agregado dos guiones bajo antes del nombre. Esto onvierte a edad en una
variable privada solo a esible dentro de la lase.
Cuando se quiere a eder a la variable edad fuera de la lase se obtiene el siguiente mensaje de error.

Tra eba k (most re ent all last):

File "/home/jorge/Py harmProje ts/ lasess/prg2.py", line 10, in <module>
print(y.edad)
AttributeError: 'Persona' obje t has no attribute '__edad'

Para poder a eder a esta variable es ne esario rear métodos, que se denominan geters y seters. A a se han
reado dos métodos uno para a eder a la variable edad y otro para ambiar su ontenido. Respe tivamente son
getEdad y setEdad.

lass Persona:
def __init__(self,nombre,edad,genero):
self.nombre=nombre # dato publi o
self.__edad=edad #dato privado
self.genero=genero
def getEdad(self):
return self.__edad
def setEdad(self,edad):
self.__edad=edad
def __str__(self):
return f'Nombre={self.nombre}, Edad={self._edad}, Genero={self.genero}'

10
y=Persona('Ramiro',50,'Mas ulino')
print(y.getEdad())
y.setEdad(35)
print(y.getEdad())

En la POO en el lenguaje python se han reado dos formas que simpli an la programa ión, estas son:
property y de orator.
Para mostrar su uso se va ha agregar mensajes en pantalla para mostrar que efe tivamente el pro eso pasa
por allí. El uso de property es omo sigue:

lass Persona:
def __init__(self,nombre,edad,genero):
self.nombre=nombre # dato publi o
self.__edad=edad #dato privado
self.genero=genero
def getEdad(self):
print('se llamo el metodo get')
return self.__edad
def setEdad(self,edad):
print('se llamo el metodo set')
self.__edad=edad
def __str__(self):
return f'Nombre={self.nombre}, Edad={self.__edad}, Genero={self.genero}'
edad = property(getEdad, setEdad)
y=Persona('Ramiro',50,'Mas ulino')
print(y.edad)
y.edad=35
print(y.edad)

EL resultado de la eje u ión es omo sigue:

se llamo el metodo get

50
se llamo el metodo set
se llamo el metodo get
35

La ventaja que se ve es que al utilizar no hay que ha er referen ia al método sino dire tamente a las variables.
y los métodos son llamados en forma automáti a. Esto se logra agregando la fun ión property
El uso de de oradores simpli a esto omo sigue:
lass Persona:
def __init__(self,nombre,edad,genero):
self.nombre=nombre # dato publi o
self.__edad=edad #dato privado
self.genero=genero
property
def edad(self):
print('se llamo el metodo get')
return self.__edad
edad.setter
def edad(self,edad):
print('se llamo el metodo set')
self.__edad=edad
def __str__(self):

11
 return f'Nombre={self.nombre}, Edad={self.__edad}, Genero={self.genero}'
y=Persona('Ramiro',50,'Mas ulino')
print(y.edad)
#y.edad=35
print(y.edad)
En lugar de in luir el método property se agrega el de orador property en la línea anterior de la deni ión
de la fun ión. Cada vez que se quiere leer la variable pasa automáti amente por la fun ión.
Se ha reado un segundo de orador on el mismo nombre y que ante ede a la fun ión on el nombre
edad.setter que espe i a que esa es la fun ión que se debe llamar para ambiar el valor.

3.1. Métodos para omparar objetos

Para omparar objetos se utiliza el método __lt__. En nuestro ejemplo persona al agregar el método:

def __lt__(self,otro):
return self.edad < otro.edad

ya es posible ordenar personas por edad. Por ejemplo:

y=Persona('Ramiro',50,'Mas ulino')
x=Persona('Lu ia',35,'Femenino')
l=[y,x℄
l.sort()
for i in l:
print(i)

imprime la lista de personas ordenada por edad.

Nombre=Lu ia, Edad=35, Genero=Femenino

Nombre=Ramiro, Edad=50, Genero=Mas ulino

Existen métodos para la igualdad (eq), menor (lt), menor o igual (le), mayor (gt), mayor o igual (ge). Los
mismo se es riben de la misma forma que el ejemplo mostrado.

3.2. Polimorsmo
Polimorsmo es la apa idad de invo ar a un mismo método y en fun ión al objeto que lo invo a obtiene
un resultado diferente. Para esto es ne esario que las lases que manejarán objetos diferentes tengan el mismo
nombre del método.
Considere dos lases empleado y obrero. Para al ular el salario de obrero y empleado se requieren diferentes
fórmulas para la antigüedad, horas extraordinarias, et . En el ejemplo primero reamos las lases empleado y
obrero. Para simpli idad del ejemplo solo es una lase on un solo método al uloSueldo.

lass Empleado:
def al uloSueldo(self):
print('Cal ulo sueldo empleado')

lass Obrero:
def al uloSueldo(self):
print('Cal ulo sueldo obrero')

Ahora reamos dos objetos diferentes, empleado y obrero, e invo amos al método al uloSueldo

12
a=Empleado()
b=Obrero()
a. al uloSueldo()
b. al uloSueldo()

El resultado es:

Cal ulo sueldo empleado

Cal ulo sueldo obrero

Como ve on el polimorsmo no es ne esario espe i ar a que lase se reere, esto se ha e en forma automáti a
y transparente fa ilitando el desarrollo.

3.3. Vo abulario
En apsular.- Es el pro eso de ha er que los atributos de la lase no puedan a ederse dire tamente.
__lt__.- Remplaza a la las instru ión < para implementar esta omo parte de la lase.
Geter.- Se denomina a la fun ión que permite leer una atributo en una lase.
Seter.- Se denomina a la fun ión que permite ambiar los valores de una atributo en una lase.
property .- es un método que espe i a la fun ión geter y la fun ión seter de un atributo.

@property .- Es un de orador que se pone para indi ar ual es la fun ión. geter de una variable en una
lase.
Polimorsmo. Es la a ión de invo ar a un mismo método para objetos diferentes. Dependiendo del objeto
se realizan las a iones apropiadas.

13