Unidad 4 BaseDeDatos POO

7/25/2019 Unidad 4 BaseDeDatos POO

1/39

UNIDADIV

POO

MBA. Ing. Juan M. BarretoUTN - FRBA. Secretara de Cultura y Extensin Universitaria

Medrano 951 2do piso (1179) // Tel. +54 11 xxxx xxxxxEmail: [email protected]


2/39

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................................................................123.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. BarretoUTN - FRBA. Secretara de Cultura y Extensin Universitaria

Medrano 951 2do piso (1179) // Tel. +54 11 xxxx xxxxxEmail: [email protected]


3/39

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-bd-

POO...................................................................................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.UTN - FRBA. Secretara de Cultura y Extensin Universitaria

Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // [email protected]

www.sceu.frba.utn.edu.ar/e-learning


4/39

p. 4

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

Bibliografa.......................................................................38

Presentacin:

xxxxxxxxxxxxxxxxxxxxxxxxxxxx





5/39

p. 5

Objetivos:

Que los participantes:

xxxxxxxxxxxxxxxxxxxxxxxxxxx





6/39

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





7/39

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"





8/39

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']





9/39

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 formaimplcita 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.pyclass Comentario:

def imprimir( self ):

print(self.texto)

objeto = Comentario()

objeto.texto = "Hola variable de instancia"

objeto.imprimir()

input()





10/39

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:





11/39

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 quecontiene 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__)





12/39

p. 12

Como era de esperar la salida nos retorna:

(, , , , )





13/39

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()





14/39

p. 14

La salida nos retorna:

---------- Prioridad Clases ------------

(, , , )

(, , , )

---------- 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.





15/39

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

class Vehiculo(object):

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:





16/39

p. 16

00-POO/super2_init.py

class Vehiculo(object): 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 ruedasplstico





17/39

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__()





18/39

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):





19/39

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")





20/39

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())





21/39

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))

# ###############################





22/39

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]





23/39

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 cualdebe 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.nombre = nombre

self.edad = edad





24/39

p. 24

self.sexo = sexo

El mtodo de instancia datos() tiene como primer componente la palabra self (la que nospermite 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.nombre = nombre

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)





25/39

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()





26/39

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)





27/39

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]





28/39

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('-----------------------')





29/39

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

self.sueldo= sueldo

self.trabajo= trabajo

def apellido(self):

return self.nombre.split()[-1]

def darAumento(self, porcentaje):

self.sueldo *= (1.0 + porcentaje)

if __name__ == '__main__':

Juan = Persona('Juan Garcia', 42, 30000, 'software') Susana = Persona('Susana Gomez', 45, 40000, 'hardware')


print(Juan.apellido())

Susana.darAumento(0.10)






30/39

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





31/39

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)





32/39

p. 32

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

POO.

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





33/39

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

self.sueldo = sueldo

self.trabajo = trabajo

def apellido(self):

return self.nombre.split()[-1]

def darAumento(self, porcentaje):

self.sueldo *= (1.0 + porcentaje)

if __name__ == '__main__':


Susana = Persona('Susana Gomez', 45, 40000, 'hardware')







34/39

p. 34

Susana.darAumento(0.10)


GerenteM.py

from PersonaP.PersonaM import Persona


def darAumento(self, porcentaje, premio=0.1): self.sueldo *= (1.0 + porcentaje + premio)

crearDb.py

if __name__ == '__main__':


from GerenteP.GerenteM import Gerente


Susana = Persona('Susana Gomez', 45, 40000) 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('-----------------------')





35/39

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 deGerente 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>' %

(self.__class__.__name__, self.nombre, self.trabajo,

self.sueldo))

GerenteM.py



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

Persona.__init__(self, nombre, edad, sueldo, 'Gerente')

def darAumento(self, porcentaje, premio=0.1):

Persona.darAumento(self, porcentaje + premio)





36/39

p. 36

crearDb.py

if __name__ == '__main__':

# #########################################

# Para llamada a __str__

# #########################################

print('--------__str__-----------')

print(Juan)

print(Susana)

print('-----------------------')





37/39

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.pyA continuacin vamos utilizar el mdulo :

leerDesdePersona.py

import shelve


for key in db:

print(key, '=>\n ', db[key].nombre, db[key].sueldo)

Juan = db['Juan']






38/39

p. 38

print(db['Susana'].apellido())

db.close()

13.3. Actualizar datos - actualizarDatos.pyA continuacin vamos utilizar el mdulo :

actualizarDatos.py

import shelve





Tom = Gerente('Tom Perez', 42, 50000)


Tom = db['Tom']


db['Tom'] = Tom

db.close()





39/39

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

Documents

Transcript of Unidad 4 BaseDeDatos POO