Resolucin del Laboratorio 03

Nombre: P_TKL
1.
>>> class Alumno:
def __ini__(self, nombre, codigo):
self.__nombre = nombre
self.codigo = codigo
def cambiarNombre(self,x):
self.__nombre = x
def getNombre(self):
print self.__nombre

2.
>>> class ClaseOtroEjemplo:
def __init__(self):
self.publico = 'propiedad publica'
self.__privado = 'propiedad privada'
def obtener_privado(self):
print self.__privado

def metodoPublico(self):
print "soy publico"
def __metodoPrivado(self):
print "soy privado"
def ejecutar_metodoPrivado(self):
self.__metodoPrivado()

>>> clase = ClaseOtroEjemplo()

>>> ##Como ejecutamos un metodo publico? hacemos un llamamiento

simple
>>> clase.metodoPublico()
soy publico
>>> ##Se puede ejecutar un metodo privado directamente? no
>>> clase.__metodoPrivado()

Traceback (most recent call last):

File "<pyshell#28>", line 1, in <module>
clase.__metodoPrivado()
AttributeError: ClaseOtroEjemplo instance has no attribute '__metodoPrivado'
>>> clase.ejecutar_metodoPrivado()
soy privado
>>> ##Como hariamos para cambiar una propiedad privada? con un set o
una funcion dentro de la clase
>>> class ClaseOtroEjemplo:
def __init__(self):
self.publico = 'propiedad publica'
self.__privado = 'propiedad privada'
def obtener_privado(self):
print self.__privado

def metodoPublico(self):
print "soy publico"
def __metodoPrivado(self):
print "soy privado"
def ejecutar_metodoPrivado(self):
self.__metodoPrivado()
def set_privado(self, nuevo_valor):
self.__privado = nuevo_valor

>>> clase = ClaseOtroEjemplo()

>>> clase.set_privado('nuevo privado')
>>> clase.obtener_privado()
nuevo privado

3.
Python 2.7.8 (default, Jun 30 2014, 16:03:49) [MSC v.1500 32 bit (Intel)] on
win32
Type "copyright", "credits" or "license()" for more information.
class Persona():
def __init__(self, DNI):
self.__nombre='nn'
self.__edad=0
self.__DNI=DNI
self.__sexo='H'
self.__peso=0
self.__altura=0
def __init__(self):
self.__nombre='nn'
self.__edad=0
self.__DNI=''
self.__sexo='H'
self.__peso=0
self.__altura=0
__generarDNI()
def __init__(self, nombre, edad, sexo):
__comprobarSexo(sexo)
self.__nombre=nombre

self.__edad=edad
self.__DNI=''
self.__sexo=sexo
self.__peso=0
self.__altura=0
__generarDNI()
def __init__(self, nombre, edad, sexo, peso, altura):
__comprobarSexo(sexo)
self.__nombre=nombre
self.__edad=edad
self.__DNI=''
self.__sexo=sexo
self.__peso=peso
self.__altura=altura
__generarDNI()
def calcularMC(self):
if(self.__sexo=='H'):
K=4
else:
K=2
PI=self.__altura-100-((self.__altura-150)/K)
if(PI==self.__peso):
print 'Peso Ideal'
return 0
else:
if(PI<self.__peso):
print 'Sobre Peso'
return -1
else:
print 'Infra Peso'

return 1
def esMayorDeEdad(self):
if (self.__edad>17):
return True
else:
return False
def __comprobarSexo(self, sexo):
if(sexo != 'M' and sexo!='H'):
sexo='H'
def toString(self):
print self.__nombre
print self.__edad
print self.__DNI
print self.__sexo
print self.__peso
print self.__altura
def __generarDNI(self):
import random
lst=['a','b','c','d','e','f','g','h','i','j']
ln = ''
for i in range(8):
x = random.randint(0, 9)
ln = ln + lst[x]
self.__DNI = self.__DNI + x
print ln
def setNombre(self, nombre):
self.__nombre = nombre
def setEdad(self, edad):
self.__edad = edad
def setSexo(self, sexo):

self.__sexo = sexo
def setPeso(self, peso):
self.__peso = peso
def setAltura(self, altura):
self.__altura = altura
class Ejecutable():
def __init__(self):
self.nombre = ''
self.edad = 0
self.sexo = ''
self.peso = 0
self.altura = 0
def exe(self):
print 'Ingrese un nombre'
self.nombre = input()
print 'Ingrese un edad'
self.edad = input()
print 'Ingrese el sexo'
self.sexo = input()
print 'Ingrese el peso'
self.peso = input()
print 'Ingrese el altura'
self.altura = input()
self.obj1 = Persona(self.nombre, self.edad, self.sexo, self.peso,
self.altura)
self.obj2 = Persona(self.nombre, self.edad, self.sexo)
self.obj3 = Persona()
self.obj1.setNombre(self.nombre)
self.obj1.setEdad(self.edad)
self.obj1.setSexo(self.sexo)

self.obj1.setPeso(self.peso)
self.obj1.setAltura(self.altura)
self.obj1.calcularMC()
self.obj2.calcularMC()
self.obj3.calcularMC()
self.obj1.esMayorDeEdad()
self.obj2.esMayorDeEdad()
self.obj3.esMayorDeEdad()
self.obj1.toString()
self.obj2.toString()
self.obj3.toString()

4.
>>> class Password():
def __init__(self):
self.longitud=8
self.contrasena=''
def __init__(self, longitud):
self.longitud=longitud
self.contrasena=''
import random

dd={1:'0',2:'1',3:'2',4:'3',5:'4',6:'5',7:'6',8:'7',9:'8',10:'9',11:'a',12:'f',13:'j',14:'w',
15:'u',16:'C',17:'G',18:'H',19:'F',20:'Q'}
for i in range(self.longitud):
self.contrasena=self.contrasena+dd[random.randint(1,20)]
def esFuerte(self):
mayus=0
minus=0

num=0
for i in range(self.longitud):
if(ord(self.contrasena[i])>=65 and
ord(self.contrasena[i])<=90):
mayus = mayus + 1
if(ord(self.contrasena[i])>=97 and
ord(self.contrasena[i])<=122):
minus = minus + 1
if(ord(self.contrasena[i])>=48 and
ord(self.contrasena[i])<=57):
minus = minus + 1
if(mayus>2 and minus>1 and num>5):
return True
else:
return False
def generarPassword(self):
import random

dd={1:'0',2:'1',3:'2',4:'3',5:'4',6:'5',7:'6',8:'7',9:'8',10:'9',11:'a',12:'f',13:'j',14:'w',
15:'u',16:'C',17:'G',18:'H',19:'F',20:'Q'}
for i in range(self.longitud):
self.contrasena=self.contrasena+dd[random.randint(1,20)]
def getContrasena(self):
return self.contrasena
def getLongitud(self):
return self.longitud
def setLongitud(self, longitud):
self.longitud=longitud

>>> p=[]

>>> longPass = input()

10
>>> nPass = input()
5
>>> for i in range(nPass):
p.append(Password(longPass))

>>> for i in range(nPass):

p[i].getContrasena()

'5G786u1863'
'46j7Q3H2f7'
'4uH879w491'
'F2ww423240'
'CFHjw2u8Hu'
>>> esF=[]
>>> for i in range(nPass):
esF.append(p[i].esFuerte())

>>> esF
[False, False, False, False, False]
>>> for i in range(nPass):
if(esF[i]==True):
print p[i].getContrasena()

5. Haz una clase llamada Persona que siga las siguientes condiciones:

Sus atributos son: nombre, edad, DNI, sexo (H hombre, M mujer), peso y
altura. No queremos que se accedan directamente a ellos. Piensa que
modificador de acceso es el ms adecuado, tambin su tipo. Si quieres
aadir algn atributo puedes hacerlo.
Por defecto, todos los atributos menos el DNI sern valores por defecto
segn su tipo (0 nmeros, cadena vaca para String, etc.). Sexo ser
hombre por defecto, usa una constante para ello.
Se implantaran varios constructores: o Un constructor por defecto. o Un
constructor con el nombre, edad y sexo, el resto por defecto. o Un
constructor con todos los atributos como parmetro.
Los mtodos que se implementaran son:
o calcularIMC(): calcular si la persona est en su peso ideal (peso
en kg/(altura^2 en m)), devuelve un -1 si est por debajo de su
peso ideal, un 0 si est en su peso ideal y un 1 si tiene
sobrepeso .Te recomiendo que uses constantes para devolver
estos valores.
o esMayorDeEdad(): indica si es mayor de edad, devuelve un
booleano.
o comprobarSexo(char sexo): comprueba que el sexo introducido es
correcto. Si no es correcto, ser H. No ser visible al exterior.
o toString(): devuelve toda la informacin del objeto.
o generaDNI(): genera un numero aleatorio de 8 cifras, genera a
partir de este su nmero su letra correspondiente. Este mtodo
ser invocado cuando se construya el objeto. Puedes dividir el
mtodo para que te sea ms fcil. No ser visible al exterior. o
Mtodos set de cada parmetro, excepto de DNI.

5.1.Ahora, crea una clase ejecutable que haga lo siguiente:

Pide por teclado el nombre, la edad, sexo, peso y altura.

Crea 3 objetos de la clase anterior, el primer objeto obtendr las
anteriores variables pedidas por teclado, el segundo objeto obtendr
todos los anteriores menos el peso y la altura y el ltimo por defecto,
para este ltimo utiliza los mtodos set para darle a los atributos un
valor.
Para cada objeto, deber comprobar si est en su peso ideal, tiene
sobrepeso o por debajo de su peso ideal con un mensaje.
Indicar para cada objeto si es mayor de edad.
Por ltimo, mostrar la informacin de cada objeto
o

>>> class Electrodomestico:

precioConsumo={'A':100,'B':80,'C':60,'D':50,'E':30,'F':10}
def __init__(self):
self.precioBase=100
self.color='Blanco'
self.consumoEnergetico='F'
self.peso=5
#Colores disponibles (blanco, negro, rojo, azul, gris)#
#constructores
def __init__(self, precio, peso):
self.precioBase=precio
self.color='Blanco'
self.consumoEnergetico='F'
self.peso=peso
def __init__(self, precio, color, consumo, peso):
self.precioBase=precio
self.color=color
self.__comprobarConsumoEnergetico(consumo)
self.consumoEnergetico=consumo
self.peso=peso
#metodos
def getPrecio(self):
return self.precioBase
def getColor(self):
return self.color
def getConsumo(self):
return self.consumoEnergetico
def getPeso(self):
return self.peso
def __comprobarConsumoEnergetico(self, letra):
if letra < 'A' or letra > 'F':

self.consumoEnergetico='F'
else:
self.consumoEnergetico=letra
def __comprobarColor(self, color):
if color != 'blanco' or color != 'negro' or color != 'rojo' or color !=
'azul' or color != 'gris':
self.color = 'blanco'
else:
self.color = color
def precioFinal(self):
precioBase =
precioBase+precioConsumo[self.consumoEnergetico]

6. Haz una clase llamada Password que siga las siguientes condiciones:

Que tenga los atributos longitud y contrasea. Por defecto, la longitud

ser de 8,
Los constructores sern los siguientes:
o Un constructor por defecto
o Un constructor con la longitud que nosotros le pasemos. Generar
una contrasea aleatoria con esa longitud
Los mtodos que implementara sern:
o EsFuerte(): devuelve un booleano si es fuerte o no. Para que sea
fuerte debe tener ms de 2 maysculas, ms de 1 minscula y
ms de 5 numeros
o generarPassword(): genera la contrasea del objeto con la
longitud que tenga
o Getters para contrasea y longitud
o Setters para longitud

class Password:
import random
def __init__(self):
long=0
cont[0]=0
def __init__(self, h):
long=h
for x in range(h):
cont[x]=chr(32,127)

#se generara un valor char mediante su equivalente ASCII

imprimible
def EsFuerte(self):
may=0
minus=0
num=0
for x in range(long):
if (90>=ord(cont[x])>=65):
may=may+1
if (122>=ord(cont[x])>=97):
minus=minus+1
if (57>=ord(cont[x])>=48):
num=num+1
if (may>5 and minus>1 and num>5):
return True
else:
return False
def generarPassword(self):
for x in range(long):
cont[x]=chr(32,127)
def getContrasea(self):
return cont
def getLongitud(self):
return long
def setLongitud(self,x):
long=x

6.1 Ahora, crea una clase ejecutable:

o
o
o
o
o
o
o

Crea un array de Passwords con el tamao que t le indiques por teclado

Crea un bucle que cree un objeto para cada posicin del array
Indica tambin por teclado la longitud de los Passwords (antes del bucle)
Crea otro array de booleanos donde se almacene si el password del array
de Password es o no fuerte (usa el bucle anterior)
Al final, muestra la contrasea y si es o no fuerte (usa el bucle anterior)
Usa este simple formato:
Contrasea 1 valor_booleano1
Contrasea2 valor_booleano2

class Ejecutable:
def ejecutar(self):
YUS=input("Ingrese numero de contraseas a generar: ")
LON=input("Ingrese longitud de contraseas: ")
for x in range(YUS):
Contra[x]=Password(LON)
for x in range(YUS):
Fuerza[x]=Contra[x].EsFuerte()
for x in range(YUS):
print ("Contrasea"+x+1)

Contra[x].getContrasea()
print ("valor_booleano"+x+1)
print (Fuerza[x])
7. Crear una superclase llamada Electrodomestico con las siguientes
caractersticas:

Sus atributos son precio base, color, consumo energtico (letras entre A
y F) y peso. Indica que se podrn heredar
Por defecto, el color ser blanco, el consumo energtico ser F, el
precioBase es de 100 y el peso de 5 kg. Usa constantes para ello.
Los colores disponibles son blanco, negro, rojo, azul y gris. No importa si
el nombre esta en maysculas o en minsculas.
Los constructores que se implementen sern
o Un constructor por defecto
o Un constructor con precio y peso, resto por defecto
o Un constructor con todos los atributos
Los mtodos que implementara sern
o Metodos get de todos los atributos
o comprobarConsumoEnergetico(char letra): comprueba que la letra
es correcta, sino es correcta usara la letra por defecto. Se
invocara al crear el objeto y no ser visible
o comprobarColor(String color): segn precio y tamao, aunmentara
su precio

class Electrodomestico:
precioBase=100
CEne='F'
Color="blanco"
W=5
def __init__(self):
return 0
def __init__(self,X,w):
precioBase=X
W=w
def __init__(self,X,w,col,enne):
precioBase=X
W=w
Color=col
CEne=enne
comprobarColor(col)
comprobarConsumoEnergetico(letra)
def comprobarColor(color):
if (color!="blanco" or color!="negro" or color!="rojo" or color!
="azul" or color!="gris"):
Color="blanco"
def comprobarConsumoEnergetico(letra):
if (letra!='A' or letra!='B' or letra!='C' or letra!='D' or letra!='E' or
letra!='F'):

CEne=F
def precioFinal():
if (CEne=='A'):
precioBase=precioBase+100
if (CEne=='B'):
precioBase=precioBase+80
if (CEne=='C'):
precioBase=precioBase+60
if (CEne=='D'):
precioBase=precioBase+50
if (CEne=='E'):
precioBase=precioBase+30
if (CEne=='F'):
precioBase=precioBase+10
if (19>=W>0):
precioBase=precioBase+10
if (49>=W>=20):
precioBase=precioBase+50
if (79>=W>=50):
precioBase=precioBase+80
if (W>=80):
precioBase=precioBase+100