Laboratorio Clases en Python

Resolución del Laboratorio 03Nombre: 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.obj1.esMayorDeEdad()



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


if(ord(self.contrasena[i])>=65 and ord(self.contrasena[i])<=90):

mayus = mayus + 1


minus = minus + 1


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


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


p[i].getContrasena()

'5G786u1863'

'46j7Q3H2f7'

'4uH879w491'

'F2ww423240'

'CFHjw2u8Hu'

>>> esF=[]


esF.append(p[i].esFuerte())

>>> esF

[False, False, False, False, False]


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 más adecuado, también su tipo. Si quieres añadir algún atributo puedes hacerlo.

Por defecto, todos los atributos menos el DNI serán valores por defecto según su tipo (0 números, cadena vacía 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 parámetro.

Los métodos 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 información del objeto. o generaDNI(): genera un numero aleatorio de 8 cifras, genera a partir de este su

número su letra correspondiente. Este método será invocado cuando se construya el objeto. Puedes dividir el método para que te sea más fácil. No será visible al exterior. o Métodos set de cada parámetro, 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 métodos 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 información 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.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':


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 contraseña. Por defecto, la longitud será de 8, Los constructores serán los siguientes:

o Un constructor por defectoo Un constructor con la longitud que nosotros le pasemos. Generará una contraseña

aleatoria con esa longitud Los métodos que implementara serán:

o EsFuerte(): devuelve un booleano si es fuerte o no. Para que sea fuerte debe tener más de 2 mayúsculas, más de 1 minúscula y más de 5 numeros

o generarPassword(): genera la contraseña del objeto con la longitud que tengao Getters para contraseña y longitudo Setters para longitud

class Password:import randomdef __init__(self):

long=0cont[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=0minus=0num=0for 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 getContraseña(self):

return contdef getLongitud(self):

return longdef setLongitud(self,x):

long=x

6.1 Ahora, crea una clase ejecutable:

o Crea un array de Passwords con el tamaño que tú le indiques por tecladoo Crea un bucle que cree un objeto para cada posición del arrayo Indica también por teclado la longitud de los Passwords (antes del bucle)o Crea otro array de booleanos donde se almacene si el password del array de Password es

o no fuerte (usa el bucle anterior)o Al final, muestra la contraseña y si es o no fuerte (usa el bucle anterior) Usa este simple

formato:o Contraseña 1 valor_booleano1o Contraseña2 valor_booleano2

class Ejecutable:def ejecutar(self):

YUS=input("Ingrese numero de contraseñas a generar: ")LON=input("Ingrese longitud de contraseñas: ")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 ("Contraseña"+x+1)Contra[x].getContraseña()print ("valor_booleano"+x+1)print (Fuerza[x])

7. Crear una superclase llamada Electrodomestico con las siguientes características:

Sus atributos son precio base, color, consumo energético (letras entre A y F) y peso. Indica que se podrán heredar

Por defecto, el color será blanco, el consumo energético 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 mayúsculas o en minúsculas.

Los constructores que se implementen seráno Un constructor por defectoo Un constructor con precio y peso, resto por defectoo Un constructor con todos los atributos

Los métodos que implementara seráno Metodos get de todos los atributoso 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): según precio y tamaño, aunmentara su precio

class Electrodomestico:precioBase=100CEne='F'Color="blanco"W=5def __init__(self):

return 0def __init__(self,X,w):

precioBase=XW=w

def __init__(self,X,w,col,enne):precioBase=XW=wColor=colCEne=ennecomprobarColor(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

Laboratorio Clases en Python

Documents

Transcript of Laboratorio Clases en Python