Lección Python

# Intento de división por cero (genera ZeroDivisionError)
numero = 10
divisor = 0
resultado = numero / divisor
print(f'El resultado es: {resultado}')

# Intento de sumar número y cadena
numero = 5
texto = 'Hola'
resultado = numero + texto
print(resultado)

try:
    numero = 10
    divisor = 0
    resultado = numero / divisor
    print(f'El resultado es: {resultado}')
except ZeroDivisionError:
    print('Error: No se puede dividir por cero')
print('El programa continúa ejecutándose')

def operacion_segura(a, b):
    try:
        resultado = int(a) / int(b)
        return f'Resultado: {resultado}'
    except ValueError:
        return 'Error: Valores no numéricos'
    except ZeroDivisionError:
        return 'Error: División por cero'

print(operacion_segura('10', '2'))
print(operacion_segura('abc', '5'))
print(operacion_segura('8', '0'))

def leer_archivo(nombre_archivo):
    archivo = None
    try:
        archivo = open(nombre_archivo, 'r')
        contenido = archivo.read()
        print(f'Archivo leído exitosamente')
    except FileNotFoundError as e:
        print(f'Error: Archivo no encontrado - {e}')
    except PermissionError:
        print('Error: Sin permisos para leer el archivo')
    else:
        print('Operación completada sin errores')
    finally:
        if archivo:
            archivo.close()
        print('Recursos liberados')

leer_archivo('archivo_inexistente.txt')

def procesar_datos(datos):
    try:
        # Simulamos operaciones que pueden fallar
        if not datos:
            raise ValueError('Los datos están vacíos')
        resultado = sum(datos) / len(datos)
        return resultado
    except (TypeError, ValueError) as e:
        print(f'Error de datos: {type(e).__name__}: {e}')
        return None
    except Exception as e:
        print(f'Error inesperado: {type(e).__name__}: {e}')
        return None

print(procesar_datos([1, 2, 3, 4]))
print(procesar_datos([]))
print(procesar_datos('no es lista'))

class EdadInvalidaError(Exception):
    '''Excepción levantada cuando la edad es inválida'''
    def __init__(self, edad, mensaje='Edad fuera del rango válido'):
        self.edad = edad
        self.mensaje = mensaje
        super().__init__(self.mensaje)

def validar_edad(edad):
    if edad < 0 or edad > 150:
        raise EdadInvalidaError(edad, f'La edad {edad} no es válida')
    return f'Edad válida: {edad} años'

try:
    print(validar_edad(25))
    print(validar_edad(200))
except EdadInvalidaError as e:
    print(f'Error personalizado: {e.mensaje}')
    print(f'Edad problemática: {e.edad}')

class BancoError(Exception):
    '''Excepción base para errores bancarios'''
    pass

class SaldoInsuficienteError(BancoError):
    '''Error cuando no hay suficiente saldo'''
    def __init__(self, saldo_actual, monto_solicitado):
        self.saldo_actual = saldo_actual
        self.monto_solicitado = monto_solicitado
        super().__init__(f'Saldo insuficiente: tienes ${saldo_actual}, necesitas ${monto_solicitado}')

class CuentaBloqueadaError(BancoError):
    '''Error cuando la cuenta está bloqueada'''
    pass

def retirar_dinero(saldo, monto, cuenta_activa=True):
    if not cuenta_activa:
        raise CuentaBloqueadaError('La cuenta está bloqueada')
    if monto > saldo:
        raise SaldoInsuficienteError(saldo, monto)
    return saldo - monto

try:
    nuevo_saldo = retirar_dinero(100, 150)
except SaldoInsuficienteError as e:
    print(f'Error de saldo: {e}')
except BancoError as e:
    print(f'Error bancario: {e}')

import logging
from contextlib import contextmanager

# Configuración básica de logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class DatabaseError(Exception):
    pass

@contextmanager
def conexion_database():
    '''Simula una conexión a base de datos'''
    logger.info('Estableciendo conexión a la base de datos')
    try:
        # Simular conexión
        conexion = {'conectado': True}
        yield conexion
    except Exception as e:
        logger.error(f'Error en operación de base de datos: {e}')
        raise DatabaseError(f'Falla en base de datos: {e}')
    finally:
        logger.info('Cerrando conexión a la base de datos')

def operacion_critica():
    try:
        with conexion_database() as db:
            if not db['conectado']:
                raise DatabaseError('Conexión fallida')
            logger.info('Operación completada exitosamente')
            return 'Datos procesados'
    except DatabaseError as e:
        logger.error(f'Error crítico: {e}')
        return None

resultado = operacion_critica()
print(f'Resultado: {resultado}')