Buenas, la idea de esta entrada es comenzar a practicar con algunos ejercicios la programación orientada a objetos en python.
La programación orientada a objetos (POO) es un enfoque formal de programación que combina los datos y las acciones asociadas (métodos) en estructuras lógicas (objetos). Este enfoque mejora la capacidad de gestionar software complejos como también así el desarrollo y mantenimiento de aplicaciones de gran tamaño.
Puedes ver la entrada sobre Programación Orientada a Objetos en python que escribí ya hace algún tiempo. También puedes dar una vuelta por todo el repertorio de ejercicios que hemos ido publicando en el blog aquí: Ejercicios Python
Espero estos ejercicios te sean de ayuda.
Ejercicio 1
Escribir una clase en python que convierta un número entero a número romano
Ejercicio 2
Escribir una clase en python que convierta un número romano en un número entero
Ejercicio 3
Escribir una clase en python para encontrar la validez de una cadena de paréntesis, '(', ')', '{', '}', '[' ']. Los paréntesis deben aparecer en el orden correcto, por ejemplo "()" y "()[]{}" son validos, pero "[)", "({[)]" y "{{{" son inválidos.
Ejercicio 4
Escribir una clase en python que obtenga todos los posibles subconjuntos únicos de un conjunto de números enteros distintos.
Entrada: [4, 5, 6]
Salida: [[], [6], [5], [5, 6], [4], [4, 6], [4, 5], [4, 5, 6]]
Ejercicio 5
Escribir una clase en python que encuentre un par de elementos (índice de los números) de una matriz dada cuya suma es igual a un número de destino especifico.
Entrada: numeros = [10,20,10,40,50,60,70], objetivo=50
Salida: 3, 4
Ejercicio 6
Escribir una clase en python que encuentre los 3 elementos que sumen 0 a partir de números reales
Entrada: [-25, -10, -7, -3, 2, 4, 8, 10]
Salida: [[-10, 2, 8], [-7, -3, 10]]
Ejercicio 7
Escribir una clase en python que calcule pow(x, n)
x = es la base
n = es el exponente
Entrada: pow(2, -3)
Salida: 0.125
Entrada: pow(3, 5)
Salida: 234
Ejercicio 8
Escribir una clase en python que revierta una cadena de palabras
Entrada: "Mi Diario Python"
Salida: "Python Diario Mi"
Ejercicio 9
Escribir una clase en python con 2 métodos: get_string y print_string. get_string acepta una cadena ingresada por el usuario y print_string imprime la cadena en mayúsculas.
Ejercicio 10
Escribir una clase en python llamada rectangulo que contenga una base y una altura, y que contenga un método que devuelva el área del rectángulo.
Ejercicio 11
Escribir una clase en python llamada circulo que contenga un radio, con un método que devuelva el área y otro que devuelva el perímetro del circulo.
Las soluciones a los ejercicios pueden publicarlas en los comentarios.
Hasta acá los ejercicios, a meter código muchachos, nos vemos en las soluciones ;)
Saludos, Diego...
lunes, 16 de noviembre de 2015
Ejercicios de clases y objetos en python (parte 1)
Suscribirse a:
Enviar comentarios
(
Atom
)
Un intento de los numeros romanos :
ResponderEliminarcategorias = [['I','V','X'],['X','L','C'],['C','D','M']]
popurri = {0:'',1:'0',2:'00',3:'000',4:'01',5:'1',6:'10',7:'100',8:'1000',9:'02'}
class Romano(object):
def __init__(self, numero):
self.number = str(numero)
self.largo = len(self.number)
def romanizar (self):
respuestafinal = ''
for x in range(0,self.largo):
respuestafinal = respuestafinal + self.romanizardig(self.number[x],self.largo-x-1)
return respuestafinal
def romanizardig(self,digito,categoria):
logica = categorias[categoria]
respuesta = ''
dig_a_procesar = [x for x in popurri[int(digito)]]
for x in dig_a_procesar:
respuesta = respuesta + logica[int(x)]
return respuesta
Prueba = Romano(950)
print Prueba.romanizar()
Ejercicio 2
ResponderEliminarpopurri = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
class Normalizador(object):
def __init__(self, numero):
self.number = numero
self.largo = len(numero)
def normalizar(self):
sumatotal = 0
for x in range(0,self.largo):
valor = popurri[self.number[x]]
if x != self.largo-1:
if valor < popurri[self.number[x+1]]:
valor = -valor
sumatotal += valor
return sumatotal
Prueba = Normalizador('DCXCII')
print Prueba.normalizar()
Excelente Lucas. Gracias por visitar y participar en el blog. saludos
EliminarEste comentario ha sido eliminado por el autor.
ResponderEliminarMi código: ideone.com
ResponderEliminarExcelente Victor. Gracias por visitar y participar en el blog. saludos
EliminarEste comentario ha sido eliminado por el autor.
ResponderEliminar# -*- coding: utf-8 -*-
ResponderEliminarclass Dec_Rom:
....def __init__(self,n):
........self.n=n
........self.numero=[]
........if int(self.n)<=100000:
............self.numero += n
........else:
............print 'El numero debe ser menor o igual a 100000'
....def check(self):
.........self.nums={1:'I',5:'V',10:'X',50:'L',100:'C',500:'D',1000:'M',4000:'ÏǗ',5000:'Ǘ',6000:'ÜÏ',7000:'ÜÏÏ',8000:'ÜÏÏÏ',9000:'ÏẌ',10000:'Ẍ',20000:'ẌẌ',30000:'ẌẌẌ',40000:'ẌĹ',50000:'Ĺ',60000:'ĹẌ',70000:'ĹẌẌ',80000:'ĹẌẌẌ',90000:'ẌĆ',100000:'Ć'}
........roma,resul,indice,pase='',0,0,False
........if len(self.numero)==6:
............roma += self.nums[100000]
............return roma
........elif len(self.numero)==5:
............conv=int(self.numero[indice])*10000
............resul=self.nums[conv]
............roma += resul
............indice += 1
............pase=True
........else:
............pass
........if len(self.numero)==4 or pase:
............base,medinf,med,sup,sups=100,400,500,900,1000
............if int(self.numero[indice])<4:
................conv=int(self.numero[indice])*self.nums[1000]
................roma += conv
................indice += 1
............else:
................conv=int(self.numero[indice])*1000
................resul=self.nums[conv]
................roma += resul
................indice += 1
........elif len(self.numero)==3:
............base,medinf,med,sup,sups=100,400,500,900,1000
........elif len(self.numero)==2:
............base,medinf,med,sup,sups=10,40,50,90,100
........elif len(self.numero)==1:
............base,medinf,med,sup,sups=1,4,5,9,10
........while indice<len(self.numero):
............conv=int(self.numero[indice])*base
............if conv<medinf:
................conv=int(self.numero[indice])*self.nums[base]
................roma += conv
............elif conv==med:
................resul=self.nums[conv]
................roma += resul
............elif conv==sup:
................roma += self.nums[base]
................roma += self.nums[sups]
............else:
................resul=conv-med
................if resul<0:
....................resul *= -1
....................roma += self.nums[resul]
....................roma += self.nums[med]
................else:
....................resul /= base
....................roma += self.nums[med]
....................conv=resul*self.nums[base]
....................roma += conv
............if len(self.numero)==5 and indice ==2 or len(self.numero)==4 and indice ==1 or len(self.numero)==3 and indice == 0:
................base,medinf,med,sup,sups=10,40,50,90,100
............elif len(self.numero)==5 and indice ==3 or len(self.numero)==4 and indice ==2 or len(self.numero)==3 and indice == 1 or len(self.numero)==2 and indice==0:
................base,medinf,med,sup,sups=1,4,5,9,10
............indice += 1
........return roma
while True:
....entrada=raw_input()
....num=Dec_Rom(entrada)
....print num.check()
Seguiré con los demás ejercicios, por lo pronto ahí esta el primero. Excelente pagina, Dios les bendiga.
ResponderEliminarExcelente Victor. Saludos y gracias por visitar el blog :)
EliminarHola aquí dejo mi versión. Son el ejercicio 1 y 2 juntos.
ResponderEliminarEstá colgado en https://github.com/Didweb/R-mer/blob/master/romanos.py
He mirado de ponerlo aquí pero era muy largo.
Gracias por la web es muy motivadora y me esta ayudando mucho. Saludos.
Hola Edu, gracias a ti por visitar el blog... a seguir metiendo código ;). Saludos
Eliminarejercicio 1
Eliminardef toRomanNumbers (entero):
entero = int(entero)
numero_romano=""
if(int(entero/1000)>0): #M
for i in range(0,int(entero/1000)):
numero_romano=numero_romano+"M"
entero = entero%1000
if(int(entero/100)==9): #CM
entero=entero-900
numero_romano=numero_romano+"CM"
if(int(entero/100)==4): #CD
entero=entero-400
numero_romano=numero_romano+"CD"
if(int(entero/500)>0): #D
for i in range(0,int(entero/500)):
numero_romano=numero_romano+"D"
entero = entero%500
if(int(entero/10)==9): #XC
entero=entero-90
numero_romano=numero_romano+"XC"
if(int(entero/10)==4): #XL
entero=entero-40
numero_romano=numero_romano+"XL"
if(int(entero/100)>0): #C
for i in range(0,int(entero/100)):
numero_romano=numero_romano+"C"
entero = entero%100
if(int(entero/50)>0): #L
for i in range(0,int(entero/50)):
numero_romano=numero_romano+"L"
entero = entero%50
if(entero==9): #IX
entero=entero-9
numero_romano=numero_romano+"IX"
if(int(entero/10)>0): #X
for i in range(0,int(entero/10)):
numero_romano=numero_romano+"X"
entero = entero%10
if(int(entero/5)>0): #V
for i in range(0,int(entero/5)):
numero_romano=numero_romano+"V"
entero = entero%5
if(entero==4): #IV
numero_romano=numero_romano+"IV"
entero=entero-4
if(entero!=0): #I
for i in range(0,int(entero)):
numero_romano=numero_romano+"I"
return numero_romano
ejercicio 1
ResponderEliminarclass Romano:
_roman = {1: 'I', 5: 'V', 10:'X', 50: 'L', 100: 'C', 500: 'D', 1000: 'M'}
def __init__(self, num = None):
self.num = num
def romanizar(self):
entero = int(self.num)
str_romano = ''
for x in (1000, 100, 10, 1):
if entero // x != 0:
valor = entero // x
entero %= x
str_romano += self.asignar(valor, x)
return str_romano
def asignar(self, valor, a):
aux = ''
if valor == 4:
return self._roman[a] + self._roman[5 * a]
elif valor == 9:
return self._roman[a] + self._roman[10 * a]
elif valor >= 5:
aux += self._roman[a * 5]
valor -= 5
aux += self._roman[a] * valor
return aux
class Subconjuntos:
ResponderEliminardef __init__(self, conjunto = None):
self.conjunto = conjunto
def subconj(self):
sub = [[], self.conjunto]
corta = 0
for prim in self.conjunto:
corta += 1
sub += [[prim]]
for sec in self.conjunto[corta:]:
sub += [[prim, sec]]
return sub
s = Subconjuntos([4,5,6])
print(s.subconj())
ejercicio 5
ResponderEliminarclass Elementos:
def __init__(self, matriz = None):
self.matriz = matriz
def search_elemnt(self):
ant = self.matriz[0]
i = 1
for act in (self.matriz[1:]):
if i == len(self.matriz)-1:
return False
if (ant + act) == self.matriz[i+1]:
return i-1 , i
i += 1
ant = act
c = Elementos([10,20,40,40,50,60,70])
print(c.search_elemnt())
Esta es mi solucion para el ejercicio 1: Solo funciona hasta el 4999 por que no se como poner el cinco mil. podrias poner tu solucion:
ResponderEliminarclass NumerosRomanos():
def __init__(self):
self.numero1="I"
self.numero5="V"
self.numero10="X"
self.numero50="L"
self.numero100="C"
self.numero500="D"
self.numero1000="M"
def imprimirlista(self,listanueva):
for i in listanueva:
print(i, end="")
def menorque5(self,numeroarabigo):
self.elnumero=numeroarabigo
self.i=1
self.lista=[]
if 0<self.elnumero<=3:
while self.i<=self.elnumero:
self.lista.append(self.numero1)
self.i=self.i+1
elif self.elnumero==4:
self.lista=["IV"]
else:
#lista=""
pass
return self.lista
def menorque10(self, numeroarabigo):
self.i=6
self.lista=["V"]
if 5<numeroarabigo<=8:
while self.i<=numeroarabigo:
self.lista.append(self.numero1)
self.i=self.i+1
elif numeroarabigo==9:
self.lista=["IX"]
else:
self.lista=["V"]
return self.lista
def menorque50(self, numeroarabigo):
self.i=1
self.lista=[]
if 0<numeroarabigo<=3:
while self.i<=numeroarabigo:
self.lista.append(self.numero10)
self.i=self.i+1
elif numeroarabigo==4:
self.lista=["XL"]
else:
#lista=""
pass
return self.lista
def menorque100(self, numeroarabigo):
self.i=6
self.lista=["L"]
if 5<numeroarabigo<=8:
while self.i<=numeroarabigo:
self.lista.append(self.numero10)
self.i=self.i+1
elif numeroarabigo==9:
self.lista=["XC"]
else:
self.lista=["L"]
return self.lista
def menorque500(self, numeroarabigo):
self.i=1
self.lista=[]
if 0<numeroarabigo<=3:
while self.i<=numeroarabigo:
self.lista.append(self.numero100)
self.i=self.i+1
elif numeroarabigo==4:
self.lista=["CD"]
else:
#lista=""
pass
return self.lista
def menorque1000(self, numeroarabigo):
self.i=6
self.lista=["D"]
if 5<numeroarabigo<=8:
while self.i<=numeroarabigo:
self.lista.append(self.numero100)
self.i=i+1
elif numeroarabigo==9:
self.lista=["CM"]
else:
self.lista=["D"]
return self.lista
def menorque5000(self, numeroarabigo):
self.elnumero=numeroarabigo
self.i=1
self.lista=[]
if 0<self.elnumero<=3:
while self.i<=self.elnumero:
self.lista.append(self.numero1000)
self.i=self.i+1
elif self.elnumero==4:
self.lista=["MV"]
else:
#lista=""
pass
return self.lista
def romanizar(self,arabigo):
for i in range(len(arabigo)):
k=len(arabigo)-i
if int(arabigo[i])<5 and k==1:
self.imprimirlista(self.menorque5(int(arabigo[i])))
elif 5<=int(arabigo[i])<10 and k==1:
self.imprimirlista(self.menorque10(int(arabigo[i])))
elif int(arabigo[i])<5 and k==2:
self.imprimirlista(self.menorque50(int(arabigo[i])))
elif 5<=int(arabigo[i])<10 and k==2:
self.imprimirlista(self.menorque100(int(arabigo[i])))
elif int(arabigo[i])<5 and k==3:
self.imprimirlista(self.menorque500(int(arabigo[i])))
elif 5<=int(arabigo[i])<10 and k==3:
self.imprimirlista(self.menorque1000(int(arabigo[i])))
elif int(arabigo[i])<5 and k==4:
self.imprimirlista(self.menorque5000(int(arabigo[i])))
arabe=input("Podrias introducir el numero a convertir: ")
minumero=NumerosRomanos()
minumero.romanizar(arabe)
Mi version del numero dos, de igual manera solo funciona hasta el 4999 por que no se como expresar el cinco mil:
ResponderEliminarclass RomanoArabigo():
def __init__(self):
self.lista=["I", "V", "X", "L", "C", "D", "M"]
self.sumatoria=0
def validar(self, romano):
self.numero=romano
bandera=False
contador=0
for i in self.numero:
if i.upper() in self.lista:
contador=contador+1
else:
contador=0
break
if contador==0:
bandera=False
print("El Numero es invalido")
else:
bandera=True
return bandera
def enlistar(self, romano):
self.lista=[]
for i in romano:
self.lista.append(i)
return self.lista
def analiza(self, nromano):
self.milista=self.enlistar(nromano)
i=0
while i<(len(self.milista)-1) and i>=0:
if i<len(self.milista):
b=i
if self.milista[i]=="I" and self.milista[i+1]=="V":
self.sumatoria=self.sumatoria+4
self.milista.remove(self.milista[i])
self.milista.remove(self.milista[i])
i=b
elif self.milista[i]=="I" and self.milista[i+1]=="X":
self.sumatoria=self.sumatoria+9
self.milista.remove(self.milista[i])
self.milista.remove(self.milista[i])
i=b
elif self.milista[i]=="X" and self.milista[i+1]=="L":
self.sumatoria=self.sumatoria+40
self.milista.remove(self.milista[i])
self.milista.remove(self.milista[i])
i=b
elif self.milista[i]=="X" and self.milista[i+1]=="C":
self.sumatoria=self.sumatoria+90
self.milista.remove(self.milista[i])
self.milista.remove(self.milista[i])
i=b
elif self.milista[i]=="C" and self.milista[i+1]=="D":
self.sumatoria=self.sumatoria+400
self.milista.remove(self.milista[i])
self.milista.remove(self.milista[i])
i=b
elif self.milista[i]=="C" and self.milista[i+1]=="M":
self.sumatoria=self.sumatoria+900
self.milista.remove(self.milista[i])
self.milista.remove(self.milista[i])
i=b
elif self.milista[i]=="M" and self.milista[i+1]=="V":
self.sumatoria=self.sumatoria+4000
self.milista.remove(self.milista[i])
self.milista.remove(self.milista[i])
i=b
else:
i=i+1
self.sumatoria=self.sumatoria+(self.lista.count("I")*1)
self.sumatoria=self.sumatoria+(self.lista.count("V")*5)
self.sumatoria=self.sumatoria+(self.lista.count("X")*10)
self.sumatoria=self.sumatoria+(self.lista.count("L")*50)
self.sumatoria=self.sumatoria+(self.lista.count("C")*100)
self.sumatoria=self.sumatoria+(self.lista.count("D")*500)
self.sumatoria=self.sumatoria+(self.lista.count("M")*1000)
print("Tu numero Romano convertido al Arabigo es:")
print(self.sumatoria)
Romano=RomanoArabigo()
validacion=False
while validacion!=True:
minumero=input("Por favor introduce un numero romano: ")
validacion=Romano.validar(minumero)
Romano.analiza(minumero)
Este comentario ha sido eliminado por el autor.
ResponderEliminarMi solucion al numero 3, tambien valida casos como un parentesis de cerradura antes de uno de apertura ejemplo: ())[]
ResponderEliminarclass Parentesis():
def __init__(self):
self.curvos1=('(')
self.curvos2=(')')
self.cuadrados1=('[')
self.cuadrados2=(']')
self.llaves1=('{')
self.llaves2=('}')
def verificar(self, parentesisr):
self.parentesisl=[""]
for i in parentesisr:
self.parentesisl.append(i)
self.curv1=self.parentesisl.count(self.curvos1)
self.curv2=self.parentesisl.count(self.curvos2)
self.cuad1=self.parentesisl.count(self.cuadrados1)
self.cuad2=self.parentesisl.count(self.cuadrados2)
self.llave1=self.parentesisl.count(self.llaves1)
self.llave2=self.parentesisl.count(self.llaves2)
self.b=True
for i in range(len(parentesisr)):
if parentesisr[i] in self.curvos2 and i==0:
self.b=False
elif parentesisr[i] in self.curvos2 and i>0:
c=i-1
while c>=0:
if parentesisr[c] in self.curvos1:
self.b=True
break
else:
self.b=False
c=c-1
elif parentesisr[i] in self.cuadrados2 and i==0:
self.b=False
elif parentesisr[i] in self.cuadrados2 and i>0:
c=i-1
while c>=0:
if parentesisr[c] in self.cuadrados1:
self.b=True
break
else:
self.b=False
c=c-1
elif parentesisr[i] in self.llaves2 and i==0:
self.b=False
elif parentesisr[i] in self.llaves2 and i>0:
c=i-1
while c>=0:
if parentesisr[c] in self.llaves1:
self.b=True
break
else:
self.b=False
c=c-1
if self.curv1==self.curv2 and self.cuad1==self.cuad2 and self.llave1==self.llave2 and self.b==True:
print("La estructura de parentesis es valida")
else:
print("La estructura de parentesis es invalida")
estructura=input("Por favor introduce una estructura de parentesis: ")
MisParentesis=Parentesis()
MisParentesis.verificar(estructura)
este es mi código para convertir de romanos a números y viceversa
ResponderEliminarhttps://ideone.com/NjKaQh
Me podrian ayudar con este ejercicio porfa
ResponderEliminar* Escribir una clase en python llamada rectangulo que contenga una base y una altura, y que contenga un método que devuelva el área del rectángulo.
class rectangulo:
Eliminardef __init__(self, ladosLargos, ladosCortos):
self.ladoLargo=ladosLargos;
self.ladoCorto=ladosCortos;
def perimetro(self):
self.perimetro=(self.ladoLargo*2)+(self.ladoCorto*2);
return self.perimetro;
def area(self):
self.Area=self.ladoCorto*self.ladoLargo;
return self.Area;
class triangulo:
def __init__(self, base, lado2, lado3, altura):
self.Base=base;
self.ladoDos=lado2;
self.ladoTres=lado3;
self.Altura=altura;
def perimetro(self):
self.perimetro=self.base+self.ladoDos+self.ladoTres;
return self.perimetro;
def area(self):
self.Area=self.Base*self.Altura;
return self.Area;
lado1=float(input("Dame el lado largo: "));
lado2=float(input("Dame el lado corto: "));
rectangulo= rectangulo(lado1, lado2);
print("El perimetro es:", rectangulo.perimetro()," y el área es:", rectangulo.area())
ahi esta el del triangulo y el del rectangulo, amigo
EliminarMi solucion particular para el caso de 1,2 y hasta 3 elementos del ejercicio 4,observen como utlizo un operador en python que he decubierto el operador [d:e:s] que se aplica sobre una lista y puede devolver la misma lista u otra diferente, presten atencion que no hace lo mismo que el conocido operador[n:f],donde las letras son numeros enteros.
ResponderEliminarclass conbinatoria_deelementos():
def __init__(self):
self.entrada=list(input("Introdusca una lisa de numeros :"))
self.tamaño=len(self.entrada)
self.lista=[]
self.listavariable=[]
def creaciondesubgrupos(self):
n=0
s=0
for i in range(0,self.tamaño):
self.listavariable.append(self.entrada[i])
for j in range(0,self.tamaño-n):
self.lista.append(self.entrada[i:j+2+s:j+1])
n=n+1
s=s+1
#j=j-1
self.lista.append([])
if self.listavariable in self.lista:
print(self.lista)
else:
self.lista.append(self.listavariable)
print(self.lista)
conjunto=conbinatoria_deelementos()
conjunto.creaciondesubgrupos()
Lo he hecho mas o menos. Todo lo que viene a ser el método que convierte un entero -menor de 4000- en romano esta bien pero la parte de la clase y donde se instancia el entero como un número está mal:
ResponderEliminarclass Conversor:
def __init__(self,numero):
self.numero = numero
def convertir(self,numero):
romanos = {1500:'DM',1000:'M',900:'CM',500:'D',450:'LD',400:'CD',
100:'C',90:'XC',50:'L',40:'XL',10:'X',9:'I',5:'V',4:'IV',1:'I',0:''}
numlist = {0:'V', 1:'L', 2:'D'}
listnum = []
numero = str(numero)
for i in numero:
listnum.append(i)
for i in listnum:
listnum.insert(listnum.index(i),int(i))
listnum.remove(i)
numrom = ''
numero = int(numero)
x = len(listnum)
if numero < 4000:
for i in listnum:
if i in romanos:
i *= (10**(x-1))
numrom += romanos[i]
else:
if i == 2:
numrom += romanos[10**(x-1)]*2
elif i == 3:
numrom += romanos[10**(x-1)]*3
elif i == 6:
numrom += (numlist[x-1] + romanos[10**(x-1)])
elif i == 7:
numrom += (numlist[x-1] + romanos[10**(x-1)]*2)
elif i == 8:
numrom += (numlist[x-1] + romanos[10**(x-1)]*3)
x-= 1
return numrom
else:
return 'No podemos convertir ese numero'
Entero = Conversor(467)
print(Entero.convertir(467))