Assert statements

A mi me gusta bastante la definicion que nos da Al Sweigart en su libro “How to automate the boring stuff with Python” se las comparto:

In plain English, an assert statement says, “I assert that this condition holds true, and if not, there is a bug somewhere in the program.” Unlike exceptions, your code should not handle assert statements with try and except; if an assert fails, your program should crash. By failing fast like this, you shorten the time between the original cause of the bug and when you first notice the bug. This will reduce the amount of code you will have to check before finding the code that’s causing the bug.Assertions are for programmer errors, not user errors. For errors that can be recovered from (such as a file not being found or the user enter-ing invalid data), raise an exception instead of detecting it with an assertstatement.

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

def run():
    num = input('Enter a number: ')
    assert num.isnumeric() and int(num)>0, 'Ingresa solo numeros positivos'
    print(divisor(int(num)))
    print('Finish')


if __name__ == '__main__':
    run()

Lo que pude aprecir es que el metodo isnumeric() solo cuando es un numero entero positivo del resto develve false, asi que no hay necesidad de evaluar di el numero es ingresado es negativo ya la isnumeric lo hace por nosotros:
![](

Assert statements

• Es una manera poco usual de manejar los errores en python
• Evalúa una condicional, si esta se cumple continuamos con el flujo normal del python, si no se cumple eleva un error del tipo AssertionError y nos muestra un mensaje.
• Su sintaxis es:

assert <condicion>, <"mensaje">
<código>

No es necesario introducir nuevo codigo para el desafio del profesor ya que el metodo “.isnumeric” solo reconoce como strings numericos aquellos que solo tienen numeros. No acepta signos como el “-”. Por ello cualquier numero negativo será rechazado por el mismo assert statement que el que rechaza las letras y palabras:

.
Cuando usamos assert además de imprimirse el mensaje de error que escribimos, se muestra también todo el TRACEBACK

.
En cambio, cuando usamos try-except solo se muestra el mensaje de error que escribimos en el código

De acuerdo a lo que dice la documentación de VsCode, isNumeric devuelve True si todos los caracteres son números. Por lo tanto, un número negativo no cumple con esta condición, devolviendo False.
En conclusió, no es necesario realizar el análisis para números negativos porque ya se está verificando
Solo basta agregar en el mensaje que debe ingresar números y que sean mayores a cero

Mi solución

def run():
    num = input('Ingresa un número: ')
    assert int(num) > 0, "Ingresa números mayores a 0"
    assert num.isnumeric(), "Ingresa números"
    print(divisors(int(num)))
    print('Finalizo')

Mi solución al reto de la clase:

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


def run():
    print('*** CALCULAR DIVISORES **\n')

    num = input(':: Escribe un número: ')

    error_msg = """
    ⚠ Ingresaste una opción incorrecta
    Las únicas opciones validas son números mayores a 0
    NO puedes ingresar LETRAS o NÚMEROS NEGATIVOS
    """
    assert num.isnumeric() and int(num) > 0, error_msg

    print(divisors(int(num)))

    print('\nFin del Programa')


if __name__ == '__main__':
    run()

<def divisor(num):
    divisors =[i for i in range(1, num + 1) if num % i == 0]
    return divisors
    
def run():
    num = input(f'Ingresa un número: ') 
    assert num.isnumeric() > 0, "ingresa un número positivo"      
    print(divisor(int(num)))
    print("termino mi programa")

    
if __name__ =='__main__':
    run()> 

Lo deje como lo resolvimos en clase porque al ponerle el signo de negativo el isnumeric detecta al simbolo como un caracter que no puede convertir en entero y por ende no hace falta validar si los numeros son positivos, quedan verificados dentro del mismo assert.

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

def main():

    num = input("Ingrese un numero: ")
    assert num.isnumeric(), "Debes ingresar un número entero positivo."
    print(f"Los divisores de {num} son:{divisors(int(num))}")

if __name__ == '__main__':
    main() 

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

def run():

    num = input("Ingresa un numero:")
    assert num.isnumeric() and int(num) > 0, "Debes ingresar un numero positivo."
    print(divisors(int(num)))
    print('El programa ha termindo')

if __name__ == '__main__':
    run()

📚 assert condition, error message
Se lee como.

"Afirmo que esta condición es cierta, de lo contrario, manda este mensaje de error.

🤔 Los assert statements nos permiten manejar errores mediante expresiones, esto permite reducir líneas de código del proyecto.

Las assert statements son a los try / except lo que las lambda functions a las def functions. No tienen un nombre, son anónimas y se pueden escribir en una sola línea que define un evento en particular

reto
assert num.isnumeric(), ‘Ingresa solo numeros positivos’

de hecho la misma linea de código del ejemplo sirve para evitar que el usuario ingrese números negativos ya que la función isnumeric() devuelve true solo si TODOS los caracteres del string son númericos… por lo tanto al ingresar un signo “-” esta función devolverá false

En JavaScript los asser se pueden usar para debuggear cuando la aplicación está en desarrollo y ver si en algún momento los parámetros que le entran a la función se varían de los que esperamos creo que en python también sería un buen uso.

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


def run():
    num =input('Ingresa un numero: ')
    assert num.isnumeric() and int(num) > 0, "Debes ingresar un numero positivo" 
    print(divisor(int(num)))
    print('Termino mi programa')


if __name__=='__main__':
    run()

    num = input('Ingresa un número: ')
    assert num.isnumeric(), 'Debes ingresar un número'
    assert int(num) > 0, 'Debes ingresar un número mayor a 0'
    print(divisors(int(num)))

# 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():
   num = input('Enter a number to know the divisors: ')
   assert num.isnumeric() and int(num) > 0, 'You need to enter a positive numbers'
   div = divisors(int(num))
   print('Divisors of', num)
   for i in div:
      print(i)
   print('Program Finished!')

if __name__ == '__main__':
   run() 

Tuve que ponerle un lstrip(’-’) para poder combinarlo con lo presentado en el curso ya que isnumeric sólo devuelve true si son números positivos, sino devolverá false porque el " - " no es numérico para esa función, deben haber otras formas tan sencillas o complejas como por ejemplo probar con el try except si se puede hacer alguna operación matemática y dependiendo de eso podriamos recurrir a una excepción u otra para continuar con assert.

   num = input("Ingresa un número: ")

    assert num.lstrip('-').isnumeric(), "Debes ingresar un número"
    assert int(num) > 0, "Debes ingresar un número positivo"

    print(divisors(int(num)))
    print("Terminó mi programa")

Desarrollo del reto:

def divisors(num):    
    divisors = []
    for i in range(1,num+1):
        if num%i == 0:
            divisors.append(i)
    return divisors
   
    
def run():   
    num = input ("ingrese el número: ")
    assert num.isnumeric() and int(num)>=0,"Por favor ingrese solo números positivos"
    print (divisors(int(num)))
    print("Fin del programa")
  

if __name__ == "__main__":
    run() 

Así los convine

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: '))
        assert num >= 0, "Debes ingresar un número positivo"
        print(divisors(int(num)))
        print("Terminó mi programa")
    except ValueError:
        print('Sólo puedes ingresar números enteros')

if __name__ == '__main__':
    run()

Les comparto como resolví el reto. 😄
En mi primera versión utilize el metodo value.isnumeric() para comprobar si era número o texto, pero viendo otros aportes como el de alexander cambie a not(value.isalpha())

• .isnumeric() : no considera a los negativos como numeros
• .isalpha() : si hay un número no lo considera texto

divisores = lambda num: [div for div in range(1,num+1) if num % div == 0]

def run():
  value = input("Digite un numero: ")
  assert not(value.isalpha()), "Solo se permite digitar numeros"
  assert int(value) > 0, "Digite un numero positivo"
  print(divisores(int(value)))

if __name__ == '__main__':
  run()

Considerando que tenia que devolverme una lista, decidí usar el lambda y ahorrar unas cuantas líneas de código.
Espero les halla servido mi aporte, para entender un poco mas como mezclar lo que estamos aprendiendo. 😁

Mi aporte

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


def run():

    num = input('Ingresa un número: ')

    assert int(num) > 0, 'Debes ingresar un entero positivo'
    assert num.isnumeric() , 'Debes ingresar un numero'
    print(divisors(int(num)))
    print("Terminó mi programa")

if __name__ == '__main__':
    run()

Aquí mi aporte:

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

def run():


    num = input('Ingresa un número: ')
    assert num.isnumeric() and int(num) > 0, 'Debes ingresar un número que sea positivo diferente de CERO'
    print(divisors(int(num)))
    print('Terminó mi programita')



if __name__=='__main__':
    run()

Assert statements / Afirmaciones
Expresiones que combinan variables con operadores.
Maneja el flujo del programa, código(true) o error(false).
assert(afirmo) condición(true), mensaje de error(false)
.isnumeric()

Creo que usar Try - Except es mejor opción para controlar el flujo del programa, quiero decir que podemos seguir con el flujo del programa, aún si el error es lanzado, diferente a “assert”, que nos detiene el programa.

El reto de validar los número negativos, debe controlar que permita introducir el valor del signo negativo, para ello al comprobar si es numérico previamente se debe reemplazar el signo menos por cadena vacia y luego validar si es positivo

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


def run():
    num = input('Ingresa un número: ')
    assert num.replace("-","").isnumeric(), "Debes ingresar un número"
    assert num >= 0, "Debes ingresar un número positivo"
    print(divisors(int(num)))
    print("Terminó mi programa")


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("Ingresa un número: "))
        list_divisors = divisors(num)
        if list_divisors == []:
            raise Exception("Debes ingresar un número entero positivo.")
        print(list_divisors)
    except ValueError:
        print("Debes ingresar un número entero.")
    except Exception as exc:
        print("¡Error!", exc)

    print("Terminó mi programa")


if __name__ == '__main__':
    run()

isnumeric() retorna TRUE solo cuando tenemos números positivos, luego no hay necesidad de hacer otro assert o colocar algun condicional if sobre lo que se esta ingresando

No hay forma de hacer las dos comprobaciones en el mismo assert?

def divisors(num):

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

def run():

    num=input('Meteme un numero: ')
    assert num.isnumeric(), 'Se deve ingresar un numero'
    assert num<=0, 'Se deve ingresar un numero positivo mayor a 0'
    print(divisors(int(num)))
    print('Termine')

if __name__=='__main__':
    run()

Hola a todos

mi aporte:

def divisors(num):
    divisors = []

    assert num<0, "ingrese un numero positivo"

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



def run():
           
    num = input("ingrese un numero: ")
    assert num.isnumeric(), "debes ingresar un numero"
    print(divisors(int(num)))
    print("termino el programa")
    print("debes ingresar un numero")


if __name__ == '__main__':
    run()

con la funcion isnumeric se encuentra solución directamente al reto, ya que esta solo toma los números nada mas. Es decir que cualquier otro símbolo lo va a tomar como no numérico, sin embargo quise darme la tarea de completar el reto manejando de forma independiente ambos errores. Ya que quería la opción de poner mensajes específicos para cada situación.
al hacerlo de esta manera me encontré con varias barreras, la primera era que al poner 2 assert seguidos un para el valor numérico y el otro para las letras, esto me generaba error para una de las 2 opciones.
Al tratar de corregir esto usando try-except me encontré con el segundo problema, cuando utilizas un assert dentro de un try-except este no se ejecuta.
Después de muchos ensayos y de revisar diferentes formas del codigo con la herramienta de debugging,
se me ocurrió la siguiente solución:

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

def run(): 
    num = input('Escribe un numero para sacar sus divisores: ')

    if num.isnumeric():
        print(divisors(int(num)))

    else:
        try:
            num = int(num)
        except:
            return print("No debes ingresar letras o caracteres")
    
        
        assert num > 0, "Debes ingresar un numero positivo"
        

if __name__ == '__main__':
    run()

Hola todos.

Comparto mi aporte.
Ya que isnumeric funciona para validar numeros enteros positivos, solo cambie el mensaje mencionando que debe ingresar numeros enteros y positivos.

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

def run():
        num = input('Ingresa un numero: ')
        assert num.isnumeric(), "Debes ingresar un Numero positivo"
        print(divisors(int(num)))
        print("Termino el programa")

if __name__ == '__main__':
    run()

El metodo isnumeric() considera a los negativos como que no son números. Por lo que el algoritmo ya lo hace asi como esta. Seria agregar al mensaje ‘Debes agregar un numero positivo’.

Fuente: https://www.w3schools.com/python/ref_string_isnumeric.asp

Les dejo un ejemplo de como usar assert con try and except, un adicional que agrego es el KeybordInterrupt para que el usuario no pueda salir del programa con control c. Espero les sirva

def user():
    try:
        x = input('Tell me a number between 1 and 10: ')
        if int(x) not in range(1,11):
            assert False
        else:
            return x
    except KeyboardInterrupt:
        print('\nDude You just type a number then you leave...')
        return user()
    except ValueError:
        print('You shoul type a number pal...')
        return user()
    except AssertionError:
        print('You should type a number between 1 and 10...')
        return user()

def run():
    return print(user())

if __name__ == '__main__':
    run()

Nunca se sabe cuando se necesite ser más específicos con los mensajes de cara al usuario, creo que aunque el método .isnumeric() valide también lo solicitado en el reto, podríamos no estar evidenciando qué fue exactamente lo que pasó, por ejemplo podría haber sido un carácter de texto, y también tiraría un False, pensando en esto, implementé ambas validaciones para mostrar el error en específico, con try,except valido que se ingrese un valor numérico, y con assert que sea positivo (mayor a 0 en mi caso)

def run():

    user_input = input("Ingresa un número: " )

    try:

        number = int(user_input)
        assert number > 0, "Intenta con un número positivo, mayor a cero"
        
        print(divisors(number))

    except ValueError as e:
        print(e)
        print("Ingresa sólo números")
    
    finally:
        print("Terminado")

RETO

def divisors(num):
    assert num > 0, "El numero debe se un entero positivo"
    divisors = [i for i in range(1, num + 1) if num % i == 0]
    return divisors


def run():
    num = input("Ingrese un numero: ")
    assert num.isnumeric(), "Debes ingresar un numero"
    print(divisors(int(num)))
    print("Termino mi programa ")


if __name__ == "__main__":
    run()

La palabra clave de declaración de Python prueba si una condición es verdadera. Si una condición es falsa, el programa se detendrá con un mensaje opcional. Las declaraciones de afirmación se utilizan para depurar código y manejar errores. No debe utilizar una declaración de aserción en un entorno de producción.

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: "))
assert num > 0, "Debes ingresar un número positivo"
print(divisors(num))
print(“terminó mi programa”)

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 = (input("ingresa un numero"))
    assert num.isnumeric()  and int(num)<0,"ingresa solo numeros positivo"
    print(divisors(int(num)))
    print("termino mi programa: ")

if __name__ == '__main__':
    run()

def divisor(num): 

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


def run():
    num = input("Escribe un número: ")
    assert int(num) > 0, "Debes ingresar un número positivo"
    print(f'{divisor(int(num))} \nTerminó mi programa.') 


if __name__ == '__main__':
    run()

def divisors(num):
    assert num>0, "Tienes que ingresar un numero positivo"
    divisor=[i for i in range(1,num+1) if num%i==0]
    return divisor

def run():
    num=input("Ingresa el número: ")
    assert num.isnumeric(), "Tienes que ingresar un numero"
    print(divisors(int(num)))
    print("Terminó el programa")

if __name__=="__main__":
    run()

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


def run():
    num = input('Ingresa un número: ')
    assert num.replace('-','').isnumeric(), 'Debes ingresar un número'
    
    num = int(num)
    assert num > 0, 'El número ha de ser más grande de 0'

    print(divisors(num))
    print('Terminó el programa')
    

if __name__ == '__main__':
    run()

Solución al reto en Github:

# Based on file ../debug/debugging.py
# File on https://github.com/FernandoTorresL/Curso_Python_Intermedio/blob/main/asserts/asserts_statements.py
def divisors(num):
    divisors = []

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

def run():
    num = input("Ingresa un número: ")

    assert num.isnumeric(), "Debes ingresar un número positivo"
    assert int(num) > 0, "Debes ingresar un número positivo"

    print(divisors(int(num)))
    print("Terminó mi programa")


if __name__ == '__main__':
    run()

Mi código del reto:

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


def run():
        num = (input("Ingresa un número: "))
        assert num.isnumeric() and int(num) > 0, "Debes ingresar un número positivo"
        print(divisors(int(num)))
        print("Terminó mi programa")


if __name__ == '__main__':
    run()

utilice los 2 tipos de errores este seria mi codigo

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

def run():
    try:
        num = input("ingresa un número: ")
        assert num.isnumeric()
        assert int(num) > 0
        print(divisor(int(num)))
        print("termino el programa")  
    except AssertionError:
        print("no puedes ingresar texto ni numero negativos")

if __name__ == "__main__":
    run()

Tuve varios problemas por que .isnumeric() considera ‘-’ como un cararcter despues investigar un poco encontre una .funcion para ayudarme con eso la cual fue .lstrip() con la cual se omite al caracter, asi un numero negativo sigue siendo un numero.

def divisors(num):
    divisors = []

    assert num > 0, "A Natural number must be entered"
    for i in range(1, num + 1):
        if num % i == 0:
            divisors.append(i)
    return divisors


def run():
    num = input("Type a number: ")
    assert num.lstrip('-').isnumeric(), "A number must be entered"
    num = int(num)
    print(divisors(num))
    print("Program ends")
        

if __name__ == '__main__':
    run()

Aporte: Le agregue en el assert para que también cumpla la condición de que sea estrictamente mayor a cero.

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


def run():
    num = input("Ingresa un numero: ")
    assert num.isnumeric() and int(num) > 0, "Debe ingresar un numero positivo no cero"
    print(divisors(int(num)))
    

if __name__ == "__main__":
    run()

Si se usa assert es bueno complementarlo con un try ... except para manejar un posible AssertionError y dejarlo “más bonito”

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


def run():

    try:
        num = input('Enter a number: ')
        assert num.isnumeric() and int(num) > 0, "Only positive numbers are valid"
        print(f'\nDivisors of {num} are: {divisors(int(num))}')

    except AssertionError:
        print('\nOnly positive numbers are valid')

if __name__ == '__main__':
    run()

def divisors(num):
    divisors = []
    assert num > 0, 'Ingresa un número positivo'
    for i in range(1, num + 1):
        if num%i == 0:
            divisors.append(i)
    return divisors

Mi aporte al reto de la clase:

def divisors(num):
    try:
        assert num >= 0, 'Debes ingresar un número positivo.'
        divisors = [i for i in range(1,num+1) if num%i == 0]
        return divisors
    except ValueError:
        print('Error en el código.')
        return [0]

def run():
    num = input('Ingresa un número: ')
    assert num.lstrip('-').isnumeric(), 'Deben ingresar un número.'
    print(divisors(int(num)))
    print('Termina el programa')
    
if __name__=='__main__':
    run()

Utilizo la función .lstrip() de un string para reemplazar el signo del guión (-) cuando ingreso un número negativo.
Resulta que la validación .isnumeric() no deja pasar a la función divisors porque esta validación detecta si todos los caracteres en la cadena son numéricos, y el guión no lo es.

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

def run():
num = input("Ingresa un numero: ")
assert num.isnumeric() > 0, "Debes ingresar un numero positivo"
print(divisors(int(num)))
print(“Termino mi programa”)

if name == ‘main’:
run()

Mi reto

Explicacion

La combinacion de assert statements con try, except y else statements funciono satisfactoriamente mejor al uso de try, except y else statements por si solos. La funcion isnumeric() resulto “fotografiar 3 pajaros en una toma”, ya que retorna False cuando la entrada no es numerica, no es numero positivo o esta vacia, arrojando el AssertionError. Todo en uno.
.
El assert statement es manejado con except para imprimir un mensaje mas sofisticado que funciona para todos los casos posibles de entradas invalidas.
Ademas el codigo se vio considerablemente reducido usando assert statements en combinacion con try, except y else statements en comparacion al codigo del reto anterior:

Solucion al reto:

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

def run():
    num = input("Ingrese un numero: ")
    assert num.isnumeric() and int(num)>0, "Debes ingresar un numero entero positivo."
    print(divisors(int(num)))
    print("termino mi programa")      
    

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('Ingresa un número: '))
        assert (num) > 0, 'Debes ingresar un número mayor a 0 flipa0'
        print(divisors(num))
        print("Terminó mi programa")
    except ValueError:
        print('Debes ingresar un numer0 flipa0')


if __name__ == '__main__':
    run()

Aqui mi codigo:

def run():
    
        num = input("Ingresa un numero: ")
        assert not(num.isalpha()), "Debes ingresar numero"
        assert int(num) > 0, "Debes ingresar numero positivo"
        print(divisor(int(num)))
        print("Terminado")

This my challenge !! 😄

def divisors(num):
  assert num > 0 , "Error, Please enter a number positive"
  divisors = [i for i in range(1, num + 1) if num % i == 0]
  return divisors


def run():
  num = input("Insert a number: ")
  assert num.isnumeric(), "Error, Please enter a number"
  print(divisors(int(num)))
  print("I finish my program")


if __name__ == '__main__':
  run()

Solución del reto:

def divisor(var):
    assert var > 0, 'Solo se permite numeros positivos'
    divisors = []
    for i in range(1, var+1):
        if var % i == 0:
            divisors.append(i)
    return divisors
    
def run():
    num = input('Ingresa un numero: ')
    assert num.lstrip('-').isnumeric(), 'No se pueden escribir strings'
    print(divisor(int(num)))
    print('Termino mi programa')
    
if __name__=='__main__':
    run()

Según lo que probé, el método isnumeric() solo acepta como números desde el 0 en adelante, no hay necesidad de evaluar si es negativo ya que la función lo hace automáticamente. Por eso hice que mejor evaluara que tiene que ser un numero diferente de 0. Aquí el código

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

def run():
    num = (input("Ingresa un número: "))
    assert num.isnumeric() and int(num) != 0, "Debes ingresar un número entero positivo y que sea diferente de 0"
    print(divisors(int(num)))
    print("Terminó mi programa")
        
if __name__ == "__main__":
    run()

Reto 💯

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

def run():
        num = input("Ingresa un número: ")
        assert num.isnumeric() > 0, "Solo se admite valores númericos positivos"
        print(divisors(int(num)))
        print("Termino mi programa")
            
        
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 = input('Ingresa un número: ')
# assert genera una condicion si no la cumple muestra un mensaje en consola tipo error
# agregamos una segunda condicion a assert que indica si numero debe ser mayor a 0
# no permite númerosnegativos-3
assert num.isnumeric() and int(num) > 0 ,"Solo se permiten números positivos"
print(divisors(int(num)))
print(“Terminó mi programa”)

if name == ‘main’:
run()

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

def run():
        num = input("Ingresa el nùmero que deseas: ")
        #verifica si el string es un numero o un numero positivo, de lo contrario lanza error msg
        assert num.isnumeric() or num.isdigit(), "Debes introducir solo numeros positivos"
        print(divisors(int(num)))
        print("Termino mi programa")

if __name__ == '__main__':
    run()

Ni modo que el usuario tenga que leer toda la traza del error para al último leer que tiene que ingresar un número.
Queda claro que el assert statements es para el programador y no para el usuario.

Reto

def divisors(num):
    divisors = []
    for i in range(1, num + 1):
        if num % i == 0 :
            divisors.append(i)
    return divisors
            
def run():
        num = input("Ingresa un número: ")

        assert num.isdecimal(), "Debes de ingresar un numero positivo."
        print(divisors(int(num)))
        print("Termino mi programa.")

if __name__ == "__main__":
    run()

Assert challenge

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

def run():
    num = input("ingresa un número: ")

    # -- ASSERT STATEMENT -- 
    # método de los string isnumeric(), devuelve verdadero si el valor ingresado es tipo numérico y False si no lo es
    # nota, para que el método funcione, es recomendable eliminar int en la variable num en el input
    assert num.isnumeric() and int(num) > 0, "Se debe ingresa un número positivo" 
    
    print(divisors(int(num))) # aqui si se castea la variable num 
    print("Terminó mi programa")


if __name__ == "__main__":
    run()

Saludos 😃

Reto completado.
Aclarar que con el mismo metodo isnumeric() se puede validar si un numero es positivo y esto es debido a que dicho metodo no admite signos como por ejemplo el guion o el punto, en este caso los devuelve false, por lo tanto con el mismo metodo validamos que el usuario siempre ingrese un numero y a su vez que ese numero sea positivo.

PD: Me disculpan si coloco muchos comentarios en el codigo

#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
#Con assert confirma la expresion y despues de la coma va lo que queremos que haga siempre que la expresion sea False
def run():
    print("Programa que calcula los divisores de un numero")
    value_entry = input("Ingrese un numero: ")
#El metodo isnumeric se usa para verificar si un caracter o cadena de caracteres es un numero o no, Este metodo no admite signos
# En este caso si colocaramos (-30) como ejemplo nos daria false porque aunque 30 es un numero al colocarle
# el guion de negativo, el metodo nos devolveria false.   
    assert value_entry.isnumeric(), "Debes ingresar un numero positivo"
    print(divisors(int(value_entry)))
            
    
if __name__== '__main__':
    run()

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

def run():
        #quitamos el int
        nums=int(input("Digita un numero: "))
        assert nums>0, ("Ingresa numeros positivos")
        '''
        Todo numero  mayor a cero(nums>0) se imprimiran, 
        por el contrario(menor a cero) saldra el error ("Ingresa numeros positivos")
        '''
        
        print(divisors(nums))#convertimos el nums en int de nuevo. 
        print("Termino el programa")

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: '))
assert num > 0
print(divisors(num))
print(“Terminó mi programa”)
except ValueError:
print(‘Error… Se debe ingresar un número’)
# Usado así, con ‘AssertionError’ sólo aparece el mensaje que se desea.
except AssertionError:
print(‘Error… Sólo números positivos’)

if name == ‘main’:
run()

Traducción al texto en inglés de abajo:
“En lenguaje llano, una sentencia assert dice: “Afirmo que esta condición es verdadera, y si no es así, hay un error en alguna parte del programa”. A diferencia de las excepciones, su código no debería manejar las sentencias assert con try y except; si una assert falla, su programa debería fallar. Al fallar rápidamente de esta manera, acorta el tiempo entre la causa original del fallo y el momento en que lo nota por primera vez. Esto reducirá la cantidad de código que tendrá que comprobar antes de encontrar el código que está causando el fallo.Las aserciones son para los errores del programador, no para los errores del usuario. Para los errores que pueden ser recuperados (como un archivo que no se encuentra o el usuario que introduce datos no válidos), lanza una excepción en lugar de detectarlo con una aserción.”

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

Bueno, esta es mi forma de resolver el reto para que solo permita enteros positivos.

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: '))
    assert num > 0, "debes ingresar un entero positivo"
    print(divisors(num))
    print("termino el programa")

if __name__ == '__main__':
    run()

Quería poder aplicar ambas condiciones de que sea un entero positivo y solo números, pero me complique jaja seguiré investigando.

Chicos, para que solo con assert les salga el mensaje diferenciado por error hice lo siguiente

def run():
    
    num = input("Ingresa un número: ")
    assert num.isnumeric() or num[-1:].isnumeric(), "Debes ingresar un número"
    
   
    assert int(num) >= 0, "El número debe ser positivo"
    
    
    print (divisors(int(num)))
    print ("Terminó mi programa")
        
   


if __name__ == "__main__":
    run ()

de esta manera primero chequeamos si es un numero, y luego chequeamos si es negativo, lo que hago es evaluar la string entera o sin su primer caracter ya que “-” hace que isnumeric () de Falso

Se ve elegante

En esta pregunta en Stack encontré en la primera respuesta una información que explica donde usar los assert 😃

https://es.stackoverflow.com/questions/159817/que-hace-la-función-assert

VERIFIQUE LA EJECUCION CON NUMEROS NEGATIVOS, PERO EL METODO “ISNUMERIC” ME DEVUELVE FALSE CUANDO INGRESO NUMEROS NEGATIVOS

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


def run():
        
    num = input('Ingrese un numero: ')
    assert num.isnumeric(), "debes ingresar un numero positivo"
    print(divisor(int(num)))
    print("Termina mi programa")
  

if __name__ == '__main__':
    run()> 

Si bien la función isnumeric() retorna como False aquellas cadenas que incluyan un + o - (lo que puede ser suficiente), podemos usar lstrip() para retirar estos caracteres y así poder evaluar el número en la primera función. Esto puede ayudar para aquellos casos en el que se permita “-3” o “+4” como entradas válidas.

def divisors(num) -> list:
    assert num > 0, f"Given number '{num}' is not a positive or greather than '0' number"
    divisors = [i for i in range(1, num+1) if num % i == 0]
    return divisors

def run():
    num = input("Divisors of: ")
    assert num.lstrip("+-").isnumeric(), "Only integer values are valid"
    print(f"Divisors of {num}: \n{divisors(int(num))}")

if __name__ == "__main__":
    run()

Aqui mi mi reto

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



def main():
    num = input("ingresa un numero: ")
    assert num.isnumeric() and  int(num) >= 0,"Ingrese un número (utilice cifras, NO texto) este debe ser positivo"
    print(divisors(int(num)))
    print('Termino el programa')

if __name__ == "__main__":
    main()

Reto:

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

def run():
    num = input('Ingresa un número: ')
    assert num.isnumeric(), 'Tienes que escribir un numero'
    assert int(num) > 0, 'Tiene que ser positivo'
    print(divisors(int(num)))
    print('Termino mi programa')


if __name__ == '__main__':
    run()

Reto:

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

def main():
    num = input('Ingresa un numero: ')
    assert num.isnumeric() and int(num) > 0, 'Debes ingresar un numero positivo'
    print(divisors(int(num)))
    print('Termino mi programa')
   

if __name__ == '__main__':
    main()

ok 😎

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

def run():

    num = input("Ingresa un numero: ")
    assert num.isnumeric() and int(num)>0, "No puede ingresar caracteres ni números negativos."
    num = int(num)
    print(divisors(num))
    print("Programa terminado.")
  

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 = (input("Ingresa un número: "))
        assert num.isnumeric(), "Debes ingresar un número"
        print(divisors(int(num)))
        assert num.isnumeric(num), "Debes ingresar un número positivo"
        print(divisors(int(num) > 0))
        print("Terminó mi programa")
    

if __name__ == "__main__":
    run()

En la poca investigacion que hice, el metodo “isnumeric” devuelve true en solo los numeros positivos, asi que la unica forma de comparar si es numero positivo o no, es de la siguiente manera:

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


def run():
    num = input("Ingrese un numero: ")
    assert num.isnumeric() and int(num) > 0, "Debes ingresar un numero mayor que 0"
    print(divisors(int(num)))
    print("Termino mi programa")


if __name__ == '__main__':
    run() 

<code>

Hola, esta es mi solución:

   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: "))
      assert num > 0, "Debes ingresar un número positivo"
      print(divisors(int(num)))
      print("Terminó el programa")
    
if __name__ == '__main__':
    run()

Ya muchos lo dijeron: el mismo assert anterior filtra números negativos, por lo que sólo bastaría cambiar el mensaje de error.

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

def run():
    num = input('Ingresa un número: ')
    assert num.isnumeric(), "Debes ingresar un número entero positivo."
    print(divisors(int(num)))
    print('Terminó mi programa.')


if __name__ =='__main__':
    run()

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

def integer(number):
    try:
        number = int(number)
        return number
    except:
        print("No se pueden ingresar cadenas de texto.")
        return False

def run():
    num = input("Ingresa un número: ")
    if integer(num) != False:
        assert integer(num) > 0, "No se admiten números negativos"
        print(divisors(integer(num)))
        print("Ejecución finalizada")

if __name__ == "__main__":
    run()

Isnumeric solo funciona con números positivos así que debe quitar el signo negativo, yo use lstrip y después si usar isnumeric.

def run():
    num = input("Por favor ingrese un numero: ")    
    assert num.lstrip("-").isnumeric(), "Debes ingresar un número"
    assert int(num) > 0, "Solo números positivos"
    print(divisors(int(num)))
    print("Fin")

Solo modifiqué el mensaje.

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

def run():
    num= input('Ingresa un número: ')
    assert num.isnumeric(), 'Escribe solo numeros positivos'
    print(divisors(int(num)))
    print('Terminó el programa')

if __name__ == '__main__':
    run()

Vi varias soluciones pero cometían el mismo error así que comparto una mejor solución ofrecida por un compañero:

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

def run(): 
    num = input('Escribe un numero para sacar sus divisores: ')

    if num.isnumeric():
        print(divisors(int(num)))

    else:
        try:
            num = int(num)
        except:
            return print("No debes ingresar letras o caracteres")
    
        
        assert num > 0, "Debes ingresar un numero positivo"
        

if __name__ == '__main__':
    run()

Recomiendo leer este artículo. Está en inglés pero brinda un buen contexto acerca de cuándo y dónde usar assert statements

https://www.codingem.com/python-assert-statements/#:~:text=If you assert multiple conditions,conditions in an if statement.

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: "))
        assert num > 0, "Debes ingresar un número positivo"
        print(divisors(num))

        print("Termino el programa")


if __name__ == '__main__':
    run()

def divisors(num):

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

def run():
    try:
        num = int(input("ingresa un numero positivo: "))
        assert num > 0 , "ingrese un numeor positivo"
        print(divisors(num))
    except ValueError :
        print("ingresa un numero")
        

Mi codigo 😄

a=int(input("Ingrese numero: "))
assert a>=0, "No es un numero"
b=[x for x in range(1,a+1) if a%x==0]
print(b)

mi main

def main ():
    num = input("ingresa un numero: ")
    assert num.isnumeric(), "Debes ingresar un numero positivo"
    num = int(num)
    print(divisors(num))
    print("termino")
    
    #except TypeError as tp:
    #    print(tp)