Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Poniendo a prueba el manejo de excepciones

16/21
Recursos

Aportes 698

Preguntas 24

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Solución al reto (le añadí un bucle while para que el programa se ejecute indefinidamente, hasta que el usuario ingrese un valor válido):

def divisors(num):
    divisors = []
    for i in range(1, num + 1):
        if num % i == 0:
            divisors.append(i)
    return divisors


def run():
    while True:
        try:
            num = int(input('Ingresa un número: '))
            if num < 0:
                raise ValueError
            print(divisors(num))
            print("Terminó mi programa")
            break
        except ValueError:
            print("Debes ingresar un entero positivo")


if __name__ == '__main__':
    run()
<def divisor(num):
    try:
        if num < 0:
            raise ValueError("ingresa un número positvo")
        divisors =[i for i in range(1, num + 1) if num % i == 0]
        return divisors
    except ValueError as ve:
        print(ve)
        return False


def run():
    try: 
        num = int(input(f'Ingresa un número: '))      
        print(divisor(num))
        print("termino mi programa")
    except ValueError:
        print("ingresa un número")
    
if __name__ =='__main__':
    run()> 

Solución reto

    try:
        num = int(input('Enter a number: '))
        if num < 0:
            raise Exception('Negative number is not valid')
        print(divisors(num))
        print('[!] Finish...')

    except ValueError:
        print('[!] Solo puedes añadir numeeros')
    except Exception:
        print('[!] El numero no puede ser negativo')

👾 Mejorando el control de las excepciones de nuestro proyecto.

def divisors(num):
    try:
        if num < 0:
            raise ValueError('Ingresa solo números positivos')
        else:
            divisors = [i for i in range(1, num + 1) if num % i == 0]
            return divisors
    except ValueError as value_error:
        print(value_error)
        return str(num) + " No es nu numero positivo"


def run():
    try:
        num = int(input("Ingresa un número: "))
        print(divisors(num))
        print("Terminó mi programa")
    except ValueError:
        print("Debes ingresar un número")


if __name__ == "__main__":
    run()
def run():
    divisors = lambda num: [x for x in range(1, num + 1) if num % x == 0]

    try:
        num = int(input('Ingresa un numero: '))
        if num < 0:
            raise ValueError('Solo ingresa numeros positivos')
        print(divisors(num))
        print("Termino")
    except ValueError:
        print('Solo Ingrese Numeros Positivos :|')

if __name__ == '__main__':
    run()
def divisors(num):
    divisors = []
    try:
        if num > 0:
            for i in range(1,num + 1):
                if num % i == 0:
                    divisors.append(i)
            return divisors
        if num < 0:
            raise ValueError ('No se puede ingresar numeros negativos')
    except ValueError as ve:
        print(ve)
        return False


def main():
    try:
        num = int(input('Ingresar numero: '))
        print(divisors(num ))
    except ValueError:
        print('No es un numero') 


if __name__ == "__main__":
    main()

Solucion al reto, dejando tambien la validacion del ingreso solo de numeros:

def run():
    try:
        num = int(input("INGRESA NUMERO"))
        try:
            if num <0:
                raise ValueError("No se puede ingresar numeros negativos")
            print(divisors(num))
        except ValueError as ve:
            print(ve)
    except ValueError:
        print("DEBES INGRESAR UN NUMERO")
def divisors(num):
    return [i for i in range (1,num+1) if num%i == 0]

def run():
    try:
        num = int(input("Ingrese un número: "))
        if num < 0:
            raise Exception("Ingrese un número positivo.")
        print(divisors(num))
        print("Termino el programa")
    except ValueError:
        print("Debes ingresar un número.")
    except Exception:
        print("Debes ingresar un número positivo.")
        
if __name__=='__main__':
    run()

Mi reto

Explicacion

El codigo esta dentro de un bucle while eterno que hace al programa pedir un numero como entrada hasta recibir el valor esperado. Usando condicionales y manejo de errores, el programa al recibir una entrada invalida salta a la siguiente iteracion con continue, reseteando todo el proceso y volviendo a pedir una nueva entrada. Una vez recibida la entrada valida, el programa finaliza.

Para el reto creé una excepción específica en caso de que el usuario ingrese un número negativo:

class ValueIsNegative(Exception):
  pass

def divisors(num):
  divisors = []
  for i in range(1, num+1):
    if num % i == 0:
      divisors.append(i)

  return divisors


def run():
  try:
    num = int(input("Ingresa un número: "))
    if num < 0:
      raise ValueIsNegative
    print(divisors(num))
  except ValueError:
    print("Debes ingresar un número")
  except ValueIsNegative:
    print("Debes ingresar un número positivo")



if __name__ == "__main__":
  run()

En ocasiones nuestro código tendrá la posibilidad de que salte más de un tipo de excepción, y por lo tanto podemos emplear más de un except dentro de un try.

def dividir(numero):
    return 1 / numero


def run():
    try:
        numero = int(input('Escribe un numero: '))
        print(divisor(numero))
    except ValueError:
        print('Solamente se aceptan numeros')
    except ZeroDivisionError:
        print('No se puede dividir entre 0')
    except:
        print('Se encontro un error')


if __name__ == '__main__':
    run()

Si el try lanza cualquier otra tipo de excepción no manejada, será manejada por el último except.

Modifiqué el archivo original y ahora es un proceso para traducir un decimal a binario y a este le añadí las excepciones de type y value para los valores o tipo de vlaor no validos en cada proceso.

# -*- coding: utf-8 -*-
def binary(num):
    try:
        if num <= 0:
            raise ValueError("El número debe ser positivo o mayor a cero")
        binary = []
        divisor = num
        while divisor > 0:
            binary.append(divisor % 2)
            divisor = int(divisor / 2)
        return binary
    except ValueError as ve:
        print(ve)

def run():
    try:
        num = int(input('Ingresa un numero: '))            
        str_bin = ''.join([str(b) for b in binary(num)])[::-1]
        print('El numero {} en binario es: {}'.format(num, str_bin))
    except ValueError:
        print("Debes añadir un número")
    except TypeError:
        print("El valor añadido no tiene un formato valido")

if __name__ == '__main__':
    run()

Para manejar los dos mensajes de error, y como el error del ingreso de cadenas levanta es un ValueError, utilice el NameError, para con el reise levantar el otro error, y mostar el mensaje correcto según sea el caso, así:

def my_divisor(a):
    divisor = []
    for i in range(1,a+1):
        if a % i == 0:
            divisor.append(i)
    return divisor


def run():
    try:
        num = int(input('Ingrese un Número ='))
        if num < 0:
            raise NameError('Los datos solo deben ser números enteros ')
        print(my_divisor(num))
        print("Gracias por utilizar nuestro Sistema")
    except NameError as ne:
       print(ne)     
    except ValueError:
       print('Deben ser datos numéricos')  

if __name__ == '__main__':
    run()

Para cortar el ciclo While

	return False

al final del try . Osea antes del except

Para que no se haga infinito su ciclo.

Reto:

def divisor(num):
    divisors = []
    if num < 0:
        raise ValueError('Debes ingresar un numeo positivo')

    for i in range(1, num + 1):
        if num % i == 0:
            divisors.append(i)
    return divisors


def run():
    try:
        num  = int(input('Ingresa un numero: '))
        try:
            print(divisor(num))
        except ValueError as e:
            print(e)

    except ValueError:
        print('Debes ingresar un numero')
        


if __name__ == '__main__':
    run()

Solución al reto
El bucle me permite no salir del programa hasta que ingrese un numero entero positivo

def divisors(num):
    try:
        if num < 0:
            raise ValueError("Debes ingresar un numero positivo")
        if num == 0:
            raise ValueError("Debes ingresar un numero que no sea 0")
        divisors = [i for i in range(1, num+1) if num % i == 0]
        return divisors
    except ValueError as ve:
        print(ve)
        run()


def run():
    while True:
        try:
            num = int(input("Ingresa un numero: "))
            print(divisors(num))
            print("Termino mi programa")
            break
        except ValueError:
            print("Escribe un numero entero por favor")


if __name__ == '__main__':
    run()

Esta es mi solución al reto, añadí un bucle while para que se ejecutara hasta que el usuario ingresara un valor valido

def divisors(num):
    try:
        if num < 0 or num == 0:
            raise ValueError("Ingresa un número positivo ó mayor que cero")
        divisors = [i for i in range(1, num + 1) if num % i == 0]
        return divisors
    except ValueError as ve:
        print(ve)
        run()

def run():
    while True:
        try:
            num = int(input("Ingresa un número: "))
            print(divisors(num))
            print("Termino mi programa")
            break
        except ValueError:
            print("Debes ingresar un número")

if __name__ == '__main__':
    run() 

Hola, mi solución:

def run():
    try:
        num = int(input("Ingresa un número: "))
        try:
            if num < 0 or num == 0:
                raise Exception("No se puede ingresar un número negativo")
        except Exception as ex:
            print(ex)

        divisors = lambda num: [i for i in range (1, num + 1) if num % i == 0]
        print(divisors(num))
        print("Terminó mi programa")
    except ValueError:
        print("Debes ingresar un número")

if __name__ == "__main__":
    run()
def divisors( numero ):
    try:
        if numero < 1:
            raise ValueError( "No se permiten número negativos. Por favor ingresa un número positivo mayor a cero")
        #divisors = [ i for i in range( 1, numero + 1 ) if numero % i == 1 ]    
        divisors = []
        for i in range( 1, numero + 1):
            if numero % i == 0:
                divisors.append( i )
        return divisors

    except ValueError as ve:
        print( ve )
        return False


def run():
    try:
        num = int (input('Ingrese un número: '))
        print ( divisors( num ) )
        print( '****** TERMINO MI PROGRAMA *****' )
    except ValueError:
        print('Debes ingresar un número')


if __name__ == '__main__':
    run()

Reto

def divisors(num):
    try:
        if num <= 0:
            raise ValueError("Debes ingresar un numero positivo o mayor a cero")        
            divisors = []
            for i in range(1, num + 1):
                if num % i == 0:
                    divisors.append(i)
            return divisors
    except ValueError as ve:
        print(ve)
        return False


def run():
    try:
        num = int(input("Ingrese un numero: "))
        print(divisors(num))
        print("Terminó mi programa")
    except ValueError:
        print("Debes ingresar un numero")


if __name__ == '__main__':
    run()

Solución al reto con las otras restricciones también (cadena vacía, TypeError y números negativos):

def palindrome(string):
    try:
        if len(string) == 0:
            raise ValueError("No se puede ingresar una cadena vacía")
        return string  == string[::-1]
    except ValueError as ve:
        print(ve)
        return False


if __name__ == '__main__':
    try:
        print(palindrome(""))
    except TypeError:
        print("Sólo se pueden ingresar strings")

Aqui mi manejo de excepciones con raise:

Al principio no encontraba la manera de enviar el error de números negativos usando un raise ValueError y comprendi que puedes usar un raise de otro tipo, en este caso lo cree y este fue el resultado:

Les comparto mi solución:

def divisors(num):
    
    # divisors=[]

    # for i in range (1, num+1):
    #     if num % i == 0:
    #         divisors.append(i)

        divisors = [i for i in range(1, num + 1) if num % i == 0]
        return divisors


def run():
    try:
        num = int(input("ingresa un numero: "))
        if num<=0:
            raise  Exception ("Debe ingresar un numero mayor a 0")
        print(divisors(num))
        print("Termino mi programa")
    except ValueError:
        print("Debes ingtresar un número")
    except Exception as ve:
        print(ve)

if __name__ == '__main__':
    run()

Cómo usar Raise

Aqui mi solución

def divisors(num):
    divisors=[]
    try:
        if num < 0:
            raise ValueError("Es un número negativo")
        for i in range(1,num +1):
            if num % i ==0:
                divisors.append(i)
        return divisors
    except ValueError as ve:
        print(ve)
        return False


def main():
    try:
        num = int(input("ingresa un numero: "))
        print(divisors(num))
        print('Termino el programa')
    except ValueError:
        print('Debes ingresar un número')

if __name__ == "__main__":
    main()

Mi humilde aporte

def divisores(num):
    divisores = []
    try:
        if num <= 0:
            raise ValueError("Ingrese numeros positivos")
        for i in range(1, num + 1):
            if num % i == 0:
                divisores.append(i)
        return divisores,True
    except ValueError as ve:
        print(ve)
        return "Ingresa nuevamente!"


def run():

    terminado = False

    while not terminado:
        try:
            num = int(input("Ingresa un numero: "))
            if num > 0 :
                lista_divisores, terminado = divisores(num)
                print(f"Los numeros divisores de {num} son: {lista_divisores}" )
            else:
               print(divisores(num))
            
        except ValueError:
            print("Debes ingresar numeros")

    print("Ejecucion terminada")


if __name__ == '__main__':
    run()

Mi aporte con la solución del reto

Aquí esta mi solución, si alguien es tan amable de darme feedback se la agradecería.

def divisors(num):
    try:
        if num <= 0:
            raise ValueError("Debes ingresar un número positivo")
    except ValueError as ve:
        print(ve)
        return ""

    divisors = []
    for i in range(1, num + 1):
        if num % i == 0:
            divisors.append(i)
    return divisors

def run():
    try:
        num = int(input("Ingresa un número: "))
        print(divisors(num))
        print("Termino mi programa")    
    except :
        print("Debes ingresar un número")
    
if __name__ == '__main__':
    run()

Mi solución al reto:

def divisors(num):      
    try:
        if num < 0:
            raise ValueError("Debes ingresar un número positivo")
        elif num == 0:
            raise ValueError("Debes ingresar un número mayor a cero")
        else:
            divisores = [i for i in range(1,num+1) if num%i == 0]
    except ValueError as ve:
        print(ve)
        divisores = False
    
    return divisores


def run():
    try:
        num = int(input("Ingresa un número: "))            
        print(divisors(num))
    except ValueError:
        print("Debes ingresar un número")

if __name__ == '__main__':
    run()

Hola.
Les comparto mi Solución al reto.

En la función divisors añadí un try con la validación de números menores a cero seria error, esto lo almacene con raise para elevarlo y en la except retornar el error.

en la función run genere otro try revisando que solo se permitan números.

def divisors(num):
    try:
        if num < 0:
            raise ValueError("Solo se adminten Numeros positivos")

        divisors = []
        for i in range(1, num +1):
            if num % i == 0:
                divisors.append(i)
        return divisors
    except ValueError as ve:
        return ve

def run():
    try:
        num = int(input('Ingresa un numero: '))
        print(divisors(num))
        print("Termino el programa")
    except ValueError as ve:
        print("Solo se adminten Numeros")

if __name__ == '__main__':
    run()

Hola!, Mi solucion al reto.

def divisors(num):
    divisors = [i for i in range(1,num + 1) if num%i == 0]
    return divisors


def run():
    try:
        num = int(input('Ingresa un número: '))

        try:
            if num <= 0:
                raise ValueError("Debe ser un numero mayor a cero!.")
            print(divisors(num))
            print("Terminó mi programa")
    
        except ValueError as ve:
            print(ve)
    
    except ValueError:
        print("Debes ingresar un valor numerico.")

if __name__ == '__main__':
    run()

Creo que las llamadas a la función “run()” son mala prática, si lo es avísenme please

def divisors(num):
    try:
        if num <= 0:
            raise ValueError("It must be a positive number higher than 0")
        num_divisors = [i for i in range(1, num+1) if num % i == 0]
        print(num_divisors)
        print("Done")
    except ValueError as ve:
        print(ve)
        run()


def run():
    try:
        num = int(input("Enter a number:"))
        divisors(num)
    except ValueError:
        print("You must to enter an integer number")
        run()


if __name__ == "__main__":
    run()

Le incluí también un raise para el caso de que alguien ingrese el número 0.

def divisors(num):
    try:
        if num < 0:
            raise ValueError ('No se puede ingresar numeros negativos.')
        elif num == 0:
            raise ValueError (f'El {num} es un caso especial, ya que nos daria infinito.')
        else:
            divisors = [i for i in range (1, num +1) if num %i == 0]
            return divisors
    except ValueError as ve:
        return ve
        
        
def run():
    try:
        num = int(input('Ingresa un número: '))
        print(divisors(num))
        print("Terminó mi programa")
    except ValueError:
        print ('Debes ingresar un numero')

if __name__ == '__main__':
    run()
def divisors(num):
    divisors = [i for i in range(1, num + 1) if num % i == 0]
    return divisors

def run():
    try:
        num = int(input('Enter a number: '))
        if num <= 0:
            raise ValueError("Just natural numbers")
        print(divisors(num))
    except ValueError as ve:
        print(ve)
    finally:
        print("End my code")


if __name__ == '__main__':
    run()
try:
        num = int(input('Enter a number: '))
        if num<=0:
            raise TypeError('Ingresa valores superiores a 0')
        print(divisor(num))
    except ValueError:
        print('Ingresa valores numericos')
    except TypeError as ve:
        print(ve)
    print('Finish')

ValueError es una excepción incorporada (definida por Python) que es lanzada cuando una función espera un valor determinado pero recibe otro. Consideremos un ejemplo más real. edad = int(input("Escribe tu edad: ")) if edad >= 18: print(“Eres un adulto.”) else: print(“Aún no eres un adulto.”)

Completando el RETO utilizando try, raise, except y finally:

# method to return divisors of one numbers
def divisors(num):
   divisors = [i for i in range(1, num + 1) if num % i == 0]
   return divisors

def run():
   try:
      num = int(input('Enter a number to know the divisors: '))
      if(num < 0):
         raise ValueError('Enter a positive number')
      else:
         div = divisors(num)
         print('Divisors of', num)
         for i in div:
            print(i)
   except ValueError as ve:
      print(ve)
   finally:
      print('Program Finished!')

if __name__ == '__main__':
   run()

def divisors(num):
divisors = []
for i in range(1, num + 1):
if num % i == 0:
divisors.append(i)
return divisors

def negativ(num):
try:
if num < 0:
raise ValueError(“escribe un número positivo”)
return divisors (num)
except ValueError as ve:
print(ve)
return False

try:
#print(palindrome(“ana”))
num = int(input("escbribe un número= "))
print(negativ(num))
except TypeError:
print(“Debes ingresar un número positivo”)

Reto

def run():
    try:
        num = int(input("Ingresa un número: "))
        if num<0:
            raise ValueError("Debes ingresar números positivos")
        print(divisors(num))
        print("Terminó")
    except ValueError as ve :
        print(ve)
        return False

#Una excepción propia que será elevada por la función divisors 
class NegativeDivisorsError(Exception):
    
    def __init__(self, message):
        
        self.message = message                

    def __str__(self):
        
        return self.message

def divisors(num):    
    
    if num<=0:
    
        raise NegativeDivisorsError("El número debe ser positivo")
    
    divisors = [i for i in range(1, num+1) if num%i == 0]
    
    return divisors

def run():
    
    try:        
        
        num = int(input('Ingresa un número: '))        
        
        print(divisors(num))
    
        print('Terminó el programa')
        
    except ValueError as ve:        
    
        print("El valor debe ser numérico")
    
    except NegativeDivisorsError as de:
    
        print(de)
    

if __name__=='__main__':
    run()

Result 📊🖐️

def get_divisors(number: int) -> list:

    # we onli accept positive numbers
    assert number >= 1, f'{number} Only positive numbers are allowed'
    return [i for i in range(0, number + 1) if i % 2 == 0]


def run():
    try:
        number = int(input('Enter a number to calculate all divisors: '))
        print(get_divisors(number))
        print('End of the program')
    except ValueError:
        print('You must enter only numbers')


if __name__ == '__main__':
    run()

Probe con esto! sumando list comprehensions

def list_divisors(num):
    divisors = [i for i in range(1, num+1) if num%i == 0]
    return divisors        

def run2():
    try:
        num=int(input("Ingresa un numero: "))
        print(list_divisors(num))
        print("Termino mi programa")
        if num<0: 
            print("Lo siento debe ser un numero positivo")
    except ValueError:
        cerrar = input("\n Estas seguro que deseas cerrar el programa? (s/n): ")
        if cerrar.upper()=='S':
            print('Aplicacion cerrada por usuario. Chao')
        elif cerrar.upper()== 'N':
            num=int(input("Ingresa un numero: "))
            print(divisors(num))
            print("Termino mi programa")
            if num<0: 
                raise ValueError("Lo siento debe ser un numero positivo")
        raise KeyError("Debias escribir 's' o 'n'. Se cierra el programa.")

if __name__ == '__main__':  
    run2()

def divisors(num):
    try:
        if num < 0:
            raise ValueError('debes ingresar un numero positivo')
        divisors = []
        for i in range(1, num + 1):
            if num % i == 1:
                divisors.append(i)
        return divisors
    except ValueError as ve:
        print(ve)
        return " "
def divisor(num): 

    divisor = [i for i in range(1, num +1) if num % i == 0]
    return divisor


def run():
    try:
        num = int(input("Escribe un número: "))
        try:
            if num < 0:
                raise ValueError("Debes ingresar números positivo.") 
            print(f'{divisor(num)} \nTerminó mi programa.')
        except ValueError as ve: 
            print(ve)
            return False
    except ValueError:
        print("Solo puedes ingresar números.")  



if __name__ == '__main__':
    run()
def divisors(num):
    try:
        if num < 0:
            raise ValueError("Typing a positive number")

        divisors = []
        for i in range(1, num + 1):
             if num % i == 0:
                divisors.append(i) 
        return divisors

    except ValueError as ve:
        print(ve)
        return False

def run():
   
    try:
        num = int(input("Typing a number:"))
        print(divisors(num))
        print("END program")
    except ValueError:
        print("You must typing a number ")
    

if __name__ == "__main__":
    run()

Este es mi código del reto:

def divisors(num):
    if num < 0:
        raise ValueError("Negative numbers aren't supported")
    divisors = []
    for i in range(1, num + 1):
        if num % i == 0:
            divisors.append(i)
    return divisors


def run():
    try:
        num = int(input("Ingresa un número: "))
        # print(num)
        print(divisors(num))
        print("Terminó mi divisor")
    except ValueError:
        print("Debes ingresar un número positivo")


if __name__ == '__main__':
    run()


Solucion al Reto
saludos!

def divisor(num):
try:
if num < 0 :
raise ValueError (“ingresa un numero positivo”)
divisors = [i for i in range (1, num+1) if num % i == 0 ]
return divisors
except ValueError as ve:
print(ve)
return False

def run():
try:
num = int(input("ingresa un número: "))
print(divisor(num))
print(“termino el programa”)
except ValueError:
print(“No puedes ingresar texto”)

if name == “main”:
run()

Mi solución al reto:

Les dejo mi código para el reto de la clase:

def divisors(num):
    try:
        if num < 0:
            raise ValueError('Debes ingresar un número positivo')
        divisors = []
        for i in range(1, num + 1):
            if num % i == 0:
                divisors.append(i)
        return divisors
    except ValueError as vev:
        print(vev)
        print('Terminó mi programa')
        exit()


def run()
    try:
        num = int(input('Ingresa un número: '))
        print(divisors(num))
        print('Terminó mi programa')
    except ValueError:
        print('Debes ingresar un número')
        print('Terminó mi programa')


if __name__ == '__main__':
    run()

aqui como lo resolvi

ry:
        num = int(input("ingresa un numero: "))
        if num < 0:
            raise NameError('il numero deve essere un numero positivo')
        print(divisors(num))
        print("Termino mi programa")
    except ValueError:
        print("Debes ingresar un numero")
        run()
    except NameError as iii:
        print(iii)
        run()

Por si a alguien también se confundió con el uso de raise, entendí que, para este caso y el del reto, se debe redefinir la función (por ej, divisors) con la excepción “raise” incorporada, no en la función run(), ya que ahí solo está el error try/except definido inicialmente.

Aporte

def divisors(num):
    divisors = []
    try:
        if num < 0:
            raise ValueError("Debes ingresar un numero positivo")
        else:
            for i in range(1,num+1):
                if num % i == 0:
                    divisors.append(i)
            return divisors
    except ValueError as ve:
        return ve


def run():
    try:
        num = int(input("Ingresa un numero: "))
        print(divisors(num))
    except ValueError:
        print("Se debe ingresar un entero")
    

if __name__ == "__main__":
    run()
def divisors(num):
    divisors = []
    for i in range(1, num + 1):
        if num%i == 0:
            divisors.append(i)
    try:
        if num < 0:
            raise ValueError('Ingresa un número positivo')
        return divisors
    except ValueError as NegativeError:
        print(NegativeError)

**Hola chicos este es mi codigo *

def main():    
    try:
        num = int(input("Ingrese un numero:"))
        if num < 0:
            raise TypeError("Ingrese un numero positivo")
        return print([n for n in range(1,num +1) if num % n == 0])

    except TypeError:
        print("Ingrese un numero positivo")
        main()

    except ValueError:
        print("Debes ingresar un numero")
        main()

if __name__ == "__main__":
    main()

Mi solución manteniendo ambas excepciones:

def divisors(num):
    divisors = []
    for i in range(1, num +1):
        if num % i == 0:
            divisors.append(i)
    return divisors


def run():
    try:
        num = int(input("Type a number: "))
        if num < 0:
            raise Exception("Debes ingresar un numero positivo")
        print(divisors(num))
        print("My program has ended")
    except ValueError:
        print("Solo puedes ingresar un numero")
    except Exception as ex:
        print(ex)



if __name__ == '__main__':
    run()

def divisors (num):
divisors = []
for i in range (1,num + 1):
if num % i == 0:
divisors.append(i)
return divisors

def run():

    num = int(input("Ingresa un numero: "))
    try:
        if num < 0:
            raise ValueError ("Ingrese numeros positivos")
        return print (divisors(num))
    except ValueError as PBRError:
        print(PBRError)

if name == ‘main’:
run()

Mi solución al reto 😄

def divisors(num):
    try:
        if num > 0:
            divisors = []
            for i in range(1, num + 1):
                if num % i == 0:
                    divisors.append(i)
            return divisors
        else:
            raise ValueError("you dumb? number must be bigger than 0.")
    except ValueError as message:
        print(message)


def run():
    try:
        num = int(input("Insert a number: "))
        print(divisors(num))
    except ValueError:
        print("You can only use integers.")


if __name__ == '__main__':
    run()

Este es mi aporte añadí un codigo de error para que sea más fácil identificar que fue lo que salio mal en vez de devolver la lista vacia.

def divisors(num):
    try:
        if num < 0:
            raise ValueError("Solo se aceptan números positivos")
        divisors = []
        for i in range(1, num + 1):
            if num % i == 0:
                divisors.append(i)
        return divisors
    except ValueError as ve:
        print(ve)
        return "Code error 1"


def run():
    try:
        num = int(input('Ingresa un número: '))
        print(divisors(num))
        print("Terminó mi programa")
    except:
        print("Debes ingresar un número")

if __name__ == "__main__":
    run()

Hola Platzinautas!

Les dejo mi resolución del reto:

def divisors(num):
    divisor = []
    try:
        if num <= 0:
            raise ValueError('Solo se permiten números positivos')
        for i in range(1, num + 1):
            if num % i == 0:
                divisor.append(i)
        return divisor
    except ValueError as ve:
        print(ve)
        return False


def run():
    try:
        num = int(input('Ingresa un número: '))
        print(divisors(num))
        print('Terminó mi programa.')
    except ValueError:
        print('Debes ingresar un número')

if __name__ == '__main__':
    run()

Mi humilde aporte

def divisors(num):
    divisors_list=[]
    # Excepcion para evitar que usuario ingrese Negativos
    try:
        if num<0:
            raise ValueError("No estan permitidos numeros negativos") 
        
        for i in range(1,num+1):
            if num % i == 0:
                divisors_list.append(i)
    
        return divisors_list
    except ValueError as ve:
        return ve

def run():

    # Excepcion para que evitar que el usuario ingrese valor diferente a numero (letra o palabra)
    try:
        num=int(input("Ingresa un numero: "))
        print(divisors(num))
        print('El programa termino bye!')
    except ValueError:
        print('Debes ingresar un número')



if __name__ == '__main__':
    run()

Este es mi código:

def divisors(num):
    try:
        if num < 0:
            raise ValueError("Ingresa un número positivo")
        else:
            divisors = [i for i in range(1, num +1) if num % i == 0]
        
            return divisors

    except ValueError as ve:
        print(ve)
        return str(num) + " No es un número positivo"


def run():
    try:
        num = int(input("Ingresa un número: "))
        print(divisors(num))
        print("Terminó mi programa")
    except ValueError:
        print("Debes ingresar un número")


if __name__ == '__main__':
    run()
def divisors(num):
    divisors=[]
    for i in range(1,num+1):
        if num % i == 0:
            divisors.append(i)
    return divisors

def run():
    try:    
        num = int(input("Inserte un numero para bucar sus divisores: \n"))
        if num < 0:
            raise ValueError

        print(divisors(num))
        print("Programa finalizado.")
    except ValueError:
        print("Solo se aceptan valores numéricos positivos")


if __name__ == "__main__":
    run()

Esta es mi solución

Solución al reto propuesto

def divisors(num):
    try:
        if num < 0:
                raise ValueError("Debes ingresar un numero positivo")
        divisors = [i for i in range(1,num+1) if num % i == 0]
        return divisors
    except ValueError as ve:
        print(ve)
        return False

def run():
    try:
        num = int(input("Ingrese un numero: "))
        print(divisors(num))
        print("termino mi programa")
    except ValueError:
        print("Debes ingresar un numero")

if __name__ == '__main__':
    run()

def divisor(num):
try:
if num<0:
raise ValueError(“Ingresa un numero positivo”)
else:
divisor = [i for i in range(1,num +1) if num%i==0]
return divisor
except ValueError as value_error:
print(value_error)
return “No es un numero positivo”

def run():
try:
num = int(input("Ingresar un numero: "))
print(divisor(num))
print(“Termino mi programa”)
except ValueError:
print(“Ingresa un numero”)

if name ==“main”:
run()

def run():
    correcto = False
    while correcto == False:
        try:
            numero = int(input('Ingrese un número entero: '))
            if numero <= 0:
                raise ValueError
            divisores = [i for i in range(1, numero + 1) if numero % i ==0]
            print(divisores)
            correcto = True
            print('Fin')
        except ValueError:
            print('Solo números enteros positivos, por favor.')


if __name__ == '__main__':
    run()
def divisor(var):
    try:
        if var < 0:
            raise ValueError('Solo se permite numeros positivos')
        divisors = []
        for i in range(1, var+1):
            if var % i == 0:
                divisors.append(i)
        return divisors
    except ValueError as ve:
        return ve
    


def run():
    try:
        num = int(input('Ingresa un numero: '))
        print(divisor(num))
        print('Termino mi programa')
    except ValueError:
        print('Debes ingresar un numero')


if __name__=='__main__':
    run()
def divisors(num):
#challenge = usa palabras clave try, except, raise para elevar un error 
#si el usuario ingresa un numero negativo en nuestro programa de divisores
    try:
        if num <= 0:
            raise ValueError("No se puede ingresa un numero negativo")
        else:
            divisors = [i for i in range(1,num+1) if num%i ==0]
            return divisors
    except ValueError as ve:
        print(ve)
        return False


def run():
#si el usuario ingresa una letra en nuestro programa de divisores
    try:
        num = int(input("Ingresa el nùmero que deseas: "))
        print(divisors(num))
        print("Termino mi programa")
    except ValueError:
        print("Debes ingresa un nùmero")

if __name__ == '__main__':
    run()

def divisors(num):
    divisors = []
    for i in range(1, num + 1):
        if num % i == 0:
            divisors.append(i)
    return divisors

def run():
    num = int(input("Ingresa un número: "))
    try:
        if (num <= 0):
            raise ValueError("No pueden haber números negativos")
        print(divisors(num))
        print("Terminó mi programa")
    except ValueError as ve:
        print(ve)

if __name__ == '__main__':
    run()

Comparto mi codigo, en este caso agregue para q no se puedan escribir caracteres y el except marque una alerta

<
def divisors(num):
    divisors = []
    try:
        if num < 0:
            raise ValueError
        for i in range(1, num + 1):
            if num % i == 0:
                divisors.append(i)
        return divisors
    except ValueError as ve:
        print("Debes ingresar un numero positivo")
        return False


def run():
    try:
        num = int(input('Ingresa un número: '))
        print(divisors(num))
    except ValueError:
        print("Solo puede Ingresar numeros enteros")
    
    print("Terminó mi programa")


if __name__ == '__main__':
    while true:
        run()> 
#hago un programa de divisores que maneje excepciones si:
#1) El usuario intenta ingresar una letra
#2) el usario intenta ingresar un numero negativo
def divisors(num):
    div_list =[]
    try:
        if(num <=0):
            raise ValueError("El numero debe ser positivo")
        else:
            for i in range( 1 , num+1 ):
                if num % i == 0:
                    div_list.append(i)
    except ValueError as ve:
        print(ve)
    finally:     
        return div_list  

def run():
    try:
        num = int(input("Ingresá un numero y te dire sus divisores: "))
        print( divisors(num) )
    except ValueError:
        print("Debe ingresarse un numero entero")


if __name__== "__main__":
    run()

La forma como resolví

def divisores(num):
    divisors= []
    try:
        if num <0:
            raise ValueError("ingrese un numero positivo")
        else:
            for i in range(1, num +1):
                if num % i ==0:
                    divisors.append(i)
            return divisors
    except ValueError as ve:
       return ve
        
        

def run():
    try:
        num = int(input("Ingresa un numero: "))  
        print(divisores(num))
        print("Termino mi programa")
    except ValueError:
        print("porfavor ingrese un numero no letras ni caracteres")
        print("Termino mi programa")

Reto:

#!/usr/bin/python3.8

def divisors(num):
    divisors = []
    for i in range(1, num + 1):
        if num % i == 0 :
            divisors.append(i)
    return divisors
            
def run():
    try:
        num = int(input("Ingresa un número: "))
        if num < 0:
            raise Exception("El numero debe ser positivo.")

        print(divisors(num))
        print("Termino mi programa.")
    except ValueError:
        print("Debes Ingresar un número.")
    except Exception as nv:
        print(nv)

if __name__ == "__main__":
    run()

<code> 
def divisors(num):

    try:
        if num < 0 :
            raise ValueError("Por favor ingrese un numero positivo")

        divisor = [ i for i in range(1, num + 1) if num % i == 0]
        return divisor

    except ValueError as ve:
            print(ve)

def run():

    try:
        print(divisors(num = int(input("Ingresa un numero:"))))
        print("termino mi programa")

    except ValueError:
            print("Debes ingresar un valor numerico")


if __name__ == '__main__':
    run()

Mi solución

def divisor(num):
    try:
        if num <= 1:
            raise ValueError ("No se pueden ingresar valores negativos, ingresa un número positivo > 0")
    
        # divisor = []
        # for i in range(1, num +1):
        #     if num % i == 0:
        #         divisor.append(i)
        divisor = [i for i in range (1, num+1) if num % i == 0]
        return divisor
            
    except ValueError as ve:
        print(ve)
        return False

def run():

    while True:
        try:
            num = int(input("Ingresa un número: "))
            if num > 1:
                print(divisor(num)) 
                print("Terminó mi programa")
                break
            else:
                 print(divisor(num))
        except ValueError:
            print ("Debes ingresar un número")

if __name__ == '__main__':
    run()

Reto:

Mi reto

Reto Completado. Espero les guste mi codigo y les sea de utilidad. Resaltar que por cada Try pueden existir varios Except

#Programa que calcula los divisores de un numero e imprime mensajes de error cuando
#se inserta un valor que no sea un numero asi como tambien, un valor cuando 
#se ingresa un numero negativo
def divisors(num):
    divisors = [i for i in range(1, num+1) if num % i==0]
    return divisors

#Es importante saber que pueden existir varios "except" por un solo "Try". En este caso usaremos dos "except"
def run():
    try:
        print("Programa que calcula los divisores de un numero")
        value_entry = int(input("Ingrese un numero: "))
        if value_entry <= 0:#Condicion si insertan un numero negativo
            raise Exception("Solo debes ingresar numeros positivos")#Error cuando existe un numero negativo
    except ValueError:#Error cuando se inserta algo queno sea una letra
        print("Debes ingresar un numero")
    except Exception as ve:#Error cuando se da la condicion de insertar un numero negativo
        print(ve)  
    else:        
        print(divisors(value_entry))

    

if __name__== '__main__':
    run()
def divisors(num):
  divisors = []
  try:
    if num - int(num) != 0:
      raise ValueError('Ingrese solo enteros')

    elif num < 0:
      raise ValueError('Solo ingrese número positivos')

    else:
      num = int(num)
      for i in range(1,num+1):
        if num % i == 0:
          divisors.append(i)
      return divisors

  except ValueError as ve:
    print(ve)
    return 'Reto cumplido'
    
def run():
  try:
    num = float(input('Ingresa un número: '))
    #if num < 0:
    #  raise ValueError('Ingrese solo número positivos')
    print(divisors(num))
    print('Terminó el programa')
  except ValueError:
    print('Ingrese solo números')


if __name__ == '__main__':
  run()

Yo utilice una condiciona y SyntaxError pirque ValueError no me mostraba mi raise.

def divisors(nums):
    divisors=[]
    for i in range(1,nums+1):
        if nums%i==0:
            divisors.append(i)
    return divisors

def run():
    try:#Intentar
        nums=int(input("Digita un numero: "))
        if nums<0:
            raise SyntaxError ("No numeros menores a cero.")
        print(divisors(nums))
        print("Termino el programa")
    except ValueError:#Si sucede algo mal.
        print("Ingresa numeros ***NO*** letras.")
if __name__=='__main__':
    run()

def divisors(num):
divisors = []
for i in range(1, num + 1):
x = num % i
if num % i == 0:
divisors.append(i)
return divisors

def run():
try:
num = int(input('Ingresa un número: '))
if num < 0:
raise AssertionError
print(divisors(num))
print(“Terminó mi programa”)
except ValueError:
print(‘Error… Se debe ingresar un número’)
# Uso este error (AssertionError) con el fin de separar
# los mensajes.
except AssertionError:
print(‘Error… Sólo números positivos’)

if name == ‘main’:
run()

Mi aporte + un ciclo para seguir pidiendo información si es que esta estuvo incorrecta.

def divisors(num):
    try:
        if num < 0:
            raise ValueError("Ingresa un numero positivo")

        return [i for i in range(1, num + 1) if num % i == 0]

    except ValueError as ve:
        print(ve)
        return False

def run():
    while True:
        try:
            num = int(input("Ingresa un numero: "))
            print(divisors(num))

            print("Se acabo el programa")

        except ValueError:
            print("Debes ingresar un numero")

if __name__ == '__main__':
    run()
def divisors(num):
    try:
        if num < 0:
            raise ValueError("No se debe ingresar numeros negativos")
        
        divisors = []
        for i in range(1,num + 1):
            if num % i == 0:
                    divisors.append(i)
        return divisors        
    except ValueError as ve:
        print(ve)
        return

Validando con el ejercicio de palindromo:

  1. Que la cadena no venga vacia
  2. Que no digite numeros
def palindromo(string):
    string = string.replace(' ', '')
    string = string.lower()
    string_inverso = string[::-1]
    if string == string_inverso:
        return True
    else:
        return False


def run():
    string = str(input("Digita la palabra: "))
    while string == "":
        print("La cadena no puede estar vacia")
        string = str(input("Digita la palabra: "))
        while string.isalnum():
            print("Debes escribir una cadena de caracteres")
            string = str(input("Digita la palabra: "))
    es_palindromo = palindromo(string)
    if es_palindromo == True:
        print("Es palíndromo")
    else:
        print("No es palíndromo")



if __name__ == '__main__':
    run()

Una Locura, de verdad que he aprendido montones!!!

Yo lo hice así pero el uso del raise no lo tengo entendido al 100%

def run():
try:
num=int(input("Ingresa un un número: "))
if num <0:
raise (“El número tiene que ser positivo”)
else:
divisiors = [numero for numero in range(1,num+1) if num%numero==0]
print(divisiors)
except ValueError:
print(“Debes Ingresar un número”)

if name == ‘main’:
run()

# RETO

def divisors(num):
    try:
        if num<  0:
            raise ValueError('Debes ingresar un número positivo')
        divisors = []
        for i in range(1, num+1):
            if num%i == 0:
                divisors.append(i)
        return divisors        
    except ValueError as ve:
        print(ve)
        return False    
def run():
      try:
        num = int(input('Ingresa un número: '))
        print(divisors(num))
        print('Termino mi programa') 
      except ValueError:
          print('Debes ingresar un número')

if __name__ == '__main__':
    run()

COMPLETITO

def divisors(num):
    divisors=[]
    while True:
        try: 
            if num<0:
                raise Exception
            for i in range(1,num+1):
        
                if num%i==0:
           
                    divisors.append(i)
            break            
        
        except Exception:
            num=int(input("you have to enter only positive numbers, please enter a number"))
    
    return divisors

def run():
    while True:

        try:
            num=int(input("enter a number"))
                          
            print(divisors(num))
        
            print("Terminó")

            break
        
        except ValueError:
            print("Only can enter numbers")
    

if __name__=='__main__':
    run()

def divisors(num):
try:
if num < 0:
raise ValueError(“ingresa un número positvo”)
divisors = []
for i in range(1, num + 1):
if num % i == 0:
divisors.append(i)
return divisors
except ValueError as ve:
print(ve)
return False

def run():
try:
num = int(input('Ingresa un número: '))
print(divisors(num))
print(“Terminó mi programa”)
except ValueError:
print(“Debes ingresa un número”)

if name == ‘main’:
run()

no se si me quedo bien 😕

def divisors(num):
    divisors = []
    for i in range(1, num + 1):
        if num % i == 0:
            divisors.append(i)
    return divisors


def run():
    try: 
        num = int(input('Ingresa un numero: '))
        print(divisors(num))
        print('Termino mi programa')
    except ValueError:
        print('Debes de ingresar un numero')
    if num <= 0:
        print('Debes de ingresar un numero positivo')




if __name__ == '__main__':
    run()
def divisors(num):
    divisors = []
    for i in range(1, num + 1):
        if num % i == 1:
            divisors.append(i)
    return divisors


def run():
    try:
        num = int(input('Ingresa un número: '))
        print(divisors(num))
        print("Terminó mi programa")
        if num < 0:
            raise ValueError ("ingresa un numero positivo")
    except ValueError:
        print("debes ingresar un numero")

Mi aporte

solución al problema de excepciones

#!/usr/bin/env python3

def divisor(n: int) -> int:
    divisors = []
    for i in range(1, n + 1):
        if n % i == 0:
            divisors.append(i)
    return divisors




def main():
    try:
        n = int(input('Ingrese un numero: '))
        if n < 0:
            raise ValueError('Tiene que ser un positivo')
        print(divisor(n))
        print('\ntermino el programa')
    except ValueError as ve:
        print(ve)

    
if __name__ == '__main__':
    main()

![](

Ya quedo el programa!

Reto cumplido. Aquí el código:

def divisors(num):
    #divisors = [i for i in range(1, num+1) if num % i == 0]
    divisors = []
    try:
        if num == 0:
            print("0 tiene infinito número de divisores. Todos los número son divisores de 0.")
            return True
        elif num < 0:
            raise ValueError("Debes ingresar un número positivo.")
        for i in range(1, num+1):
            if num % i == 0:
                divisors.append(i)
        return divisors
    except ValueError as ve:
        print(ve)
        return False

def run():
    try:
        num = int(input("Ingresa un número: "))
        print(divisors(num))
        print("Terminó mi programa")
    except ValueError:
        print("No valido. Ingresar solo números.")


if __name__ == '__main__':
    run()
def divisors(num):
    divisors=[]
    for i in range(1,num+1):
        if num % i == 0:
            divisors.append(i)
    return(divisors)


def run():
    try:
        num=int(input('Type a number:'))
        if num <= 0:
            raise ValueError('Please write a positive integer')           
        return print(divisors(num))
    except ValueError as ve:
        print(str(ve) + ' You should type a number')
        

if __name__ == '__main__':
     run()