Ejercicios de clases y objetos en python (parte 1)

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

  1. Unknown dice:

    Un intento de los numeros romanos :

    categorias = [['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()

  2. Unknown dice:

    Ejercicio 2

    popurri = {'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()

    1. PythonDiario dice:

      Excelente Lucas. Gracias por visitar y participar en el blog. saludos

  3. Victor Cueva dice:

    Este comentario ha sido eliminado por el autor.

  4. Victor Cueva dice:

    Mi código: ideone.com

    1. PythonDiario dice:

      Excelente Victor. Gracias por visitar y participar en el blog. saludos

  5. Víctor dice:

    Este comentario ha sido eliminado por el autor.

  6. Víctor dice:

    # -*- coding: utf-8 -*-

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

  7. Víctor dice:

    Seguiré con los demás ejercicios, por lo pronto ahí esta el primero. Excelente pagina, Dios les bendiga.

    1. PythonDiario dice:

      Excelente Victor. Saludos y gracias por visitar el blog 🙂

  8. Edu dice:

    Hola aquí dejo mi versión. Son el ejercicio 1 y 2 juntos.
    Está 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.

    1. PythonDiario dice:

      Hola Edu, gracias a ti por visitar el blog... a seguir metiendo código ;). Saludos

    2. Anónimo dice:

      ejercicio 1

      def 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

  9. Anónimo dice:

    ejercicio 1

    class 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

  10. Anónimo dice:

    class Subconjuntos:

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

  11. Anónimo dice:

    ejercicio 5

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

  12. Unknown dice:

    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:

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

  13. Unknown dice:

    Mi version del numero dos, de igual manera solo funciona hasta el 4999 por que no se como expresar el cinco mil:

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

  14. Unknown dice:

    Este comentario ha sido eliminado por el autor.

  15. Unknown dice:

    Mi solucion al numero 3, tambien valida casos como un parentesis de cerradura antes de uno de apertura ejemplo: ())[]

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

  16. Unknown dice:

    este es mi código para convertir de romanos a números y viceversa
    https://ideone.com/NjKaQh

  17. Anónimo dice:

    Me podrian ayudar con este ejercicio porfa

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

    1. Branco dice:

      class rectangulo:
      def __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())

    2. Branco dice:

      ahi esta el del triangulo y el del rectangulo, amigo

  18. Unknown dice:

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

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

  19. Anónimo dice:

    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:

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

  20. Anónimo dice:

    '''
    Escribe una Clase que Convierta un Número Entero a Número Romano.
    '''

    class Roman_Numerals(object):

    # Atributo de Clase.
    dictNumber = {1: "I", 2: "II", 3: "III", 4: "IV", 5: "V", 6: "VI", 7: "VII", 8: "VIII", 9: "IX", 10: "X"}

    # Constructor.
    def __init__(self, intNumber):
    # Variable de Instancia.
    self.intNumber = intNumber

    # Método de Instancia.
    def Convert(self):
    # Recorremos el Diccionario por las Llaves.
    for number in self.dictNumber:
    if self.intNumber == number:
    # get() regresa el Valor según la Llave asignada.
    print("El Numero {0} en Romano es {1}".format(self.intNumber, self.dictNumber.get(number)))

    if __name__ == '__main__':
    rn = Roman_Numerals(6)
    rn.Convert()

  21. Anónimo dice:

    '''
    Escribe una Clase que Convierta un Número Romano a Número Entero.
    '''

    class Roman_Numerals(object):
    # Atributo de Clase.
    dictNumber = {1: "I", 2: "II", 3: "III", 4: "IV", 5: "V", 6: "VI", 7: "VII", 8: "VIII", 9: "IX", 10: "X"}

    # Constructor.
    def __init__(self, strNumber):
    self.strNumber = strNumber

    # Método de Instancia.
    def Convert(self):
    # Recorremos el Diccionario por los Valores.
    for i in range(1, len(self.dictNumber) + 1):
    if self.strNumber == self.dictNumber[i]:
    # Obtenemos las Llaves en un tipo 'dict_keys' que después convertiremos a Lista.
    self.listKeys = list(self.dictNumber.keys())
    # Le Restamos 1 dado que las Listas empiezan con el Índice 0.
    self.listKeys = self.listKeys[i - 1]

    def __str__(self):
    return "El Numero Romano {0} es el Numero Entero {1}".format(self.strNumber, self.listKeys)

    if __name__ == '__main__':
    rn = Roman_Numerals("VII")
    rn.Convert()
    print(str(rn))

  22. Anónimo dice:

    '''
    Escribe una Clase 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]]
    '''

    class Subconjuntos:

    def __init__(self, conjunto):
    self.conjunto = conjunto

    def subconj(self):
    sub = [[], self.conjunto]
    corta = 0
    for prim in self.conjunto:
    print("prim ",prim)
    corta += 1
    sub += [[prim]]
    for sec in self.conjunto[corta:]:
    print("Conjunto: ", self.conjunto[corta:], "corta: ", corta)
    sub += [[prim, sec]]
    print("Sub: ", sub)

    return sub

    s = Subconjuntos([4,5,6])

    print(s.subconj())

  23. Anónimo dice:

    '''
    Ejercicio 5
    Escribe una clase que Encuentre un Par de Elementos de una Matriz cuya Suma es Igual a un Objetivo Específico.
    Entrada: Numeros = [10,20,10,40,50,60,70] ; Objetivo=50
    Salida: 3, 4
    '''

    class Peers(object):

    # Atributo de Clase.
    list_Numbers = [10, 20, 10, 40, 50, 60, 70]

    # Constructor.
    def __init__(self, int_Obj):
    self.int_Obj = int_Obj

    # Método de Instancia.
    def findPeers(self):
    for i in range(len(self.list_Numbers)):
    if (self.list_Numbers[i] + self.list_Numbers[i - 1]) == self.int_Obj:
    self.i = i
    self.i_1 = (i-1)

    def __str__(self):
    return ("Los Indices que Suman {0} son ({2}, {1}).".format(self.int_Obj, self.i, self.i_1))

    if __name__ == '__main__':
    peers = Peers(50)
    peers.findPeers()
    print(str(peers))

  24. Anónimo dice:

    '''
    Escribir una Clase 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]]
    '''

    class Find(object):

    def __init__(self, list_Enter):
    self.listEnter = list_Enter
    self.listOut = []

    def set_Zero(self):
    for i in range(len(self.listEnter)):
    j = i + 1
    for j in range(j, len(self.listEnter)):
    k = j + 1
    for k in range(k, len(self.listEnter)):
    if (self.listEnter[i] + self.listEnter[j] + self.listEnter[k] == 0):
    self.listOut.append( [self.listEnter[i], self.listEnter[j], self.listEnter[k]] )

    def get_Zero(self):
    return self.listOut

    def __str__(self):
    return "{0}".format(self.listOut)

    sum_Zero = property(get_Zero, set_Zero)

    if __name__ == '__main__':
    f = Find( [-25,-10,-7,-3,2,4,8,10] )
    f.set_Zero()
    print("Get: ", f.get_Zero())
    print("Property: ", f.sum_Zero)
    print("STR: ", str(f))

  25. Anónimo dice:

    '''
    Escribe una Clase que Calcule pow(x, n)
    x = es la base
    n = es el exponente

    Entrada: pow(2, -3)
    Salida: 0.125
    '''

    class Pow(object):

    # Constructor.
    def __init__(self, x, n):
    self.x = x
    self.n = n

    # Método de Instancia.
    def findPow(self):
    self.ans = (self.x ** self.n)

    def __str__(self):
    return "Entrada: ({0}, {1}). Salida: {2}.".format( self.x, self.n, self.ans )

    if __name__ == '__main__':
    p = Pow(2, -3)
    p.findPow()
    print(str(p))

  26. Anónimo dice:

    '''
    Escribe una Clase que Revierta una Cadena de Palabras.
    Entrada: "Mi Diario Python"
    Salida: "Python Diario Mi"
    '''

    class Reverse(object):

    # Constructor.
    def __init__(self, strCadena):
    self.strCadena = strCadena
    self.list_Cadena = self.strCadena.split(" ")
    self.newCadena = []

    # Método de Instancia.
    def reverse(self):
    for i in range( 0, len(self.list_Cadena) ):
    self.newCadena.append( self.list_Cadena[(i+1) * -1] )
    self.newCadena = ' '.join(self.newCadena)

    def __str__(self):
    return "Entrada: {0}. Salida: {1}.".format(self.strCadena, self.newCadena)

    if __name__ == '__main__':
    r = Reverse("Mi Diario Python")
    r.reverse()
    print(str(r))

    1. Unknown dice:

      Tiene Error,no Corre el programa

    2. Unknown dice:

      en el metodo de Instancia

    3. Anónimo dice:

      Como saldria

    4. Unknown dice:

      ayuden, bien el código porfa

  27. Omar dice:

    Numeros romanos (se que esta pobre pero es un avance):
    class Numero():

    def __init__(self,n):
    self.numero = n

    def convertir(self):

    n = self.numero
    nr = int(n)
    cont = len(n)
    pos = len(n)-1
    cad = ""
    aux = ""
    nums = {9:"IX",8:"VIII",7:"VII",6:"VI",5:"V",4:"IV",3:"III",2:"II",1:"I",0:"",10:"X",20:"XX",30:"XXX",40:"LX",50:"L",60:"LX",70:"LXX",80:"LXXX",90:"XC",
    100:"C",200:"CC",300:"CCC",400:"CD",500:"D",600:"DC",700:"DCC",800:"DCCC",900:"CM",1000:"M",2000:"MM",3000:"MMM"}
    x = 0
    while x < cont:
    l = int(n[pos:cont])
    cad = nums[l]+cad
    x = x+1
    pos = pos-1
    nr = nr - int(l)
    n = str(nr)
    return cad

    num = input("Dame un numero n")
    miNumero = Numero(num)
    print("El numero en romano es :")
    print(miNumero.convertir())

  28. Unknown dice:

    Ejercicio 11

    if __name__ == "__main__":
    class Circulo: #<-- Clase
    def __init__(self, radio, diametro): #<-- Constructor
    self.radio=radio
    self.diametro=diametro
    def calcularArea(self): #<-- 1er Metodo
    pi = 3.14
    return (self.radio**2)*pi #<-- Operacion ** significa elevado
    def calcularPeri(self): #<-- 2do Metodo
    pi = 3.14
    return self.diametro*pi
    radio=float(input("Ingrese el valor del radio: "))
    diametro=float(input("Ingrese el valor del diámetro: "))
    cir=Circulo(radio,diametro) # objeto cir llamando a la clase
    area=cir.calcularArea() # objeto area que llama al 1er metodo
    perimetro=cir.calcularPeri() #objeto perimetro que llama al 2do metodo
    print("El area del círculo es: ",area)
    print("El perimetro del círculo es: ",perimetro)

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Subir

Te has suscrito correctamente al boletín

Se produjo un error al intentar enviar tu solicitud. Inténtalo de nuevo.

Mi Diario Python will use the information you provide on this form to be in touch with you and to provide updates and marketing.