No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Manejo de excepciones

15/21
Recursos

Aportes 85

Preguntas 16

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

Algo que aparece casi al final de la lectura recomendada en el documentaci贸n de Python es que se puede agregar un 鈥渆lse鈥 al try-except.

TRY: En el try se coloca c贸digo que esperamos que pueda lanzar alg煤n error.
EXCEPT: En el except se maneja el error, es decir, si ocurre un error dentro del bloque de c贸digo del try, se deja de ejecutar el c贸digo del try y se ejecuta lo que se haya definido en el Except.
ELSE: El else se ejecuta s贸lo si no hubo ninguna excepci贸n lanzada desde el try
FINALLY: Se ejecuta SIEMPRE, haya sido lanzada la excepci贸n o no haya sido lanzada.

Manejo de Excepciones

  • try except 鈫 Anidamos nuestro programa en dos bloques de c贸digo, el primero es el programa per se (el que se ejecuta normalmente, sin errores) y el segundo representa las instrucciones a seguir en caso de error.
    Su sintaxis es:
    try:
    	<bloque1>
    except <error> as <alias>:
    	<bloque 2>
    
    • <error> es un par谩metro opcional, permite capturar s贸lo el tipo de error indicado, si no se coloca captura todos los errores posibles (es buena pr谩ctica capturar cada tipo de error por separado)
    • as <alias> nos permite crear un alias al error, para trabajar con 茅l.
  • raise 鈫 Esta instrucci贸n nos permite generar errores, es decir crear nuestros propios errores cuando detectemos que nuestro programa no act煤a como deber铆a con cierto tipo de datos
    Su sintaxis es:
    	raise <NombreError>("<descripci[on del error>")
    
  • fynally 鈫 Es una bloque de c贸digo que se ejecuta exista un error o no (un tercer bloque despu茅s de try except), no es muy usual pero puede darse para cerrar archivos, conexiones a BBDD o liberar recursos

Jerarqu铆a de las excepciones y errores m谩s comunes:

Tomado de: Hunt, John. A Beginners Guide to Python 3 Programming.

Lo que en realidad ten铆a que imprimir en pantalla en el bloque de Except

Utilizamos el raise error, cuando queremos que dadas ciertas circustancias nuestro programa para y advierta al usuario.

try:
    pass #C贸digo a evaluar
except:
    pass #Si ocurre un error, llegar谩 a esta parte

Ejemplo con try, raise, except:

def palindrome(string):
    try:
        if len(string) == 0:
            raise ValueError("No se pueden ingresar cadenas vac铆as")
        return string == string[::-1]
    except ValueError as ve:
        print(ve)
        return False


try:
    print(palindrome(""))
except TypeError:
    print("Solo se pueden ingresar strings")

finally no es muy usado pero a煤n as铆 es necesario mencionarlo. Corresponde al final de un bloque try. Se usa en casos muy particulares, por ejemplo; cerrar un archivo, cerrar una conexi贸n a una base de datos o liberar recursos externos.

try:
    f = open("archivo.txt")
    # hacer cualquier cosa con nuestro archivo
finally:
    f.close()

Dentro del maneja de excepciones, Python define un conjunto de excepciones integradas en forma de jerarqu铆a, en donde podemos encontrar unas m谩s generales que otras, es decir, para el caso de la excepci贸n ZeroDivisionErrorexiste una excepci贸n m谩s general llamada ArithmeticError, y para el caso de la excepci贸n ArithmeticError existe una excepci贸n m谩s general llamada Exception.

Por lo que es importante definir bien el orden en el que ponemos cada excepci贸n dentro del try, ya que cada excepci贸n es le铆da de arriba a abajo, y la primera coincidencia que encuentra es la que ejecuta omitiendo las dem谩s.

def run():
    try:
        numero = 1 / 0
        print(numero)
    except ZeroDivisionError:
        print('No se puede divir entre 0')
    except ArithmeticError:
        print('Se encontro un error aritmetico')
    except:
        print('Se encontro un error')


if __name__ == '__main__':
    run() # No se puede divir entre 0

Si cambiamos el orden de las excepciones poniendo primero ArithmeticError, entonces la excepci贸n ZeroDivisionError no se ejecutar铆a:

def run():
    try:
        numero = 1 / 0
        print(numero)
    except ArithmeticError:
        print('Se encontro un error aritmetico')
    except ZeroDivisionError:
        print('No se puede divir entre 0')
    except:
        print('Se encontro un error')


if __name__ == '__main__':
    run() # Se encontro un error aritmetico

Recuerda entonces poner primero excepciones m谩s concretas antes que las generales, y por 煤ltimo y si as铆 lo deseas poner al final un except sin tipo de excepci贸n para manejar cualquier tipo.

Nuestro finally, es muy poco utilizado, sin embargo es muy necesario cu谩ndo queremos manejar archivos, cerrar conexiones a bases de datos o a recursos externos. Pues lo que se encuentre dentro de finally, siempre ocurre.

Try and Except

Intenta ejecutar esto si no puedes manejar, haz lo que se encuentra en el except

Buena pr谩ctica: Siempre a帽ade el tipo de excepci贸n, cada librar铆a trae las suyas, Python tiene unas propias del lenguaje en general y puedes crear las tuyas
Excepciones de Python

Finally

Es lo que se ejecutara si o si luego del manejo de la excepci贸n

Manejo de excepciones.

  • Try, except 鈫 Nos sirve para configurar acciones predeterminadas dado que sucede alguna Exception. 馃憖 El formato general es:

    try: 
    	<c贸digo>
    except <tipo de excepci贸n>:
    	<otro c贸digo>
    
  • raise 鈫 Esto nos sirve para manejar errores que python no reconoce como errores directamente. Con esto, nosotros creamos o definimos algo que si es un error.

    if <condici贸n>:
    	raise <tipo de excepci贸n>(<Mensaje>)
    

    Eso en principio interrumpe el programa (dado que es una excepci贸n). Podemos poner esto dentro de un try-except.

  • finally 鈫 Es muy rara de encontrar: cerrar archivos, conexiones y liberar recursos externos 馃. Suceda un error o no esto sucede.

Los ejemplos vistos en clase:





Try/Except structure

En este video (en ingl茅s) se explica muy bien el try/except. Adem谩s se recomienda que el c贸digo que est谩 entre ambas cl谩usulas no sea de m谩s de una l铆nea. https://www.youtube.com/watch?v=HdL82tAZR20&t=691s

鈿 El manejo de excepciones nos permite controlar los errores ocasionados durante la ejecuci贸n de nuestro proyecto.

Manejo de excepciones (raise, try, except y finally)

<h3>Try, Except</h3>

Ejemplo:

def palindrome(string):
  return string == string[::-1]

print(palindrome(1))

esto se soluciona con un try, except:

def palndrome(string):
  return string == string[::-1]
try:
  print(palindrome(1))
except TypeError:
  print('Solo se pueden ingresar strings')
<h3>Raise</h3>

Cuando Python no nos informa de un error podemos usar raise para elevar una excepcion deacuerdo al caso:

def palindrome(string):
  try:
    if len(string) == 0:
      raise ValueError('No se puede ingresar cadenas vacias')
    return string == string[::-1]
  except ValueError as ve:
    print(ve)
    return False

try:
  print(palindrome(''))
except TypeError:
  print('Solo se pueden ingresar strings')

por ultimo tenemos finally, el cual es un caso excepcional que nos ejecuta algo as铆 no se ocurra try o except:

try:
  f = open('archivo.txt')
finally:
  f.close()

Aqu铆 mi ejemplo de try / except /else:

def palindrome(string):
    try:
        palindrome = string == string [::-1]
    except TypeError:
        print(f"No puedes utilizar n煤meros, {string} es un n煤mero. ")        
    else:
        if palindrome == True:
            print(f"'{string}' es un pal铆ndromo!")
        elif palindrome == False:
            print(f"'{string}' no es un pal铆ndromo.")



palindrome(50)

un aporte a la divisi贸n por cero

def divisors(num):
    try:
        if num <= 0:
            raise ValueError("No se pueden numeros negativos")
        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("ingrese"))
        print(divisors(num))
        print("termin贸")
    except ValueError:
        print("Debes ingresar un numero")

Palabras reservadas para manejar un error o excepciones en Python:

* try: Permite que un bloque de codigo busque errores
* except: Bloque que permite manejar el error
* finally: Bloque que permite ejecutar codigo, independientemente del resultado de los bloques try y except

IMPORTANTE Para manejar el error debemos conocer el tipo de error que genera o que generara al momento de ejecutarlo
|

Como conocer el error que genera un codigo: Para hacer saber a la otra persona o a nosotros mismo que tipo de error esta generando el programa podemos hacerlo de igual forma como vemos el tipo de dato que estamos manejando puesto que recuerda que todo en python es un objeto, entonces en este caso pudiesemos aplicar lo siguiente:

Ejemplo:

try:
    c = int(input("Ingrese un valor: "))
    c / 0

except Exception as c: #Con esto estamos evaluando la variable para la excepcion
    print(type(c)._name) ---> Con esto podemos saber el tipo de el error y el nombre del mismo

#ZeroDivisionError

---
De esta forma, estaria evaluando el error, por que por ejemplo si le pasamos una cadena de texto, entonces el resultado sera un ValueError

No se si lo hicieron a prop贸sito o si es una hermosa casualidad jajaja pero si segu铆s los carreras que predefine el equipo de Platzi te vas a encontrar con que en el curso anterior muchas clases solo se enfocan en presentar conceptos que despu茅s no profundizan solo para que en el siguiente curso de la ruta cuando hablen de ese tema como algo nuevo uno ya tenga las nociones b谩sicas ya digeridas + el mismo tema explicado por dos profesores diferentes.
Gran acierto para facilitar la compresi贸n y mejorar la retenci贸n de informaci贸n

Viendo el ejemplo del uso de raise me puse a pensar, 驴Qu茅 ocurre si el usuario pone un espacio en blanco, o varios? la respuesta es que como queda el c贸digo en la clase sigue dando que es un palindromo.

As铆 que investigando un poco usando el m贸dulo strip() puedo eliminar esos espacios y volviendo la longitud a cero

 try:
        string = input("Ingresa una palabra: ")
        string = string.strip()  #as铆 se eliminar谩n los espacios y la longitud ser谩 0
        print(palindrome(string))
        print("Fin del programa")
    except TypeError:
        print("Solo se pueden ingresar strings")

Manejo de excepciones

Palabras clave (*raise, try, except y finally)

try, except

def palindrome(string):
    return string == string[::-1]

try:
   print(palindrome(1))
except TypeError:
   print("solo se pueden ingresar strings")

  • El bloque try son las declaraciones que te gustar铆a ejecutar. En caso tal de que fallen, el python salta este pedazo de bloque y se va para el except

  • el bloque except se activa cuando el bloque try falla debido a una excepci贸n. Contiene un conjunto de declaraciones que a menudo le dan un contexto sobre lo que sali贸 mal dentro del bloque try. En otras palabras, el except es solo para los errores de tipo TypeError.

raise

def palindrome(string):
    try:
        f len(string) == 0:
        raise ValueError("no se puede ingresar una cadena vac铆a"
    return string == string[::-1]
    except Value Error as ve:
        print(ve)
        return false

try:
    print(palindrome(""))
    except TypeError: 
        print("Solo se pueden ingresar strings")

Es una forma de crear nuestros propios errores cuando detectemos algo en nuestro programa que no deber铆a

finally

try:
    f = open("archivo.txt")
    # buscar cualquier cosa dentro del archivo

finally:
    f.close()

Hacer algo si sucede un error o no

Dentro de Python, los manejos m谩s b谩sicos, solo utilizan el try y luego el except. Lo que hacemos es envolver justo la zona en la que podemos tener un error, con un try, luego del try, el except.

El error del pal铆ndromo tambi茅n se podr铆a manejar con otra palabra clave que es assert y cambiando la excepci贸n de ValueError a AssertionError

Lo he intentado resolver sola antes de continuar, pero creo que puedo hacerlo mejor:

Muchachos les dejo el ejercicio trabajado con un nivel un poco mas elevado utilizando While True para validaci贸n de datos y agregando la excepci贸n de que no se aceptan n煤meros dentro del string, espero sea de ayuda!! #NeverStopLearning

def num_string(string):
    numbers = [str(i) for i in range(10)]
    for i in string:
        if i in numbers:
            return True


def palindrome():
    while True:
        string = input('String: ')
        try:
            if len(string) == 0:
                raise ValueError('No empty strings') # --> Mensaje de error
            elif num_string(string) == True:
                raise ValueError('No strings of numbers')
            else:
                return (string == string[::-1], string[::-1])
        except ValueError as ve: # ve es una abreviatura de ValueError
            print(ve)   # Excepto que suceda un ValueError al que llamamos ve, ejecuta el mensaje de error --> print(ve)
            

print(palindrome())

Manejo de excepciones.
try / probar
except/ excepto que鈥
Si sucede un error se ejecuta lo siguiente.
raise : Hay un error en la l贸gica. as da nombre al error.
finally : Al final del manejo de errores. Cerrar cosas, liberar espacio.

Otra soluci贸n a la cuesti贸n del pal铆ndromo sin uso de excepciones:

def run(string):
    string = (str(string)).replace(" ", "").lower()
    return False if string[::-1] != string or len(string) == 0 else True

Estas expresiones tambi茅n se pueden usar en inteligencia artificial como es com煤n cuando se hace m煤ltiples excepciones

try:
    do_the_thing()
except TypeError as e:
    do_the_other_thing()
except KeyError as e:
    do_the_other_thing()
except IndexError as e:
    do_the_other_thing()

Cuando queremos levantar un error en medio de una ejecuci贸n, entonces lo que tenemos que hacer es ejecutar un manejo de excepciones dentro la funci贸n. En algunos casos.

Ac谩 les dejo mi propio ejemplo

def run(num):
    try:
        if not num:
            raise ValueError("No puedo elevar a la potencia valores booleanos ",str(num))
        print(num**2)
    except ValueError as handled_error:
        print(handled_error)
    except TypeError:
        print("Solamente puedo elevar al cuadrado numeros")
        print("No puedo elevar al cuadrado " + str(num))
    finally:
        print("EOF")

if __name__=='__main__':
    # run("Patata")
    # run(True)
    # run(False)
    run(9)

mi aporte


def palindromo(s):
    try:

        if len(s)<3  or  s.isdecimal() or (not s.isalpha()):
            raise ValueError("No valido")
        return s==s[::-1]

    except ValueError as ve:
        print(ve)
        return False

def run():
    s= input("escribe una palabra: ").lower().strip()
    print(palindromo(s))

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 numero"))
        try:
            if num >=0:
                print(divisors(num))
                print("Acabo")
            else:
                raise ValueError("No puedes poner numeros negativos Amix")
        except ValueError as ve:
            print(ve)
    except ValueError :
        print("Debes ingresar un n煤mero")

    

if __name__ == '__main__':
    run()

Comparto mi c贸digo 馃槂

def divisors(num):
    try:
        if num < 0:
            raise ValueError("No se pueden ingresar n煤meros negativos")
        return
        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贸 el programa")
    except ValueError:
        print("Debes ingresar un n煤mero")



if __name__ == '__main__':
    run()

As铆 como en otros lenguajes existe try-catch, aqu铆 es posible utilizar try-except

  • _Try _- intentar谩 realizar el c贸digo que experamos que suceda

  • _Except _- Si ocurre un error dentro del bloque try, aqu铆 se concentrar谩 y se ejecutar谩 el c贸digo de este bloque

  • **Else **- este se ejecuta solo si no hubo ninguna excepci贸n dentro del try

  • _Finally _- Se ejecuta siempre al final, se haya lanzado una excepci贸n o no. Es com煤n usarlo cuando cierras cuna conecci贸n a base de datos desde una petici贸n en una API Rest o como en el ejemplo, cerrar si o si un documento abierto.

Existen distintos tipos de excepciones como **TypeError **o **ValueError **y se pueden guardar dentro de una variable

Hay formas de generar errores condicionados y esto es elevando una excepci贸n con raise, que indica el tipo de error y el mensaje

Challenge

def divider(nums):
    try:
        if(nums <= 0):
            raise ValueError('Only can process a number positive')
        if(nums > 0):
            list_divider = []
            for i in range(1, nums + 1):
                if nums % i == 0:
                    list_divider.append(i)
            print(list_divider)
    except ValueError as ve:
        print(ve)


def run():
    try:
        number = int(input('Number: '))
        divider(number)
    except ValueError:
        print('Only can process a number')
    finally:
        print('Completed')


if __name__ == '__main__':
    run()

Va mi c贸digo:

## Mostrar los divisores de un n煤mero ingresado x el usuario.

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


def run():

    while True:
        try:
            num = int(input("\nIngresa un n煤mero: "))
            if num <= 0: 
                raise Exception
            print("\nDivisores: ", divisors(num))
            break
        except Exception:   
            print("\nError: Introduce un numero entero positivo")

    print("\nFin del programa")


if __name__ == '__main__':
    run()

Try, except 鈫 Nos sirve para configurar acciones predeterminadas dado que sucede alguna Exception. 馃憖 El formato general es:
try:
<c贸digo>
except <tipo de excepci贸n>:
<otro c贸digo>
raise 鈫 Esto nos sirve para manejar errores que python no reconoce como errores directamente. Con esto, nosotros creamos o definimos algo que si es un error.
if <condici贸n>:
raise <tipo de excepci贸n>(<Mensaje>)
Eso en principio interrumpe el programa (dado que es una excepci贸n). Podemos poner esto dentro de un try-except.
finally 鈫 Es muy rara de encontrar: cerrar archivos, conexiones y liberar recursos externos

Python utiliza un objeto especial llamado excepci贸n para controlar cualquier error que pueda ocurrir durante la ejecuci贸n de un programa. Cuando ocurre un error durante la ejecuci贸n de un programa, Python crea una excepci贸n.

Aqu铆 poniendo en practica el programa de los divisores con el manejo de excepciones vistas, antes de pasar a la siguiente clase鈥
Entiendo que el else y el finally no est谩n bien utilizados, ni el raise seria tipo de error.

# recibir un n como parametro y retornar una lista de los divisores

def divisor(num):
    divisor = []
    try:
        if num == 0:
            raise ValueError('Special case, all numbers are divisible')
        for i in range (1, num + 1):
            if num % i == 0:
                divisor.append(i)            
            return divisor
    except ValueError as ve:
        print(ve)
        return 0


def run():
    try:
        num = int(input('Digit at numer: '))
        print(divisor(num))
    except:
        print('[-] Digit at number!!!')
    else:
        print('[+] The program worked successfully')
    finally:
        print('Thanks for use my program <3')


if __name__ == '__main__':
    run()

Try: Intentar algo

  • raise: Levantar un error
    Except: Capturar un error
    Finally: Usado para liberar recursos
  • try, except = este comando funciona para cuando no se esta ingresando el par谩metro esperado y necesitamos avisar por pantalla
  • raise = asigna un posible error que no esta identificado por python y le asigna un tipo de error para poder resolverlos en las excepciones
  • finally = cerrar archivos, conexi贸n, liberar recursos externos

Esta es una excelente lectura para profundizar en las excepciones.

Python Exceptions: An Introduction

   if len(string.strip()) ==0:

En est谩 web page encontrar谩s ejercicios sobre el tema:
https://www.w3schools.com/python/python_try_except.asp

The try block lets you test a block of code for errors.

The except block lets you handle the error.

The else block lets you execute code when there is no error.

The finally block lets you execute code, regardless of the result of the try- and except blocks.

Comparto mis apuntes del curso:

Manejo de excepciones

  • El manejo de excepciones ayuda al programador a trasladar el c贸digo para manejo de errores de la l铆nea principal de ejecuci贸n, adem谩s se puede elegir entre manejar todas las excepciones, las de cierto tipo o de las de grupos relacionados, esto hace que la probabilidad de pasar por alto los errores se reduzca y a la vez hace los programas m谩s robustos. Pero es importante utilizar un lenguaje de programaci贸n que soporte este manejo, de lo contrario el procesamiento de errores no estar谩 incluido y har谩 el programa m谩s vulnerable
>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

Hay una forma general de manejar las excepciones. Supongo que puede ser una pr谩ctica cuestionable el hecho de no manejar las excepciones de forma explicita pero igual les comparto lo que encontr茅:

def palindrome( string ):
    if not string:
        raise ValueError("No se pyede ingresar una cadena vac铆a")
    return string == string[::-1]


if __name__ == '__main__':
    print("Ingrese la palabra a verificar si es pal铆ndromo")
    word = input()
    try:
        if palindrome(word) == True:
            print("Es pal铆ndromo")
        else:
            print("No es pal铆ndromo")
    except Exception as Err:
        print("Excepci贸n generada {}".format(Err))  # Pasa cada vez que ocurra una excepci贸n
    else:
        print("Ejecuci贸n exitosa") # Pasa si no ocurri贸 ninguna excepci贸n
    finally:
        print("Fin de programa") # Pasa siempre
    

Comparto mis notas

![](

les dejo esta img que explica el uso de try, except, else y finally
mas info en https://realpython.com/python-exceptions/

No conoc铆a finally

As铆 es como quedo mi programita del pal铆ndromo 馃槃

驴Qu茅 les parece?

def palindromo(string):    
    """Retorna True o False si una cadena es un palindromo

    Args:
        string (str): Cadena a evaluar si es un palindromo

    Returns:
        bool: True es palindromo, False no es palindromo
    """
    assert type(string) == str, f"Esto {string}, no es una cadena"
    assert len(string.strip()) != 0, "La cadena no debe ser vacia"

    try:
        return string == string[::-1]
    except Exception as e:
        print(f"Ups -> {e}")

def run():
    while(True):
        try:
            string = input("Ingresa la cadena: ")
            es_palindromo = palindromo(string)
            break
        except Exception as e:
            print(f"Algo salio mal: {e}")

    if es_palindromo:
        print(f"{string} es palindromo :)")
    else:
        print(f"{string} no es palindromo :(")

if __name__ == '__main__':
    run()

No sab铆a que tan util son el manejo de excepciones y debugging

def palindromo(palabra):
    palabra = palabra.replace(" ", "")
    palabra = palabra.lower()
    palabra_invertida = palabra[::-1]
    if palabra == palabra_invertida:
        return True
    else:
        return False

        

def run():
    palabra =input("Escribe una palabra: ")
    es_palindromo = palindromo(palabra)
    if es_palindromo == True:
        print("Es pal铆ndromo")
    else:
        print("No es pal铆ndromo")
    try:    
        print(palabra(1, ""))
    except TypeError:
        print("Solo se pueden ingresar palabras")


if __name__ == "__main__":
    run()

Yo lo resolv铆 as铆.

El raise lo interpreto como el throw en los lenguajes compilados como C#. Lanza la excepci贸n, es una que nosotros definimos y es para que nosotros le demos control.

A entender la gran diferencia entre assert y raise.
Assert se usa a nivel de debug y puede ser borrado por optimizadores de c贸digo.
Raise lanza excepci贸n como se ve en la clase.

Prob茅 con algo diferente, cuando ingreso un n煤mero negativo al final run() me arroja None, no logr茅 solucionarlo.

divisors = lambda num: [i for i in range(1,num+1) if num % i == 0 ] if  num > 0 else print("Ingresa numoero positivo")
def run():
    try:
        print(divisors(int(input("Ingrese un numero: "))))
    except ValueError:
         print("El programa necesita un numero")
    
if __name__ == "__main__":
    run()


aqui hay una lista de excepciones.

muy buena teor铆a, listo a la pr谩ctica

I wrote my solution like this:

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("Write a number: "))
        print(divisors(num))
    except ValueError:
        print("You are just allowed to write numbers.")
    print("Program finished.")


if __name__=='__main__':
    run()

Me ha encantado esta parte para mis scripts de procesamiento, ahora puedo evitar que se pare la ejecuci贸n, por ejemplo:

def upper_items(list):
    for i in list:
        try:
            print(i.upper())
        except AttributeError:
            print("Hay un problema con un item de la lista.")


nombres = [ "juan", 2, "maria", "jose", None, "ana", "facundo" ]

upper_items(nombres)

Manejo de excepciones
鈥 Try: Dentro de este bloque se coloca el c贸digo que esperamos ejecutar y en el que pueda surgir alg煤n error.

鈥 Except: Este bloque se ejecuta si en alg煤n punto del try ocurre un error entonces se deja de ejecutar el bloque try y se ejecuta el c贸digo que se encuentre en este bloque. Se puede tener varios except para que cada uno maneje un tipo de error en espec铆fico y podemos darle un alias al error haciendo uso de la palabra reservada 鈥渁s鈥 seguido del alias que deseamos asignar al error, dentro de un solo except se pueden pasar como par谩metro varios tipos de errores de la siguiente forma:

except (RuntimeError, TypeError, NameError):

Aunque tambi茅n podemos omitir el nombre del error y dejar 煤nicamente el except.

鈥 Raise: Esta opci贸n nos sirve para nosotros mismos poder generar un error por ejemplo si una condici贸n no se cumple, para usarla simplemente usamos la palabra reservada raise y seguido de esta el nombre del error que vamos a generar

鈥 Finally: El c贸digo que se coloque dentro del bloque finally siempre ser谩 ejecutado sin importar si ocurrieron o no las excepciones, se suele usar para liberar recursos externos.

鈥 Else: El bloque try tambi茅n pose una cl谩usula else la cual es ejecutada siempre y cuando no ocurran ninguna excepci贸n.

Para el manejo de excepciones los lenguajes proveen ciertas palabras reservadas, que nos permiten manejar las excepciones que puedan surgir y tomar acciones de recuperaci贸n para evitar la interrupci贸n del programa o, al menos, para realizar algunas acciones adicionales antes de interrumpir el programa.

En el caso de Python, el manejo de excepciones se hace mediante los bloques que utilizan las sentencias try, except y finally.

Dentro del bloque try se ubica todo el c贸digo que pueda llegar a levantar una excepci贸n, se utiliza el t茅rmino levantar para referirse a la acci贸n de generar una excepci贸n.

A continuaci贸n se ubica el bloque except, que se encarga de capturar la excepci贸n y nos da la oportunidad de procesarla mostrando por ejemplo un mensaje adecuado al usuario. Veamos qu茅 sucede si se quiere realizar una divisi贸n por cero:

dividendo = 5
divisor = 0
dividendo / divisor
Traceback (most recent call last):
File 鈥<stdin>鈥, line 1, in <module>
ZeroDivisionError: integer division or modulo by zero

En este caso, se levant贸 la excepci贸n ZeroDivisionError cuando se quiso hacer la divisi贸n. Para evitar que se levante la excepci贸n y se detenga la ejecuci贸n del programa, se utiliza el bloque try-except.

try:
鈥 cociente = dividendo / divisor
鈥 except:
鈥 print 鈥淣o se permite la divisi贸n por cero鈥

No se permite la divisi贸n por cero

Dado que dentro de un mismo bloque try pueden producirse excepciones de distinto tipo, es posible utilizar varios bloques except, cada uno para capturar un tipo distinto de excepci贸n.

Esto se hace especificando a continuaci贸n de la sentencia except el nombre de la excepci贸n que se pretende capturar. Un mismo bloque except puede atrapar varios tipos de excepciones, lo cual se hace especificando los nombres de la excepciones separados por comas a continuaci贸n de la palabra except. Es importante destacar que si bien luego de un bloque try puede haber varios bloques except, se ejecutar谩, a lo sumo, uno de ellos.

try:
# aqu铆 ponemos el c贸digo que puede lanzar excepciones
except IOError:
# entrar谩 aqu铆 en caso que se haya producido
# una excepci贸n IOError
except ZeroDivisionError:
# entrar谩 aqu铆 en caso que se haya producido
# una excepci贸n ZeroDivisionError
except:
# entrar谩 aqu铆 en caso que se haya producido
# una excepci贸n que no corresponda a ninguno
# de los tipos especificados en los except previos

Como se muestra en el ejemplo precedente tambi茅n es posible utilizar una sentencia except sin especificar el tipo de excepci贸n a capturar, en cuyo caso se captura cualquier excepci贸n, sin importar su tipo. Cabe destacar, tambi茅n, que en caso de utilizar una sentencia except sin especificar el tipo, la misma debe ser siempre la 煤ltima de las sentencias except, es decir que el siguiente fragmento de c贸digo es incorrecto.

try:
# aqu铆 ponemos el c贸digo que puede lanzar excepciones
except:
# ERROR de sintaxis, esta sentencia no puede estar aqu铆,
# sino que deber铆a estar luego del except IOError.
except IOError:
# Manejo de la excepci贸n de entrada/salida

Finalmente, puede ubicarse un bloque finally donde se escriben las sentencias de finalizaci贸n, que son t铆picamente acciones de limpieza. La particularidad del bloque finally es que se ejecuta siempre, haya surgido una excepci贸n o no. Si hay un bloque except, no es necesario que est茅 presente el finally, y es posible tener un bloque try s贸lo con finally, sin except.

Veamos ahora como es que act煤a Python al encontrarse con estos bloques. Python comienza a ejecutar las instrucciones que se encuentran dentro de un bloque try normalmente. Si durante la ejecuci贸n de esas instrucciones se levanta una excepci贸n, Python interrumpe la ejecuci贸n en el punto exacto en que surgi贸 la excepci贸n y pasa a la ejecuci贸n del bloque except correspondiente.

Para ello, Python verifica uno a uno los bloques except y si encuentra alguno cuyo tipo haga referencia al tipo de excepci贸n levantada, comienza a ejecutarlo. Sino encuentra ning煤n bloque del tipo correspondiente pero hay un bloque except sin tipo, lo ejecuta. Al terminar de ejecutar el bloque correspondiente, se pasa a la ejecuci贸n del bloque finally, si se encuentra definido.

Si, por otra parte, no hay problemas durante la ejecuci贸n del bloque try, se completa la ejecuci贸n del bloque, y luego se pasa directamente a la ejecuci贸n del bloque finally (si es que est谩 definido).

Bajemos todo esto a un ejemplo concreto, supongamos que nuestro programa tiene que procesar cierta informaci贸n ingresada por el usuario y guardarla en un archivo. Dado que el acceso a archivos puede levantar excepciones, siempre deber铆amos colocar el c贸digo de manipulaci贸n de archivos dentro de un bloque try. Luego deber铆amos colocar un bloque except que atrape una excepci贸n del tipo IOError, que es el tipo de excepciones que lanzan la funciones de manipulaci贸n de archivos. Adicionalmente podr铆amos agregar un bloque except sin tipo por si surge alguna otra excepci贸n. Finalmente deber铆amos agregar un bloque finally para cerrar el archivo, haya surgido o no una excepci贸n.

try:
archivo = open(鈥渕iarchivo.txt鈥)
# procesar el archivo
except IOError:
print 鈥淓rror de entrada/salida.鈥
# realizar procesamiento adicional
except:
# procesar la excepci贸n
finally:
# si el archivo no est谩 cerrado hay que cerrarlo
if not(archivo.closed):
archivo.close()

mi aporte chico espero que les guste 馃槈

#try,except
#   |
#   |
#   V

def run():
    def palindrome(string):
        return string == string[string::-1]
    try:
        print(palindrome(1))
    except TypeError:
        print("Solo se purden ingresar strigns")


if __name__ == '__main__':
    run()

#raise
#   |
#   |
#   V

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

    try:
        print(palindrome(""))
    except TypeError:
            print("Solo se pueden ingresar strings")


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

#finalily
#   |
#   |
#   V

def run():
    try:
        f =  open("archivo.txt")
        #hacer cualquier cosa con nuestro archivo
    finally:
        f.close
    print(f)
if __name__ == "__name__":
    run()

Solucion del reto

def divisores(num):
    divisors = []

    for i in range(1, num + 1):
        if num % i == 0:
            divisors.append(i)
    return divisors
     
def run():
    print("Aprendiendo tacticas del debugin")
    try:
        num = int(input("Ingrese un numero: "))
        resultado = divisores(num)
        print(resultado)
        print("Termino mi programa")
    except ValueError:
        print("Por favor ingresa un valor tipo int")

if __name__ == "__main__":
    run()

Manejo de excepciones with:

Try and except: Estas palabras se pueden a traducir a:
Probar y excepto de que, hago lo siguiente:

def palindrome(string):
    return string == string[::-1]
try:
    print(palindrome(1))
except TypeError:
    print("Solo se pueden ingresar strings")

-------------------------

Manejo de excepciones with:

Raise: Raise es funcional cuando tenemos un error de logica, en otras palabras cuando tenemos un error pero python no lo detecta como un error

def palindrome(string):
    try:
        if len(string) == 0:
            raise ValueError("No se puede determinar si es un palindromo")
        return string == string[::-1]
    except ValueError as ve:
        print(ve)
        return False
  
try:
    print(palindrome(""))
except TypeError:
    print("Solo se pueden ingresar strings")

-------------------------

Manejo de excepciones with:

Finally: Es muy raro ve rfinally, pero bueno esta bien saber de su existencia, con ella podemos hacer una serie de cosas muy particulares, cosas como:

  • Cerrar un archivo dentro de python.

  • Cerrar una conexion a una basa de datos.

  • O liberar recursos externos.

try:
    f = open("archivo.txt")
    # Hacer cualquier cosa con nuestro archivo.
finally:
    f.close()

Esta en la funcion de finally, hacer algo sin importar si sucede un error o no.
Y en la mayoria de las ocasiones suele ser una mala practica usarlo.

Ojo:
Se puede agregar mas de 1 bloque de excepcion para gestionar distintos tipos

try: 
        es_palindromo = eval_palindromo(frase)
        if es_palindromo == True: 
            print("Si es palindromo")
        else: 
            print("NO es palindromo")
    except TypeError: 
        print("Solo se pueden ingresar strings")
    except ValueError as ve: 
        print("Cachando el raise de la funcion")
        print(ve)
    else: 
        print("Ninguna excepcion sucedio.")
    finally: 
        print("Termino el programa.")
muy buena explicaci贸n, esta parte de los errores es importante para los HMI que es en lo que trabajo.

Try: ejecuta un c贸digo que puede fallar
.
Except: ejecuta el c贸digo designado a manejar el error
.
Else: ejecuta un c贸digo si no hubo ni una excepci贸n
.
Finally: se ejecuta sea hubiera errores o no
.
Raise: provoca una excepci贸n

  • Hola a todos les comparto mi c贸digo
def divisor(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(divisor(num))
        print("Termin贸 mi programa")
    except ValueError:
        print("Debes ingresar un n煤mero")


if __name__ == "__main__":
    run() 

Hab铆a un reto al final de e las diapositivas de esta clase:

Utiliza las palabras clave try, except y raise para elevar un error si el usuario ingresa un n煤mero negativo en nuestro programa de divisores.

Ac谩 comparto mi soluci贸n:

def divisors(num):

    try:
        if num < 0:
            raise ValueError("No se aceptan n煤meros negativos")
    except ValueError as ve:
        return ve

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


def run():

    num = int(input('Ingresa un n煤mero: '))
    print(divisors(num))
    print("Termin贸 mi programa")


if __name__ == '__main__':
    run()

Muy buena esta clase, como todas!

Clase que nunca est谩 de m谩s repasar.

Entendio

Excelente explicaci贸n.

Los recuedros en color negro con el codigo, se ven muy pequenas las letras,

como crear un request al usuario que no pueda estar vac铆o

Buena clase!

EL except se lee,: s铆 sucede este error -> pasa esto.

Para el manejo de excepciones en Python, tenemos varias Keywords: Try,except,raise and finally.

No s茅 si lo est茅 interpretando mal, pero me parece que la explicaci贸n de Try es que all铆 se deben colocar los posibles errores, cuando esto es incorrecto. En Try se debe colocar el c贸digo que queremos ejecute el programa, y de no ser posible entonces que salte al Except 馃槙.