Unidad 4 BaseDeDatos POO PDF

UNIDAD IV
POO
MBA. Ing. Juan M. Barreto

UTN - FRBA. Secretara de Cultura y Extensin Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 xxxx xxxxx
Email: cursosprogramados@gmail.com
p. 2
Indice
ndice de contenido
Presentacin:.....................................................................4
Objetivos:............................................................................5
Bloques temticos:............................................................6
1. La clase object...............................................................7
2. Mtodo __init__..............................................................9
3. H....................................................................................10
3. Uso de super................................................................12
3.1. Problema en el uso de super con __init__................................................14
3.2. Problema en el uso de super con argumentos........................................16
4. Mtodos especiales, doble guin bajo al inicio y al

finalUso de __all__...........................................................19
Mtodos especiales, doble guin bajo al inicio y al final
...........................................................................................19
4.1. __all__...................................................................................................19
4.2. __ad__ y __str__..................................................................................20
MBA. Ing. Juan M. Barreto

Medrano 951 2do piso (1179) // Tel. +54 11 xxxx xxxxx
Email: cursosprogramados@gmail.com
p. 3
5. Variables y mtodos de instancia, de clase , estticos

...........................................................................................22
5.1. Variables y mtodo de instancia.........................................................22
5.2. Variables de clase................................................................................23
5.3. Mtodos de clase decorador: @classmethod.................................24
5.4. Mtodos estticos decorador: @staticmethod...............................24
6. Base de datos Almacenaminto mediante POO.......25

6.1. Crear paquete, mdulo y clase 01-bd-POO.....................................25
6.2. Accedemos desde archivo externo Introduccin de comprension.
......................................................................................................................26
7. Creamos mtodos de clase 02-bd-POO..................28

8. Herencia de clase 03-bd-POO..................................29
9. Analizar desde donde llamo a un mdulo 04-bdPOO...................................................................................31
10. Separacin del cdigo en mdulos 05-bd-POO.. .32
11. Uso de __str__ e instancia a travs de constructor
del clase padre 06-bd-POO...........................................34
12. Persistencia de datos 07-bd-POO..........................36
12.1. Crear archivo de bytes de base de datos.........................................36
12.2. Leer desde persona - leerDesdePersona.py................................36
Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
p. 4
12.3. Actualizar datos - actualizarDatos.py...............................................37
Bibliografa.......................................................................38
Presentacin:
xxxxxxxxxxxxxxxxxxxxxxxxxxxx

p. 5
Objetivos:
Que los participantes:
xxxxxxxxxxxxxxxxxxxxxxxxxxx

p. 6
Bloques temticos:
1.- La clase object
2.- Mtodo __init__
3.- Herencia mltiple
4.- Uso de super
5.- Mtodos especiales, doble guin bajo al inicio y al finalUso de __all__
6.- Variables y mtodos de instancia, de clase , estticos
7.- Base de datos Almacenaminto mediante POO.
8.- Creamos mtodos de clase 02-bd-POO.
9.- Herencia de clase 03-bd-POO.
10.- Analizar desde donde llamo a un mdulo 04-bd-POO.
11.- Separacin del cdigo en mdulos 05-bd-POO.
12.- Uso de __str__ e instancia a travs de constructor del clase padre 06-bd-POO.
13.- Persistencia de datos 07-bd-POO

p. 7
1. La clase object
Cada clase definida en Python hereda de la clase "object", por lo que puede utilizar los
mtodos establecidos en dicha clase.
Supongamos la siguiente clase, en la cual lo nico que se encuentra definido es un valor
de variable c1:
00-POO/01-claseObject.py
class Auto:
color = "azul"
objeto = Auto()
print(objeto.color)
print(dir(Auto))
input()
Salida:
azul
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__', '__gt__',
'__hash__', '__init__', '__le__', '__lt__', '__module__',
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'__weakref__', 'color']
Podemos ver dos cosas interesantes, la primera es la definicin de un objeto de la clase
Auto y la impresin del valor de color mediante el mtodo print. En este caso la
inicializacin se est realizando a travs del mtodo __init__ de la clase object.
Lo segundo es que al utilizar el mtodo dir() vemos que existen varios mtodos asociados
a Auto que no hemos definido, dichos mtodos que comienzan y terminan con un doble
guin bajo, son mtodos de la clase object, que se encuentran asociados implcitamente a
la clase Auto.
Nota: De hecho, podemos ver con el agregado del siguiente cdigo, que la clase
Auto tiene como clase padre o superclase a la clase "object", y que en si es un
objeto de la clase "type"

p. 8
00-POO/02-claseObject2.py
class Auto:
color = "azul"
# Instanciamos e imprimimos el objeto de la clase Auto
objeto = Auto()
print(objeto.color)
# Imprimimos los mtodos de la clase Auto
print(dir(Auto))
# Vemos cual es su clase padre
print(Auto.__class__.__base__)
# Vemos si es un objeto de alguna clase
print(Auto.__class__)
input()
Salida:
azul
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__', '__gt__',
'__hash__', '__init__', '__le__', '__lt__', '__module__',
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'__weakref__', 'color']
<class 'object'>
<class 'type'>

p. 9
2. Mtodo __init__
Cuando trabajamos con programacin orientada a objetos POO, una de las cosas ms
importantes a tener en cuenta, es la forma en que creamos dichos objetos. Como
veremos un poco ms adelante la forma correcta de crear los objetos es mediante la
utilizacin de un mtodo (funcin) __init__ el cual es un mtodo reservado de Python que
cumple la funcin de constructor de la clase a la cual se encuentra asociada, es decir una
funcin destinada a inicializar (crear) los objetos de la clase utilizada.
La funcin __init__ puede tomar diferente tipo de argumentos, y para su correcta
utilizacin, debemos comprender como vimos, que cada clase de Python hereda en forma
implcita de la clase "object", es decir que "object" es una superclase de cada clase
definida en Python. Si no implementamos un mtodo __init__ en nuestra clase, por
defecto se ejecuta el mtodo __init__ de la clase object.
Es posible, aunque no es la forma correcta crear variables de instancia sin utilizar un
constructor como ejemplo veamos el siguiente caso en donde podemos ver que para
trabajar con variables de instancia se utiliza dentro de la clase la palabra clave "self"
00-POO/03-init1.py
class Comentario:
def imprimir( self ):
print(self.texto)
objeto = Comentario()
objeto.texto = "Hola variable de instancia"
objeto.imprimir()
input()

p. 10
3. Herencia mltiple
Python soporta herencia mltiple, es decir que una clase puede heredar de ms de una
clase, para indicarlo, lo nico que tenemos que hacer es separar mediante una coma
cada una de las clases de las cuales se hereda en la definicin de la clase. As podramos
tener la clase Comentario que tiene N superclases de la siguiente forma.
class Comentario(Superclase1, Superclase2, ........., SuperclaseN):
def imprimir( self ):
print(self.texto)
Al trabajar con herencia mltiples, debemos tener mucho cuidado, para no cometer
errores, ya que si dos superclases poseen el mismo nombre de mtodo en su definicin,
de cual de las dos hereda el mtodo la clase hija?.
Estas cuestiones las iremos resolviendo con ejemplos y al estudiar el uso de super,
ahora nos ocuparemos de un problema denominado problema del diamante el cual se
da cuando una clase tiene dos superclases, las cuales tiene una superclase en comn.
Veamos el siguiente esquema, de tres niveles, en donde la Clase3 hereda de las Clase2a
y Clase2b y en donde estas dos ltimas a su vez heredan de la Clase1:

p. 11
Supongamos ahora que generamos una instancia de la Clase3 e implementamos un

mtodo declarado en la Clase1, la herencia se lleva a cabo a travs de la rama que
contiene a Clase2a o la que contiene la Clase2b?
Python toma la convencin de crear una lista de clases que:
1.- Busca de izquierda a derecha, y de abajo hacia arriba.
Clase3, Clase2a Clase1, Clase2b Clase1
2.- Se eliminan todas las apariciones repetidas de una clase salvo la ltima.
Clase3, Clase2a Clase1, Clase2b Clase1
queda: Clase3, Clase2a Clase2b, Clase1
Esto lo podemos ver si utilizamos el mtodo reservado __mro__, veamoslo en el siguiente
ejemplo:
00-POO/herenciamultiple.py
class Clase1():
def tipo(self):
print("Soy clase1")
class Clase2a(Clase1):
def tipo(self):
print("Soy clase2a")
class Clase2b(Clase1):
def tipo(self):
print("Soy clase2b")
class Clase3(Clase2a, Clase2b):
def tipo(self):
print("Soy clase3")
print(Clase3.__mro__)

p. 12
Como era de esperar la salida nos retorna:

(<class '__main__.Clase3'>, <class '__main__.Clase2a'>, <class
'__main__.Clase2b'>, <class '__main__.Clase1'>, <class 'object'>)

p. 13
4. Uso de super
Cuando queremos invocar a un mtodo de una superclase desde una clase hija, podemos
utilizar la palabra reservada super, veamos un ejemplo:
00-POO/super.py
class Vehiculo(object):
def tipo(self):
print("Dos ruedas")
class Material(object):
def tipo(self):
print("plstico")
class Moto(Vehiculo, Material):
def modelo(self):
print("Modelo 1")
super(Moto, self).tipo()
super().tipo()
Material.tipo(self)
Vehiculo.tipo(self)
class Bicicleta(Material, Vehiculo):
def modelo(self):
print("Modelo 2")
super(Bicicleta, self).tipo()
super().tipo()
Material.tipo(self)
Vehiculo.tipo(self)
print("---------- Prioridad Clases ------------")
print(Moto.__mro__)
print(Bicicleta.__mro__)
print("---------- para objeto 1 ------------")
objeto1 = Moto()
objeto1.modelo()
objeto1.tipo()
print("---------- para objeto 2 ------------")
objeto2 = Bicicleta()
objeto2.modelo()
objeto2.tipo()

p. 14
La salida nos retorna:

---------- Prioridad Clases -----------(<class '__main__.Moto'>, <class '__main__.Vehiculo'>, <class
'__main__.Material'>, <class 'object'>)
(<class '__main__.Bicicleta'>, <class '__main__.Material'>, <class
'__main__.Vehiculo'>, <class 'object'>)
---------- para objeto 1 -----------Modelo 1
Dos ruedas
Dos ruedas
plstico
Dos ruedas
Dos ruedas
---------- para objeto 2 -----------Modelo 2
plstico
plstico
plstico
Dos ruedas
plstico
Nota: En python 3, la sintaxis se simplifica de super(ClaseHija,self).__init__() a
super().__init().
Nota: En python 3 podemos llamar al mtodo de la case padre desde dentro de la
clase hija, directamente indicando el nombre de la clase padre de la cual queremos
heredar, y con notacin de punto el nombre del mtodo a utilizar:
Ejemplo: Vehiculo.tipo(self)
Mezclar ambos tipos de llamadas dentro de un cdigo puede traer errores serios,
sobre todo al trabajar con __init__, por lo que NO se debe mezclar las dos variantes
dentro de un cdigo.

p. 15
4.1. Problema en el uso de super con __init__

Un problema que se puede presentar en el uso de super con __init__ lo podemos
ejemplificar de la siguiente manera:
00-POO/super1_init.py
def __init__(self):
print("Dos ruedas")
super(Vehiculo,self).__init__()
def __init__(self):
print("plstico")
super(Material,self).__init__()
def __init__(self):
print("Modelo 1")
Vehiculo.__init__(self)
Material.__init__(self)
objeto1 = Moto()
Salida:
Modelo 1
Dos ruedas
plstico
plstico
De dnde sale la impresin de la segunda palabra plstico?
Este error se produce por mezclar el uso de super, con la llamada a una clase padre por
su nombre desde la clase hija, por lo que por regla general nunca se deben mezclar los
dos tipos de llamadas, o se usa una o se usa la otra Nunca que se utiliza la llamada
super desde una clase padre , se debe utilizar la llamada por nombre de superclase
desde la clase hija
La forma correcta sera como sigue:

p. 16
00-POO/super2_init.py
def __init__(self):
print("Dos ruedas")
super(Vehiculo,self).__init__()
def __init__(self):
print("plstico")
super(Material,self).__init__()
def __init__(self):
print("Modelo 1")
super().__init__()
objeto1 = Moto()
Salida:
Modelo 1
Dos ruedas
plstico

p. 17
4.2. Problema en el uso de super con argumentos

Otro problema serio, se da cuando trabajamos con argumentos, en donde se pierden por
el camino los argumentos y dejan de estar presentes en clases que los requieren. En el
ejemplo siguiente si la clase Hijo requiere argumentos, estos van a tener que ser
ingresados y van a ser pasados a la clase Padre, dado que la clase AbueloPaterno no los
requiere, estos se pierden y cuando la clase Madre los requiere ya no estan disponibles.
El cdigo del esquema anterior queda como sigue:

00-POO/super3.py
class AbueloPaterno(object):
def __init__(self):
print("AbueloPaterno")
super(AbueloPaterno, self).__init__()
class AbueloMaterno(object):
def __init__(self):
print("AbueloMaterno")
super(AbueloMaterno, self).__init__()

p. 18
class Padre(AbueloPaterno):
def __init__(self, arg):
print("Padre", "arg = ", arg)
super(Padre, self).__init__()
class Madre(AbueloMaterno):
print("Madre", "arg = ", arg)
super(Madre, self).__init__()
class Hijo(Padre, Madre):

print("Hijo", "arg = ", arg)
super(Hijo, self).__init__(arg)
objeto = Hijo("celeste")
Para corregir este problema, lo que podemos hacer es utilizar el * y ** para permitir que
las superclases permitan el pasaje de argumentos, an cuando ellas no los requieran.
00-POO/super4.py
class AbueloPaterno(object):
def __init__(self, *args, **kwargs):
print("AbueloPaterno")
super(AbueloPaterno, self).__init__(*args, **kwargs)
class AbueloMaterno(object):

p. 19
def __init__(self, *args, **kwargs):

print("AbueloMaterno")
super(AbueloMaterno, self).__init__(*args, **kwargs)
class Padre(AbueloPaterno):
def __init__(self, arg, *args, **kwargs):
print("Padre", "arg = ", arg)
super(Padre, self).__init__(arg, *args, **kwargs)
class Madre(AbueloMaterno):
print("Madre", "arg = ", arg)
super(Madre, self).__init__(*args, **kwargs)
class Hijo(Padre, Madre):

print("Hijo", "arg = ", arg)
super(Hijo, self).__init__(arg, *args, **kwargs)
objeto = Hijo("celeste")

p. 20
5. Mtodos especiales, doble guin bajo al inicio y al

finalUso de __all__
Existen mtodos especiales de python que se indican con un doble guin bajo al inicio y al
final del nombre, que cumplen tareas especficas.
5.1. __all__
Este mtodo se utiliza para declarar aquellas variables o mtodos que no deben de ser
importados con el uso de:
from privadoall import *
y solo pueden ser importados si se especifica solo el nombre de lo que queremos
importar.
from privadoall import variablePrivada1
Nota: las variable y mtodos que no queremos importar, en realidad no son privados
(como se considerara en lenguajes como JAVA, PHP, entre otros) ya que vasta indicar su
nombre explcitamente para poder acceder a ellos.
00-POO/privado__all__.py
__all__ = ['variableACompartir1', 'funcionACompartir1']
variablePrivada1 = "Hola variable privada 1"
variableACompartir1 = "Hola variable pblica 1"
def funcionACompartir1():
return 'Hola funcin Privada 1'
print(variablePrivada1)
print(variableACompartir1)
print(funcionACompartir1())

p. 21
00POO/11-recuperar__all__.py
from privadoall import *
#from privadoall import variablePrivada1
print(variableACompartir1)
print(funcionACompartir1())
# variablePrivada1 no es exportado por el mdulo ya que no esta
definido dentro de __all__
# no es accesible mediante : from privadoall import *
# pero si es accesible mediante :
print(variablePrivada1)
Al estar comentada la lnea
#from privadoall import variablePrivada1
Python nos va a decir que no existe la variablePrivada1 retornndonos un error. Sin
embargo si descomentamos la lnea, estamos explcitamente llamando a la variable, con
lo cual en este caso si podramos trabajar con dicho valor.
5.2. __ad__ y __str__

__add__ : Genera un nuevo objeto a partir de sumarle un nuevo string al valor agregado
de la instancia usada
__str__ : Cuando realizo un print de la instancia, se ejecuta el print que ponga en este
mtodo mgico
00-POO/12__str__Y__ad__.py
# ###############################
# Clase padre
# ###############################
class PrimerClase:
def imprimir(self):
print((self.data))
# ###############################

p. 22
# Clase hija
# ###############################
class SegundaClase(PrimerClase):
def imprimir(self):
print(('Valor actual = "%s"' % self.data))
# ###############################
# Clase nieta
# ###############################
class TerceraClase(SegundaClase):
def __init__(self, valor):
self.data = valor
def __add__(self, otro):
return TerceraClase(self.data + otro)
def __str__(self):
return '[Esto se imprimer al hacer un print del objeto:
%s]' % self.data
objeto1 = TerceraClase('hola')
objeto1.imprimir()
print(objeto1)
objeto2 = objeto1 + "7"
print(objeto2)
Resultado
Valor actual = "hola"
[Esto se imprimer al hacer un print del objeto: hola]
[Esto se imprimer al hacer un print del objeto: hola7]

p. 23
6. Variables y mtodos de instancia, de clase , estticos

Vamos a ver ahora algunas clasificaciones de las variables y mtodos que utilizamos
dentro de una clase.
6.1. Variables y mtodo de instancia

Las variables de instancia son aquellas que utilizamos para establecer las caractersticas
de un determinado objeto, como puede ser el color de ojos en una persona, su altura,
peso, etc. Estas variables siempre van precedidas de la palabra reservada self, la cual
debe ser especificada dentro de todo mtodo que vallamos a utilizar. Todos los mtodos
que utilicen una variable de instancia (mtodos de instancia) deben poseer la declaracin
de self como primer parmetro entre parntesis. En el siguiente ejemplo:
00-POO/13-usoDeSelf.py
class Persona(object):
def __init__( self, nombre, edad, sexo ):
self.nombre = nombre
self.edad = edad
self.sexo = sexo
print(self.nombre)
def datos(self, salario):
print("Nombre de la persona: " + self.nombre +
"\n" +
"Salario en $: " + str(salario))
objeto = Persona("Juan", 39, "masculino")
objeto.datos(100)
vemos que el constructor permite establecer tres variables de instancia (nombre, edad y
sexo) las cuales son asignadas mediante:
self.edad = edad

p. 24
self.sexo = sexo
El mtodo de instancia datos() tiene como primer componente la palabra self (la que nos
permite utilizar dentro del mismo la variable de instancia self.nombre)
y como segundo componente un atributo (salario) que debe ser pasado por la invocacin
del mtodo a partir del objeto instanciado.
objeto.datos(100)
6.2. Variables de clase

Las variables de clase no estn asociadas a una instancia en particular, sino directamente
a la clase, es correcto declararlas inmediatamente despus del establecimiento del
nombre de la clase. En el ejemplo dado a continuacin la variable empresa puede ser
invocada tanto a partir de una instancia:
print(objeto.empresa)
como directamente a partir de la clase:
print(Persona.empresa)
00-POO/14-variablesDeClase.py
empresa = "Empresa1"
def __init__( self, nombre, edad, sexo ):
self.edad = edad
self.sexo = sexo
print(self.nombre)
print("Nombre de la persona: " + self.nombre +
"\n" +
"Salario en $: " + str(salario))
objeto = Persona("Juan", 39, "masculino")
objeto.datos(100)
print(Persona.empresa)
print(objeto.empresa)

p. 25
print(objeto.edad)
6.3. Mtodos de clase decorador: @classmethod

Los mtodos de clase, es decir aquellos que no necesitan de la instancia de un objeto,
pueden ser invocados directamente escribiendo el nombre de la clase y a continuacin
con notacin de punto, el nombre del mtodo y los atributos que toma.
Los mtodos de clase utilizan en su declaracin un primer parmetro cls de forma
anloga a como declaramos en un mtodo de instancia la palabra self, y deben de ser
precedidos por el decorador @classmethod (existen otros decoradores que veremos ms
adelante). Veamos un ejemplo
00-POO/15-metodosDeClase.py
@classmethod
def imprimir(cls, parametro1):
print(parametro1)
Persona.imprimir("valor del parmetro 1")
6.4. Mtodos estticos decorador: @staticmethod

Los mtodos estticos, no necesitan poseer referencia a ningn argumento (como self o
cls) pero si deben llevar previamente el decorador @staticmethod. Dado que no poseen
en su declaracin la palabra self, no es posible acceder desde ellos a una variable de
instancia.
00-POO/16-metodosEstaticos.py
@staticmethod
def imprimir(parametro1):
print(parametro1)
objeto = Persona()

p. 26
objeto.imprimir("valor del parmetro 1")
7. Base de datos Almacenaminto mediante POO.

Hasta ahora hemos almacenado los datos mediante diccionarios, los cuales nos brindan
la posibilidad de acceder de forma relativamente simple a los datos persistidos mediante
el uso de las claves de acceso a los valores. Sin embargo el uso de diccionario posee
como limitacin el hecho de que no existe un lugar centralizado desde el cual podamos
desarrollar la lgica de acceso a los datos persistidos.
7.1. Crear paquete, mdulo y clase 01-bd-POO.

Como primer paso, creamos una clase para manejar nuestros datos y la ubicamos dentro
de un paquete segn el siguiente esquema:
datosInicioP
PersonaM.py
La clase posee un constructor __init__ y una palabra self que hace referencia al objeto
en particular con el cual estamos trabajando (es el this de otros lenguajes como JAVA,
javaScript, PHP, etc).
PersonaM.py
class Persona:
def __init__(self, nombre, edad, sueldo=0, trabajo=None):
self.edad = edad
self.sueldo = sueldo
self.trabajo = trabajo
if __name__ == '__main__':
Juan = Persona('Juan Garcia', 42, 30000, 'software')
Susana = Persona('Susana Gomez', 45, 40000, 'hardware')
print(Juan.nombre, Susana.sueldo)
print(Juan.nombre.split()[-1])
Susana.sueldo *= 1.10
print(Susana.sueldo)

p. 27
Como podemos observar la instancia del objeto la realizamos sin la necesitad de la

palabra new utilizada en otros lenguajes y pasndole los parmetros que especifica el
constructor:
De esta forma es posible acceder a modificar un atributo del objeto mediante notacin de
punto simplemente como:
Susana.sueldo *= 1.10
7.2. Accedemos desde archivo externo Introduccin de comprension.

Nuestro esquema queda modificado de la siguiente forma:
datosInicioP
__pycache__
PersonaM.py
crearDb.py
Notar en el siguiente cdigo como creamos dos objetos de la clase Persona y
almacenamos datos en forma de listas. La primera lista la creamos mediante un bucle for,
y las siguientes dos listas mediante comprension.
crearDb.py
if __name__ == '__main__':
from datosInicioP.PersonaM import Persona
Juan = Persona('Juan Garcia', 42)
Susana = Persona('Susana Gomez', 45, 40000)
personas = [Juan, Susana]

p. 28
for persona in personas:

print(persona.nombre, persona.sueldo)
print('-----------------------')
# ########################################
# Por comprension
# ########################################
x = [(persona.nombre, persona.sueldo) for persona in personas]
print(x)
print('-----------------------')
y = [(persona.edad ** 2 if persona.edad >= 7 else pesona.edad)
for persona in personas]
print(y)
print('-----------------------')

p. 29
8. Creamos mtodos de clase 02-bd-POO.

En el archivo PersonaM.py hemos creado dos instancias de la clase persona, accediendo
a una parte del nombre del objeto Juan, y modificado el sueldo del objeto Susana, desde
fuera de la clase. Podemos optimizar el cdigo, si le permitimos a la clase realizar estas
acciones, por lo que vamos a modificar el cdigo de la clase con este fin agregando los
mtodos apellido y darAumento.
Notar, que es necesario pasarle a los mtodos como argumento la palabra self para
poder trabajar con los atributos de clase.
Notar tambin que hemos agregado un parmetro porcentaje al mtodo darAumento el
cual es introducido directamente mediante la llamada a dicho mtodo.
PersonaM.py
class Persona:
self.edad = edad
def apellido(self):
return self.nombre.split()[-1]
def darAumento(self, porcentaje):
self.sueldo *= (1.0 + porcentaje)
if __name__ == '__main__':
print(Juan.apellido())
Susana.darAumento(0.10)

p. 30
9. Herencia de clase 03-bd-POO.

Python a diferencia de lenguajes como JAVA y PHP permite la incorporacin de herencias
mltiples, as clases padre son declaradas en las clases hijas entre parentesis a
continuacin del nombre de clase. Para ver como funciona el uso de herencia,
introduzcamos una nueva clase (Gerente), la cual introduce una modificacin en el
mtodo darAumento agregandole un premio extra al porcentaje de aumento estipulado
desde el objeto instancia). Nuestro esquema ahora queda como sigue:
datosInicioP
__pycache__
PersonaM.py
GerenteM.py
crearDb.py
GerenteM.py
from PersonaM import Persona
class Gerente(Persona):
def darAumento(self, porcentaje, premio=0.1):
self.sueldo *= (1.0 + porcentaje + premio)
if __name__ == '__main__':
Tom = Gerente('Tom Perez', 42, 50000, 'software')
print(Tom.nombre)
Tom.darAumento(0.10)
print(Tom.sueldo)
Notar como aqu se hace una asignacin por defecto del valor correspondiente a premio
por lo que es posible escribir la asignacin de monto de la siguientes formas dependiendo

p. 31
si dejamos el monto del premio con el valor por defecto, o si lo modificamos desde fuera
respectivamente:
Tom.darAumento(0.10, 0.40)

p. 32
10. Analizar desde donde llamo a un mdulo 04-bdPOO.

OJO: No puedo hacer referencia desde crearDb.py a Gerente con el cdigo escrito de
esta forma ya que no encontrara la referencia a la clase Persona desde la clase Gerente
simplemente porque al llamar la clase gerente desde fuera del paquete, se esperara que
en Gerente la importacin de la clase persona fuera:
from datosInicioP.PersonaM import Persona
Y no:
from PersonaM import Persona

p. 33
11. Separacin del cdigo en mdulos 05-bd-POO.

Una forma ms conveniente de trabajar, es separar el cdigo de cada clase y ubicar cada
una en un mdulo diferente segn el siguiente esquema:
PersonaP
__pycache__
PersonaM.py
GerenteP
__pycache__
GerenteM.py
crearDb.py
En este punto nuestros cdigos quedaran como sigue:
PersonaM.py
class Persona:
self.edad = edad
def apellido(self):
return self.nombre.split()[-1]
def darAumento(self, porcentaje):
self.sueldo *= (1.0 + porcentaje)
if __name__ == '__main__':

p. 34
Susana.darAumento(0.10)
GerenteM.py
from PersonaP.PersonaM import Persona
self.sueldo *= (1.0 + porcentaje + premio)
crearDb.py
if __name__ == '__main__':
from GerenteP.GerenteM import Gerente
Tom = Gerente('Tom Perez', 42, 50000, 'software')
db = [Juan, Susana, Tom]
for persona in db:
print(persona.nombre, persona.sueldo)
print('-----------------------')
for objeto in db:
objeto.darAumento(0.10)
for objeto in db:
print(objeto.nombre, '=>', objeto.sueldo)
print('-----------------------')
for objeto in db:
print(objeto.apellido(), '=>', objeto.sueldo)
print('-----------------------')

p. 35
12. Uso de __str__ e instancia a travs de constructor

del clase padre 06-bd-POO.
En esta seccin se han realizado dos modificaciones, la primera es la incorporacin del
mtodo __str__ en la clase Persona. Este al igual que todos los que comienzan y
terminan con dos guiones bajos, es reservado de Python y lo que nos permite es retornar
los valores de los atributos de un objeto en formato de string, cada vez que realizamos un
print del objeto.
La otra modificacin introducida, es que se ha agregado a la clase Gerente un constructor,
y dentro de este es llama al constructor de la clase padre, con lo cual el constructor de
Gerente unicamente solicita aquellos datos que son propios de los objetos de la clase, y
se pasan como parmetros al constructor de la padre (Persona) los valores propios de la
clase hija (Gerente) y el valor de puesto de trabajo es declarado como por defecto en
Gerente en el constructor de la clase Gerente.
PersonaM.py
class Persona:
..............
def __str__(self):
return ('<%s => %s: %s, %s>' %
(self.__class__.__name__, self.nombre, self.trabajo,
self.sueldo))
GerenteM.py
def __init__(self, nombre, edad, sueldo):
Persona.__init__(self, nombre, edad, sueldo, 'Gerente')
Persona.darAumento(self, porcentaje + premio)

p. 36
crearDb.py
if __name__ == '__main__':
# #########################################
# Para llamada a __str__
# #########################################
print('--------__str__-----------')
print(Juan)
print(Susana)
print('-----------------------')

p. 37
13. Persistencia de datos 07-bd-POO

Ahora es hora de persistir los datos, para lo que crearemos archivos en forma similar a lo
realizado en las unidades anateriores.
13.1. Crear archivo de bytes de base de datos.

A continuacin vamos utilizar el mdulo :
guardarDatos.py
import shelve
Tom = Gerente('Tom Perez', 42, 50000)
db = shelve.open('persona')
db['Juan'] = Juan
db['Susana'] = Susana
db['Tom'] = Tom
db.close()
FINDB = '
13.2. Leer desde persona - leerDesdePersona.py

leerDesdePersona.py
import shelve
for key in db:
print(key, '=>\n ', db[key].nombre, db[key].sueldo)
Juan = db['Juan']

p. 38
print(db['Susana'].apellido())
db.close()
13.3. Actualizar datos - actualizarDatos.py

actualizarDatos.py
import shelve
Tom = Gerente('Tom Perez', 42, 50000)
Tom = db['Tom']
db['Tom'] = Tom
db.close()

p. 39
Bibliografa
Libros
Programming Python 5th Edition Mark Lutz O'Reilly 2013
Programming Python 4th Edition Mark Lutz O'Reilly 2011
Head First Python Paul Barry O'Reilly 2011
Manual online
https://docs.python.org/3.4/library/intro.html


Unidad 4 BaseDeDatos POO PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Unidad 4 BaseDeDatos POO PDF

Cargado por

Copyright:

Formatos disponibles

UNIDAD IV

MBA. Ing. Juan M. Barreto

4. Mtodos especiales, doble guin bajo al inicio y al

MBA. Ing. Juan M. Barreto

5. Variables y mtodos de instancia, de clase , estticos

6. Base de datos Almacenaminto mediante POO.......25

7. Creamos mtodos de clase 02-bd-POO..................28

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

12.3. Actualizar datos - actualizarDatos.py...............................................37

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Supongamos ahora que generamos una instancia de la Clase3 e implementamos un

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Como era de esperar la salida nos retorna:

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

La salida nos retorna:

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

4.1. Problema en el uso de super con __init__

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

4.2. Problema en el uso de super con argumentos

El cdigo del esquema anterior queda como sigue:

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

class Hijo(Padre, Madre):

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

def __init__(self, *args, **kwargs):

class Hijo(Padre, Madre):

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

5. Mtodos especiales, doble guin bajo al inicio y al

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

5.2. __ad__ y __str__

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

6. Variables y mtodos de instancia, de clase , estticos

6.1. Variables y mtodo de instancia

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

6.2. Variables de clase

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

6.3. Mtodos de clase decorador: @classmethod

6.4. Mtodos estticos decorador: @staticmethod

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

objeto.imprimir("valor del parmetro 1")

7. Base de datos Almacenaminto mediante POO.

7.1. Crear paquete, mdulo y clase 01-bd-POO.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Como podemos observar la instancia del objeto la realizamos sin la necesitad de la

7.2. Accedemos desde archivo externo Introduccin de comprension.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

for persona in personas:

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

8. Creamos mtodos de clase 02-bd-POO.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

9. Herencia de clase 03-bd-POO.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

10. Analizar desde donde llamo a un mdulo 04-bdPOO.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

4.1. Problema en el uso de super con init

def init(self, *args, **kwargs):

5.2. ad y str

12. Uso de str e instancia a travs de constructor