1. 1 - Buenas prácticas: Control de errores, pruebas y validación de datos en Python
2. 2 - Control de errores.
3. 3 - Errores de sintaxis.
4. 4 - Errores lógicos.
5. 5 - Excepciones en Python.
6. 6 - Excepciones definidas por el usuario.
7. 7 - Pruebas para validar de datos.
8. 8 - La programacio defensiva.
9. 9 - Técnicas de programación defensiva.

Buenas prácticas: Control de errores, pruebas y validación de datos en Python

En el desarrollo de código, de software, es fundamental asegurarse de que nuestro programa funcione correctamente y maneje adecuadamente los errores que puedan surgir durante su ejecución. En Python, existen varias buenas prácticas para el control de errores, pruebas y validación de datos que nos ayudarán a crear código más robusto y confiable.

Control de errores.

Normalmente una de las cosas que hacemos para trabajar con errores, como control de errores, es usar por ejemplo print en el caso de python o console.log en el caso de JavaScript para ver qué está pasando en nuestro código. Pero esto no es una buena práctica, ya que no nos permite manejar los errores de manera adecuada.

En el código tenemos dos tipos de errores que podemos encontrar:

• Errores de sintaxis.
• Errores lógicos.

Errores de sintaxis.

Tipo de errores que nos encontramos cuando empezamos a escribir código. Estos errores muestran un mensaje donde nos indica que o bien no se ha escrito correctamente, un comando de Python que por algún motivo nos estamos saltando las reglas de Python. Por ejemplo si nos olvidamos de poner dos puntos al final de una estructura de control como un if, for, while, etc. O si no cerramos un paréntesis, una comilla, etc.

# Ejemplo de error de sintaxis
if True
   print("Hola Mundo")

Al ejecutar este código, Python nos mostrará un mensaje de error indicando que hay un error de sintaxis.

File "script.py", line 2
   if True
            ^
SyntaxError: invalid syntax

Errores lógicos.

Los errores lógicos son aquellos que ocurren cuando el código se ejecuta sin problemas, pero el resultado no es el esperado. Estos errores son más difíciles de detectar, ya que no generan mensajes de error. Por ejemplo, si estamos realizando una operación matemática y nos equivocamos en el orden de los operadores, el resultado será incorrecto.

# Ejemplo de error lógico
a = 10
b = 5
resultado = a - b * 2  # Debería ser (a - b)
print(resultado)  # Salida: 0, pero debería ser 5

Para manejar estos errores, es importante realizar pruebas y validaciones en nuestro código.

Excepciones en Python.

En Python, podemos manejar los errores utilizando bloques try y except. Esto nos permite capturar las excepciones que puedan ocurrir durante la ejecución del código y manejar los errores de manera adecuada.

El esquema de un bloque try-except es el siguiente:

try:
   # Código que puede generar una excepción
   ...
except TipoDeExcepcion:
   # Manejo de la excepción
   ...
except TipoDeExcepcion2:
   # Manejo de otra excepción
   ...
else:
   # Código que se ejecuta si no hay excepciones
   ...
finally:
   # Código que se ejecuta siempre, haya o no excepciones
   ...

Por ejemplo, supongamos que queremos dividir dos números, pero el divisor puede ser cero, lo que generaría una excepción. Podemos manejar esta situación de la siguiente manera:

try:
   # Código que puede generar una excepción
   resultado = 10 / 0
except ZeroDivisionError:
   # Manejo de la excepción
   print("Error: División por cero no permitida.")

En este ejemplo, si intentamos dividir por cero, se generará una excepción ZeroDivisionError, y el bloque except se ejecutará, mostrando un mensaje de error en lugar de detener la ejecución del programa. Pero podemos manejar múltiples excepciones de la siguiente manera:

try:
   # Código que puede generar una excepción 
   numero = int(input("Ingrese un número: "))
   resultado = 10 / numero
except ZeroDivisionError:
   # Manejo de la excepción de división por cero
   print("Error: División por cero no permitida.")
except ValueError:
   # Manejo de la excepción de valor inválido
   print("Error: Entrada inválida. Por favor, ingrese un número válido.")

En este caso, si el usuario ingresa un valor no numérico, se generará una excepción ValueError, y el bloque correspondiente se ejecutará.

Excepciones definidas por el usuario.

Es una opción bastante intersante que nos ofrece Python, y es la posibilidad de definir nuestras propias excepciones personalizadas. Esto es útil cuando queremos manejar errores específicos de nuestra aplicación. Podemos crear una clase que herede de la clase Exception y definir nuestra propia excepción. Por ejemplo:

class MiExcepcionPersonalizada(Exception):
   pass
def dividir(a, b):
   if b == 0:
      raise MiExcepcionPersonalizada("Error: División por cero no permitida.")
   return a / b  
try:
   resultado = dividir(10, 0)
except MiExcepcionPersonalizada as e:
   print(e)

En este ejemplo, hemos definido una excepción personalizada llamada MiExcepcionPersonalizada y la hemos utilizado en la función dividir. Si el divisor es cero, se genera nuestra excepción personalizada, y podemos manejarla en el bloque except.

Pruebas para validar de datos.

La validación de datos es una técnica que nos permite validar la entrada de datos en nuestras aplicaciones. Este tipo de técnicas se han convertido en una herramienta muy buena para todo programador, ya que nos permite asegurarnos de que los datos que estamos recibiendo son correctos y cumplen con ciertos requisitos. Existen varias formas de validar datos en Python:

• Comprobando el contenido del dato: que una variable sea de un tipo en particular (entero, cadena, lista, etc.).
• Que el dato tenga una característica específica: que un número esté dentro de un rango, que una cadena tenga una longitud mínima o máxima, etc. Tenemos que tener en cuenta que debemos pensar la forma de actuar o poder responder a las posibles alarmas que indique que algo no va bien, ya que es también nuestro objetivo mostrar información de interés al usuario que le ayude a dectectar y solucionar el problema. A esta técnica se le conoce como programación defensiva.

La programacio defensiva.

LA programación defensiva busca la mejora del software y su código fuente antendiendo a tres criterios fundamentales:

1. Calidad: Adoptar medidas de programación defensiva ayuda a mejorar la calidad del software, ya que se reducen los errores y se aumenta la robustez del código.
2. Interpretabilidad: El código defensivo suele ser más claro y fácil de entender, lo que facilita su mantenimiento y evolución.
3. Mantenibilidad: Al anticipar posibles errores y manejar excepciones de manera adecuada, el código defensivo es más fácil de mantener y actualizar a lo largo del tiempo.

Técnicas de programación defensiva.

Hay varias técnicas de porgramación defensiva que un desarrollador puede usar para mejorar la calidad de su código. Algunas de las más comunes son:

1. Revisión de código fuente: Una revisión del código se refiere al que alguien que no sea el que ha escrito el código realice una auditoría del msimo. Es conveniten que la auditoría lo haga alguien ageno al proyecto o al equipo de desarrollo, ya que esto permite tener una visión más objetiva y crítica del código.
2. Pruebas de software: Las pruebas de software son una técnica fundamental de la programación defensiva. Consisten en ejecutar el código con diferentes entradas y condiciones para verificar que funciona correctamente y detectar posibles errores.
3. Reducir al complegidad: Crear un código con muchas implementaciones y funcionalidades complejas puede dificultar su comprensión y mantenimiento. Es recomendable dividir el código en funciones y módulos más pequeños y sencillos, lo que facilita su comprensión y mantenimiento.
4. Reutilización de código: Evitar la duplicación de código es una buena práctica de programación defensiva. Si se detecta que se está repitiendo el mismo código en diferentes partes del programa, es recomendable crear una función o módulo que encapsule esa funcionalidad y reutilizarlo en lugar de duplicarlo.
5. Problemas de legado: Antes de reutiulizar código fuente antiguo, es recomendable revisar su calidad y adaptarlo a las nuevas necesidades del proyecto. El código legado puede contener errores o malas prácticas que pueden afectar la calidad del software.