Manejo de excepciones

Excepciones comunes:
ImportError : una importación falla;
IndexError : una lista se indexa con un número fuera de rango;
NameError : se usa una variable desconocida ;
SyntaxError : el código no se puede analizar correctamente
TypeError : se llama a una función en un valor de un tipo inapropiado;
ValueError : se llama a una función en un valor del tipo correcto, pero con un valor inapropiado

Les dejo mis apuntes https://github.com/karlbehrensg/introduccion-pensamiento-computacional

Manejo de excepciones
Los manejos de excepciones son muy comunes en la programación, no tienen nada de excepcional. Las excepciones de Python normalmente se relacionan con errores de semántica, también podemos crear nuestras propias excepciones, pero cuando una excepción no se maneja (unhandled exception), el programa termina en error.

Las excepciones se manejan con los keywords: try, except, finally. Se pueden utilizar también para ramificar programas.

No deben manejarse de manera silenciosa (por ejemplo, con print statements). Para crear tu propia excepción utiliza el keyword raise.

"""Creamos una función en donde cada elemento de 
una lista es dividida por un divisor definido"""
def divide_elementos_de_lista(lista, divisor):
    """El programa intentara realizar la división"""
    try:
        return [i / divisor for i in lista]
    
    """En caso de error de tipo ZeroDivisionError que
    significa error al dividir en cero, el programa
    ejecutara la siguiente instrucción"""
    except ZeroDivisionError as e:
        return lista

lista = list(range(10))
divisor = 0

print(divide_elementos_de_lista(lista, divisor))

Un aspecto importante para un buen manejo de excepciones, es conocer la jerarquía en el árbol de excepciones de Python:

Esta imagen les puede ayudar 😄

basado en y ¡Suerte!

#All possible errors

except TypeError:
    print("is thrown when an operation or function is applied to an object of an inappropriate type.")
except IndexError:
   	print("is thrown when trying to access an item at an invalid index.")
except KeyError:
    print("is thrown when a key is not found.")
except ImportError:
  	print("Raised when the imported module is not found.")
except StopIteration:
  	print("is thrown when the next() function goes beyond the iterator items.")
except ValueError:
  	print("is thrown when a function's argument is of an inappropriate type.")
except NameError:
  	print("is thrown when an object could not be found.")	
except ZeroDivisionError:
  	print("is thrown when the second operator in the division is zero.")
except KeyboardInterrupt:
  	print("is thrown when the user hits the interrupt key (normally Control-C) during the execution of the program.")
except MemoryError:
  	print("Raised when an operation runs out of memory.")
except FloatingPointError:
  	print("Raised when a floating point operation fails.")
except OverflowError:
  	print("Raised when the result of an arithmetic operation is too large to be represented.")
except ReferenceError:
  	print("Raised when a weak reference proxy is used to access a garbage collected referent.")
except TabError:
  	print("Raised when the indentation consists of inconsistent tabs and spaces.")
except SystemError:
  	print("Raised when the interpreter detects internal error.")
except RuntimeError:
  	print("Raised when an error does not fall under any other category.")
except:
 	print("Error detected can't be handled nor clasified.")

Silenciar excepciones o como decían en mi trabajo… Programación Orientada a Excepciones Vacías
jajajajaa

Con recursividad…

def divide_elementos_de_lista(lista, divisor):
    try:
        return [i / divisor for i in lista]
    except ZeroDivisionError as e:
        print(e)
        divisor = int(input('Ingresa un divisor diferente cero: '))
        return divide_elementos_de_lista(lista, divisor)

lista = list(range(10))
divisor = 0

print(divide_elementos_de_lista(lista, divisor))

Lo hice con la raíz cuadrada.Aprendí a traer la función que hace esa operación

import math 
def raiz_cuadrada_elementos_lista(lista, multiplicador):
    try:
        return [math.sqrt(i*multiplicador) for i in lista]
    except ValueError as e:
        print (e)
        return f'no existe la raíz cuadrada de un negativo'    

lista = list(range(10))
multiplicador = -8

print (raiz_cuadrada_elementos_lista(lista, multiplicador))```

mi código generado con buenas prácticas:

¡Información adicional!
Funcionamiento de try

1. El bloque de código del try es ejecutado.
2. Si no ocurre una excepción, el except se pasa por alto y el try se termina.
3. Si ocurre una excepción durante el bloque de código del try, dejará de correr ese bloque y pasará el except. Si existe un match entre la excepción ocurrida y la declarada en except, el bloque del except es ejecutado. Luego sigue la ejecución común del programa.
4. Si no hay match, se deriva a un try integrado. Si no existe manejador de esta excepción, el programa se detendrá porque se trata de una unhandled expression mostrando el mensaje del error.
   Varias excepciones en un except
   Los except pueden recibir varias excepciones en forma de tupla, por ejemplo:

... except (RuntimeError, TypeError, NameError):
...     pass

else en sentencia try

La sentencia try acepta un else que se usará cuando se deba ejecutar código si el try no encuentra ninguna excepción:

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except OSError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

#Resumen de la leccion

#Manejo de Excepciones

#Definición: Si el resultado de la funcion es un error, el ejecuta un segmento de codigo.
#Entre los cuales se puede poner el error para verlo más facilmente. Esto evita que nuestro programa deje de funcionar cuando se encuentre con estos errores.

def divide_elementos_de_lista(lista, divisor):
    try:
        return [i / divisor for i in lista]
    except ZeroDivisionError as e:
        print(e)
        return lista

lista = list(range(10))
divisor = 0

print(divide_elementos_de_lista(lista, divisor))

Este es un reto personal tratando de implementar algunas de las herramientas que eh aprendido de este curso incluyendo manejo de excepciones.

import unittest

def informacion_grado_de_estudiante():
    notas_examen_y_participacion = {2:85, 3:80, 3:90}
    return notas_examen_y_participacion
    
    
def notas_de_examen():
    examen = 0
    for i in informacion_grado_de_estudiante().keys():
        examen += i
    return examen / len(informacion_grado_de_estudiante())


def notas_de_participacion():
    participacion = 0
    for i in informacion_grado_de_estudiante().values():
        participacion += i
    return participacion / len(informacion_grado_de_estudiante())


def notas_de_estudiantes():
    notas_de_estudiantes = notas_de_examen() + notas_de_participacion()
    return notas_de_estudiantes
    
    
def average_de_estudiantes():
    return notas_de_estudiantes() / 2


class CajaNegraTest(unittest.TestCase):
        def test_notas_de_estudiantes(self):
            print(f'The student average grade is {average_de_estudiantes()}')
            try:
                self.assertGreaterEqual(average_de_estudiantes(), 50)
            except AssertionError as e:
                print(e)
if __name__=='__main__':
    unittest.main()

Las formas en las que explotan los programas, cuando no tenemos un cuidadoso manejo de excepciones, puede llevar incluso a la corrupción de los datos que son registrados en las bases de datos.

Falto mencionar que finally se usa para ejecutar algo haya o no un error.

Documentación del manejo de errores en python

"""Excepciones:
• Son muy comunes en programación. No tienen nada de excepcional.
• Las excepciones de Python normalmente son errores de semántica.
• Se pueden crear excepciones propias.
• Cuando una excepción no se maneja (unhandled exception / excepción no controlada ), 
    el programa termina en error.
• Las excepcione se manejan con palabras reservadas: try, except, finally.
• Se pueden utilizar para ramificar programas, crear condicionales.
• No se debe manejar las excepciones con prints por consola, solamente.
• Para crear una excepción se utiliza la palabra reservada "raise".
"""

"""Excepciones Comunes:
• ImportError: una importación falla.
• IndexError: una lista se indexa con un número fuera de rango.
• NameError: se usa una variable desconocida.
• SyntaxError: el código no se puede analizar correctamente.
• TypeError: se llama a una función en un valor de un tipo inapropiado.
• ValueError: se llama a una función en un valor del tipo correcto, 
    pero con un valor inapropiado
"""

#PROGRAMA COMO EJEMPLO DE EXPECIONES
"""Creamos una función en donde cada elemento de 
una lista es dividida por un divisor definido"""
def divide_elementos_de_lista(lista, divisor):
    try: #Se refiere a con lo que vamos a tratar.
        return [i / divisor for i in lista]

    except ZeroDivisionError as e:
        """En la excepción de que ocurra un error de querer dividir por 0, entonces
        devuelve la lista. Except ayuda a que el programa no se caiga a pesar de
        que ocurrió un error."""
        print(e)
        return lista

    finally:
        print('El try (tratamiento) ya terminó.')
        """finally se utiliza cuando el try (tratamiento) terminó, sin importar
        si hay un error o no."""


lista = list(range(10))
divisor = 0

print(divide_elementos_de_lista(lista, divisor))

print("""
Vamos con otro ejemplo, ahora usando la keyword 'raise':""")

numero = 4
objetivo = 9

if numero < objetivo:
    raise Exception(f'¡{numero} es menor a {objetivo}!')

Notas 😃
Manejo de excepciones

• Es cuando ocurre un error en nuestro código. Son muy comunes en la programación. No tienen nada de excepcional.
• Las excepciones de Pthon normalmente se relacionan con errores de semántica.
• Se pueden crear excepciones propias.
• Cuando una excepción no se maneja (unhandled exception) el programa termina en error.
• Las excepciones se manejan con los keywords: try, except, finally.
• Se pueden utilizar también para ramificar programas.

def divide_elementos_de_lista(lista, divisor):
    try: 
        return [i/divisor for i in lista]
    except ZeroDivisionError as e:
        print(e)
        return lista

lista = list(range(10))
divisor = 0

print(divide_elementos_de_lista(lista, divisor))

• No deben manejarse de manera silenciosa (por ejemplo, con print statements).
• Para aventar tu propia excepción utiliza el keyword raise.

Manejo de excepciones
Son muy comunes en la programación. No tienen nada de excepcional.
Las excepciones de Python normalmente se relacionan con errores de semántica.
Se pueden crear excepciones propias.
Cuando una excepción no se maneja (unhandled exception), el programa termina en error.
¿Cómo manejas las excepciones?
keywords: try, except, finally.
Se pueden utilizar también para ramificar programas.
No deben manejarse de manera silenciosa (por ejemplo con print statements)
Para aventar tu propia excepción utilizar el keyword raise.

Ya casi llego Data Tree Gardener 😄

Hay que entender que son muchísimas excepciones y que cada una se tiene que escribir explícitamente, porque, de no hacerlo, muchas veces el programa no entiende que intentas hacer.

comparto la documentación sobre excepciones en Python https://docs.python.org/3/library/exceptions.html

Les comparto los apuntes de esta clase:

Clase 28, manejo de excepciones

• Son muy comunes en la programación. No tienen nada de excepcional.
• Las excepciones de Python normalmente se relacionan con errores de semántica.
• Se pueden crear excepciones propias.
• Cuando una excepción no se maneja (unhandled exception), el programa termina en error.

Manejo de excepciones:

• Se manejan con los keywords: try, except, finally.
• Se pueden utilizar para ramificar programas, no solo para errores.
• No deben silenciarse las excepciones, usando try y except e imprimir a la consola. Ejemplo, con print statements.
• Para aventar tu propia excepción utiliza el keyword raise.

No se pueden manejar los errores con if? por ejemplo si existe el error mostrar un tipo de flash?

Si dejan el except solo, cpturara todos los errores qeu puedan haber.

Buenas tardes.
Me quedó una duda en el primer ejemplo, con divisor=2.
¿Por qué los resultados son números flotantes?
Pensé que había que avisar cuando un número va a ser float.
Gracias

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.

Que son las excepciones: Las excepciones son cuando suceden errores en tu codigo

* Son muy comunes en la programacion. No tienen nada de exepcional
* Las excepciones de Python normalmente se relacionan con errores de semantica
* Se pueden crear excepciones propias
* Cuando una excepcion no se maneja (unhandlead excepcion) el programa termina en error

Manejo de excepciones:

* Las excepciones se manejan con keywords:

	* try: Permite que un bloque de codigo busque errores
	* except: Permite que el bloque de codigo maneje el error
	* finally:  Permite ejecutar codigo, independientemente del resultado de try y except
* Se pueden utilizan tambien para ramificar programas
* No deben manejarse de manera silenciosa (por ejemplo, con print statements)
* Para aventar tu propia exepcion utiliza el keyword

	* raise

Excepciones comunes:

* ImportError: una importación falla;
* IndexError: una lista se indexa con un número fuera de rango;
* NameError: se usa una variable desconocida ;
* SyntaxError: el código no se puede analizar correctamente
* TypeError: se llama a una función en un valor de un tipo inapropiado;
* ValueError: se llama a una función en un valor del tipo correcto, pero con un valor inapropiado

Manejo de Excepciones

Son muy comunes en la programación. no tienen nada de excepcional.

Las excepciones de python normalmente se relacionan con errores de semantinca

Se pueden crear excepciones propias

Cuando una excepción no se maneja(unhandled exception), el programa termina en error

Este ejemplo nos muestra la division de la siguiente funcion dividida entre 2

cuandro la dividimos entre 0 nos sale este error

cuando ponemos la funcion try}}

nos protege de cualquier error para el error ZerodivicionError

estos nos protege o avisa de cualquier error

Les comparto la documentación oficial de Python sobre manejo de excepciones, espero les ayuden. les recomiendo tenerla siempre presente para interpretar mejores los errores y damos con la solución mas rápido
https://docs.python.org/es/3/library/exceptions.html

De hecho, si quieres tener un poco de control con las excepciones en producción, siempre puedes manejar un archivo que sea una especie de log que lleve un registró de qué errores han sucedido y en dónde, también al manejar una excepción dentro de una función es bueno lanzar una alerta para que el usuario de la función sepa cual fue el error y pueda hacer algo al respecto ^^

'''Al momento de poner el cero, nos arroja un error ZeroDivisionError
de tal manera que, usamos una excepción.

Así que corre el programa normalmente, excepto cuando el numero sea cero, 
en ese caso solo muestrame la lista'''


def divide_elementos(lista, divisor):
    try:
        return [l / divisor for l in lista]
    except ZeroDivisionError as e:
        return lista

lista = list(range(10))
divisor = int(input('Escribe un numero: '))

print(divide_elementos(lista, divisor))

¿Cuándo conviene hacer excepciones a diferencia de proteger el código?
Me refiero que en el ejemplo de la clases, sin saber excepciones yo hubiera hecho algo así:
Resultado: [i/divisor for i in Lista if divisor>0]

excelente explicado

Las excepciones son casos particulares que pueden ocurrir dentro del flujo de datos y procesos de mi código. Se pueden generar cuando se ingresan parámetros no esperados dentro de las variables, los cuales pueden provocar errores al aplicar en dichos parámetros las operaciones definidas en el código.

Para evitar dichos errores, existen las excepciones. Para utilizarlas desde la “programación defensiva” simplemente se incluyen lineas de código en las cuales por medio de keywords como try, except, finally, especificando el caso particular para el cual se aplicará esa excepción (es decir, no se seguirá el flujo normal del proceso u operaciones sobre esos parámetros/variables ante determinado valor especifico). En su lugar, se presentará un mensaje predeterminado o un grupo de parámetros sin ser alterados por las operaciones establecidas en el código.

Excelente clase

def divide_elementos_de_lista(lista, divisor):

    try:

        return [i / divisor for i in lista]

    except ZeroDivisionError as e:
        print(e)
        return lista

lista = list(range(10))
divisor = 0
print(divide_elementos_de_lista(lista, divisor))```

Que bueno que el manejo de excepciones es muy similar a los demás lenguajes de programación!!!

Lo había manejado toda mi vida con if, no sabia de esta parte.
Que cool!!!

Team no termino de entender el concepto de “silenciar las excepciones”. Se dice que es una mala práctica, pero que acaso al final de la clase no estamos usando try y **except ** para imprimir el error?
Alguna sugerencia para entender mejor esto?

Agregue la excepción TypeError 😃

def divide_elementos_de_lista(lista, divisor):
    try:
        return [i / divisor for i in lista]
    except ZeroDivisionError as e:
        print(f"Error al dividir por 0: {e}")
        return lista
    except TypeError as e:
        print(f"Error tipo de dato erroneo: {e}")
        return lista


def run():
    lista = list(range(10))
    # divisor = 0
    # divisor = "f"
    divisor = 2
    print(divide_elementos_de_lista(lista, divisor))


if __name__ == '__main__':
    run()

def divide_elementos_de_lista(lista, divisor):
    try:
        return [i / divisor for i in lista]
    except ZeroDivisionError as e:
        print(e)
        return lista


lista = list(range(10))
divisor = 0

print(divide_elementos_de_lista(lista, divisor))

Manejo de excepciones:
🤖🤖🤖
Los manejos de excepciones son muy comunes en la programación, no tienen nada de excepcional. Las excepciones de Python normalmente se relacionan con errores de semántica, también podemos crear nuestras propias excepciones, pero cuando una excepción no se maneja (unhandled exception), el programa termina en error.
🤖
Las excepciones se manejan con los keywords: try, except, finally. Se pueden utilizar también para ramificar programas.
🤖
No deben manejarse de manera silenciosa (por ejemplo, con print statements). Para crear tu propia excepción utiliza el keyword raise.

hola comunidad!!!
Estoy usando VScode como editor para este curso pero estoy teniendo muchos problemas con mi código, ya que me marca muchos errores de indentacion, busque en internet pero sigo sin poder solucionarlo, se que es un problema con el tab y los espacios, pero no se si exista algún pluggin o configuración para ya no tener estos problemas:

File “excepsions.py”, line 4
except ZeroDivisionError as e:
^
IndentationError: unindent does not match any outer indentation level

no es la primera vez que em ocurre este error y me estoy atorando mucho en el curso.
espero me puedan ayudar.
gracias.

Me gustó la clase, pero si no pudieron entender aquí les dejo un vídeo que de seguro os ayudará: link

Errores y excepciones

‎

‎ ‏‏‎
Existen dos tipos diferentes de errores dentro de python: errores de sintaxis y excepciones.

‎ ‏‏‎

Errores de sintaxis:

Los errores de sintaxis, también conocidos como los errores de interpretación, son quizás el tipo de error más común cuando aún estas aprendido sobre Python:
‎ ‏‏‎

El intérprete señala la línea responsable del error e indica una pequeña flecha, que apunta al lugar donde se detectó el error. En este caso el error es porque faltaría antes del print() los dos puntos (' : '). Además se muestran el nombre del archivo y el número de la línea a con posterioridad consultar.

‎ ‏‏‎

Excepciones:

Los errores detectados después de pasar la prueba de sintaxis pero durante la ejecución del programa se llaman excepciones o errores lógicos. Por ejemplo, este tipo de errores pasan desde dividir un número por 0 hasta la importación de un módulo inexistente. Estas excepciones necesitan ser manejadas por el programa, de no hacerlo, y siendo esta incapacidad del programa mayoritaria en los casos, dan como output mensajes de error como los siguientes:
‎ ‏‏‎

La última línea en cada >>> detalla el error que surgió. Las excepciones son de diferentes tipos y el tipo de excepción se imprime como parte del mensaje: los tipos en el ejemplo son ZeroDivisionError, NameError y TypeError: estos nombres de errores son identificadores integrados, no keywords.
‎ ‏‏‎
Referencias

• Una excepción es cuando sucede un error en el código.
• Son muy comunes en la programación. No tienen nada de excepcional.
• Las excepciones de Python normalmente se relacionan con errores de semántica.
• Se pueden crear excepciones propias.
• Cuando una excepción no se maneja (unhandled exception), el programa termina en error.

• Las excepciones se manejan con los keywords: try, except, finally.
• Se pueden utilizar también para ramificar programas.
• No debe manejarse de manera silenciosa (por ejemplo, con print statements).
• Para arrojar tu propia excepción utiliza el keyword raise.

• ImportError: Una importación falla.
• IndexError: Una lista se indexa con un número fuera de rango.
• NameError: Se usa una variable desconocida.
• SyntaxError: El código no se puede analizar correctamente.
• TypeError: Se llama a una función en un valor de un tipo inapropiado.
• ValueError: Se llama a una función en un valor del tipo correcto, pero con un valor inapropiado.
• ZeroDivisionError: Dividir entre 0.

try:
	# tu código
except:
	# En caso de error 
else:
	# si no hay error coore otro código
finally:
	# corre el código sin errores o con errores

Las Excepciones son a Python como el SI.ERROR es a Excel.

def divide_elementos_de_lista(lista, divisor):
    try:
        return [i / divisor for i in lista]
    except ZeroDivisionError as e:
        print(e) #e representa el error que incluye la excepción ZeroDivisionError
        return lista

lista = list(range(10))
divisor = 0

print(divide_elementos_de_lista(lista, divisor))

Gracias por el aporte.

[0:45] La mayoria de las excepciones se relacionan con errores de semántica. Por ejemplo las de tipo, de división, operaciones que no son compatibles, etc.

[1:04] Se pueden crear excepciones propias. Cuando una excepción no se maneja (unhandled exception), el programa termina en error.

Manejo de excepciones: son muy comunes en la programación. No tienen nada excepcional.

En JS no da error dividir por 0 por el contrario da la respuesta matemática: infinito

Las Excepciones son una estructura de control que implementan ciertos lenguajes de programación con el objetivo de manejar condiciones “anormales” o no esperadas dentro del programa que normalmente impedirían el continuo desarrollo del programa, pero que pueden ser tratados en el mismo curso del programa.

Una buena practica para evitar errores, a pensar en posibles fallos

cual es la diferencia entre usar
return [i/divisor for i in lista]
y
for i in lista
	yield i/divisor

[1:11] Las excepciones se manejan con tres keywords nuevos: try, except, finally.

[1:59] Una pésima practica es silenciar tus excepciones, es decir que en lugar de manejar el error lo imprimes a la consola.

[4:44] Para manejar una excepción tenemos dos opciones, podemos poner el try except fuera de la función, o ponerlo dentro y hacer algo de programación defensiva: yo se que voy a dividir y un error muy comun es que alguien envie un cero.

vaya hasta 1 semana tratando de solucionar un bug!!!

def divide_elementos_de_lista(lista, divisor):
    try:
        return [i / divisor for i in lista]
    except ZeroDivisionError as e:
        print(e)
        return lista


lista = list(range(10))
divisor = 0 #divisor de entrada

print(divide_elementos_de_lista(lista, divisor))```

El keyword finally se usa generalmente para liberar fuentes externas (Archivos, Interfaces, Servers, Etc…)

Por ejemplo:

try:
   f = open("test.txt")
   # Operaciones con el archivo
finally:
   f.close()

Alguien conoce otro uso?

Y “finally” dónde queda?

Clave: Siempre pensar en los caminos malos, con errores, fallas para asi defender tu algoritmo y hacerlo robusto.

try para tener un retorno del erro
except para una exception

Cuando no manejas las excepciones: Resplandor y hace pum!

Nunca había entendido el try hasta ahora. Muy buena clase!

Muy buena clase.

Muy bueno!

Esto se me ocurre que puede ser útil cuando estás haciendo un programa de análisis de datos, en mi caso de energía.

Por las noches obtienes cero de generación.

Yo entiendo que las excepciones son acciones con ciertos parametros que hacen que tengan error justo en ese espacio,
Algo asi como la singularidad en fisica no? Todo el universo funciona de manera ordenada pero cuando se llega a los agujeros negros las ecuaciones fallan.

Corrijanme si me equivoco porfavor

Buena herramienta las execepciones. i3

def divide_elementos_de_la_lista(lista, divisor):
    try:
        return[i/divisor for i in lista]
    except ZeroDivisionError as e:
        print(e)
        return lista

lista =list(range(10))
divisor=1
print(f'elementos: {divide_elementos_de_la_lista(lista,divisor)}')

En qué otros casos se manejan las excepciones?

Código con buenas prácticas explicadas en clase:

el manejo de errores es muy importante tener en cuenta y mas cuando el proyecto cada vez va escalando mas

def division_de_lista(lista, divisor):
    try:
        return [i / divisor for i in lista]
    except ZeroDivisionError as e:
        print(e)
        return lista


lista = list(range(10))
divisor = 0

print(division_de_lista(lista, divisor))

def divide_elementos_lista(lista,divisor):
try:
return [i/divisor for i in lista ]
except ZeroDivisionError as e:
print(e)
return lista

lista=list(range(10))
divisor=0

print(divide_elementos_lista(lista, divisor))

Muy importante lo del manejo de exepciones, durante mi experiencia me he dado cuenta que hay excepciones que pueden llegar a tumbar el servidor o dejar sin recursos la memoria del servidor y mas aún cuando implican la gestión de un archivo o la gestión de una base de datos.

Ademas hubiera sido muy gratificante que el profesor hubiera dado un ejemplo de como hacer excepciones propias para este lenguaje.

def divide_list_elements(list,dividend):
    try:
        return [i/dividend for i in list]
    except ZeroDivisionError as e:
        return list


data_list = list(range(5))
zero = 0
two = 2

print(divide_list_elements(data_list,two))
print(divide_list_elements(data_list,zero))

porque cuando hago la division por 1 me da como resultado 1.0 , 2.0 , 3.0 …
y cuando lo hago divisor por cero me da 1, 2, 3 …

“”“Creamos una funcion en donde cada elemento de la lista
lo divide un elemento unico”""

def divide_elementos_de_lista(lista,divisor):
return [i / divisor for i in lista]

lista = list(rnage(10))
divisor = 0

print (divide_elementos_de_lista(lista,divisor))

Fundamental que manejemos excepciones en nuestros programas particularmente cuando trabajamos en grupos de trabajo.

Programación defensiva

Manejo de excepciones:

• Manejo de los errores del codigo
• Son muy comunes el la programacion
• La moyoria de excepciones por defecto son de semantica (tipo, division, operaciones incompatibles, etc)
• Podemos crear nuestras propias excepciones
• Si la excepciones no se manejan el programa termina

keywords de manejo de excepciones:

• Se manejan con los keywords: try, except, finally.
• Estos keywords pueden ramificar programas
• Para generar tus propias excepciones se usa el keyword raise

Nota:
Es mala practica silenciar las excepciones (ejemplo imprimirlas en consola)

Sintaxis:
-try/exept

try:
	<expresiones>
except <nombre_error> as <variable>:
	<expresiones_caso_error>

-raise:

raise <nombre_error> ("<mensaje>")

Cuando hablamos de excepciones en programación, pasa todo el tiempo x.x y dependiendo del lenguaje, en Python normalmente son en semántica. Y hasta podemos crear Excepciones propias. Pero habrá que tener cuidado para que el programa no termine en error.

Manejo de excepciones

• Se maneja con try, except y finally.
• Se pueden utilizar para ramificar programas.
• No deben manejarse de manera silenciosa, es decir con Print Statemens, recuerda que esto es para buscar bugs no para taparlos
• Para lanzar tu propia excepción utiliza raise.

#este es un programa normal que divide entre dos todos los elementos de una lista
#lo el problema viene cuando divisor = 0 porque en Python eso nos regresa error
#cuando corre y nos regresa el error en consola responde con el nombre del error
#en este caso el nombre del error es ZeroDivisionError

#la idea aqui es poder utilizar try y except para manejar el error
#es muy parecido a una promesa
def divide_elementos_de_lista(lista, divisor):
	return [i / divisor for i in lista]

lista = list(range(10))
divisor = 0
#divisor = 2
print(divide_elementos_de_lista(lista, divisor))

#usamos try para correr nuestro mensaje por defecto pero en el caso de que sea
#regresado un error pues será manejado por except
def divide_elementos_de_lista(lista, divisor):
  try:
    return [i / divisor for i in lista]
	
  #en except decimos que en caso de recibir este error, regresaremos la lista
	#que obtuvimos al principio, es decir lista
	#con fines didacticos impimimos el error en consola para verlo
  except ZeroDivisionError as error:
    print(error)
    return lista

lista = list(range(10))
divisor = 0
print(divide_elementos_de_lista(lista, divisor))

Hola comunidad! alguien que me pueda orientar en como corregir esto en mi código se lo agradecería mucho

Acá mi versión del código!

def division(lista, divisor):
    try:
        return [i / divisor for i in lista]
    except ZeroDivisionError as error:
        print(f'The error is: {error}')
        return lista

if __name__ == '__main__':
    lista = list(range(10))
    divisor = int(input('Escribe un numero: '))

    print(division(lista, divisor))

Este código para pedir un numero al usuario usa try/except para capturar una excepción de tipo ValueError en caso de que no se introduzca un entero. 😃

""" Metodo para pedir y validar que un valor introducido es numérico y con la opción que pedir un numero positivo.  """

def pedir_numero_validado(positivo = False):
    validado = False
    while validado != True:
        try:
            value = int(input('Introduce el valor: '))
            if positivo:
                if value >= 0:
                    validado = True
                    return value
                else:
                    print('Debes introducir un numero positivo')
            else:
                validado = True
                return value
        except ValueError:
            print ("Debes introducir un numero")```

Hola, con este codigo pueden escoger el divisor en la con consola en vez de en las lineas de codigo, espero les sirva o al menos de ejemplo

def divide_elementos_de_lista(lista, divisor):
    try:
        return [i  / divisor for i in lista]
    except ZeroDivisionError as e:
        print(e)
        return lista

lista = list(range(10))
divisor = 0


print(divide_elementos_de_lista(lista, divisor))```

no conocia reise

seria bueno que dejaran algun link para hacer ejercicios.

Good class!