clase3_material_para_practicar_y_repasar.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Agenda\n",
        "\n",
        "1. Funciones: creación, pasando argumentos por valor y referencia, retorno de valores, variables locales y globales\n",
        "\n",
        "2. Manejo de errores y excepciones: error, excepción, uso de depurador, pila de llamadas\n",
        "\n",
        "3. Módulos y paquetes: importación, creación\n",
        "\n",
        "4. Manejo de archivos: lectura, escritura\n",
        "\n",
        "5. Recursividad"
      ],
      "metadata": {
        "id": "97zzQmYMq8iz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 1. Funciones\n",
        "\n",
        "## A.  Introducción: Funciones Matemáticas vs. Funciones en Programación\n",
        "\n",
        "En **matemáticas**, una función $f$ es una relación entre un conjunto de entrada $D\\neq ∅$ y un conjunto de salida posibles $f(D)$, donde cada entrada está relacionada exactamente con una salida (punto a punto), es decir,\n",
        "\n",
        "$$\\begin{eqnarray}\n",
        "f : D &\\longrightarrow & f(D) \\\\\n",
        "    x &\\longmapsto & f(x)\n",
        "\\end{eqnarray}$$\n",
        "\n",
        "### Ejemplo:\n",
        "Dado $D=\\mathbb{Z}$, sea la función  \n",
        "\n",
        "$$\\begin{eqnarray}\n",
        "f : \\mathbb{Z} &\\longrightarrow & f(\\mathbb{Z}) \\\\\n",
        "    z &\\longmapsto & f(z) = 2z+1\n",
        "\\end{eqnarray}$$\n",
        "\n",
        "### Observación:\n",
        "* ¿Qué podemos decir de $f$ si va de punto a conjunto?\n",
        "* ¿Qué podemos decir de $f$ si va de conjunto a punto?\n",
        "\n",
        "\n",
        "Por otro lado, en **programación**, *una función es un bloque de código reutilizable que realiza una tarea específica*. Puede tomar entradas (parámetros) únicas o múltiples, realizar operaciones y devolver un resultado o varios, pero también puede realizar acciones sin necesariamente devolver un valor.\n",
        "\n",
        "## B. Funciones en Python\n",
        "\n",
        "En Python, las funciones ofrecen:\n",
        "\n",
        "* Flexibilidad en la definición de parámetros\n",
        "* Capacidad de retornar múltiples valores\n",
        "* Soporte para funciones anónimas (lambda)\n",
        "* Decoradores para modificar el comportamiento de las funciones\n",
        "* Generadores para crear secuencias de manera eficiente\n",
        "\n",
        "Las funciones en Python sirven para:\n",
        "\n",
        "* Dividir problemas complejos en tareas más pequeñas y manejables\n",
        "* Crear bibliotecas y módulos reutilizables\n",
        "* Implementar algoritmos y lógica de negocio\n",
        "* Manejar eventos en programación orientada a objetos\n",
        "\n",
        "Con las funciones en Python, puedes:\n",
        "\n",
        "* Procesar datos\n",
        "* Realizar cálculos complejos\n",
        "* Interactuar con el sistema operativo\n",
        "* Crear interfaces de usuario\n",
        "* Implementar operaciones de entrada/salida\n",
        "* Gestionar bases de datos\n",
        "* Y mucho más...\n",
        "\n",
        "### Definición y sintaxis\n",
        "\n",
        "* Una función es un bloque de código reutilizable que realiza una tarea específica.\n",
        "* Para definir una función en Python, se utiliza la palabra clave <font color='blue'>def</font> seguida del nombre de la función y paréntesis <font color='blue'>()</font>.\n",
        "* Opcionalmente, puedes especificar parámetros dentro de los paréntesis.\n",
        "* El bloque de código de la función se escribe indentado después de los dos puntos <font color='blue'> : </font>.\n",
        "\n",
        "La sintaxis  es:\n",
        "~~~python\n",
        "def nombre_funcion(parametro1, parametro2, ...):\n",
        "    \"\"\"Docstring: Descripción de la función\"\"\"\n",
        "    # Cuerpo de la función\n",
        "    # Instrucciones\n",
        "    return valor  # Opcional\n",
        "~~~\n",
        "\n",
        "### Llamada a funciones\n",
        "Para llamar a una función, simplemente escribe el nombre de la función seguido de paréntesis <font color='blue'>()</font> y los argumentos necesarios (si los hay).\n",
        "\n",
        "~~~python\n",
        "resultado = nombre_funcion(argumento1, argumento2, ...)\n",
        "~~~\n",
        "\n",
        "### Parámetros y argumentos\n",
        "* Los parámetros son variables definidas en la definición de la función y se utilizan para recibir valores cuando se llama a la función.\n",
        "* Los argumentos son los valores reales que se pasan a la función cuando se la llama.\n",
        "\n",
        "~~~python\n",
        "def saludar(nombre):\n",
        "    \"\"\"Esta función saluda a la persona pasada como parámetro (nombre).\"\"\"\n",
        "    return f\"Hola, {nombre}! Bienvenido al curso intensivo de Python.\"\n",
        "\n",
        "# Uso de la función\n",
        "mensaje = saludar(\"Clifford\")\n",
        "print(mensaje)  # Salida: Hola, Clifford! Bienvenido al curso intensivo de Python.\n",
        "~~~\n",
        "\n",
        "#### Observación:\n",
        "- En Python, la distinción entre **paso por valor** y **paso por referencia** no es exactamente como en otros lenguajes de programación.\n",
        "- Python utiliza un mecanismo que se conoce como \"paso por asignación\" o \"call by object reference\".\n",
        "- Sin embargo, podemos ilustrar comportamientos similares a lo que se entiende tradicionalmente como paso por valor y paso por referencia.\n",
        "\n",
        "##### Comportamiento similar al \"paso por valor\":\n",
        "\n",
        "En Python, los tipos de datos inmutables (como int, float, str, tuple) se comportan de manera similar al paso por valor.\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "~~~python\n",
        "def modificar_numero(x):\n",
        "    x += 10\n",
        "    print(\"Dentro de la función:\", x)\n",
        "\n",
        "numero = 5\n",
        "print(\"Antes de la función:\", numero)\n",
        "modificar_numero(numero)\n",
        "print(\"Después de la función:\", numero)\n",
        "\n",
        "#Salida\n",
        "#Antes de la función: 5\n",
        "#Dentro de la función: 15\n",
        "#Después de la función: 5\n",
        "~~~\n",
        "\n",
        "#### Comportamiento similar al \"paso por referencia\":\n",
        "\n",
        "Los tipos de datos mutables (como list, dict, set) se comportan de manera similar al paso por referencia.\n",
        "\n",
        "~~~python\n",
        "def modificar_lista(lista):\n",
        "    lista.append(4)\n",
        "    print(\"Dentro de la función:\", lista)\n",
        "\n",
        "mi_lista = [1, 2, 3]\n",
        "print(\"Antes de la función:\", mi_lista)\n",
        "modificar_lista(mi_lista)\n",
        "print(\"Después de la función:\", mi_lista)\n",
        "\n",
        "#Salida\n",
        "#Antes de la función: [1, 2, 3]\n",
        "#Dentro de la función: [1, 2, 3, 4]\n",
        "#Después de la función: [1, 2, 3, 4]\n",
        "~~~\n",
        "\n",
        "#### Comportamiento mixto:\n",
        "\n",
        "~~~python\n",
        "def modificar_valores(x, lista):\n",
        "    x += 10\n",
        "    lista.append(4)\n",
        "    print(\"Dentro de la función - x:\", x, \"lista:\", lista)\n",
        "\n",
        "numero = 5\n",
        "mi_lista = [1, 2, 3]\n",
        "print(\"Antes de la función - numero:\", numero, \"mi_lista:\", mi_lista)\n",
        "modificar_valores(numero, mi_lista)\n",
        "print(\"Después de la función - numero:\", numero, \"mi_lista:\", mi_lista)\n",
        "\n",
        "#Salida\n",
        "#Antes de la función - numero: 5 mi_lista: [1, 2, 3]\n",
        "#Dentro de la función - x: 15 lista: [1, 2, 3, 4]\n",
        "#Después de la función - numero: 5 mi_lista: [1, 2, 3, 4]\n",
        "~~~\n",
        "\n",
        "### Valor de retorno\n",
        "* Una función puede devolver un valor utilizando la palabra clave <font color='blue'>return</font>.\n",
        "* Si no se especifica un valor de retorno, la función devuelve <font color='blue'>None</font> por defecto.\n",
        "\n",
        "~~~python\n",
        "def cuadrado(x):\n",
        "    return x ** 2\n",
        "\n",
        "resultado = cuadrado(5)  # resultado = 25\n",
        "~~~\n",
        "\n"
      ],
      "metadata": {
        "id": "d_JgeZv1rWek"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Ejemplos:\n",
        "\n",
        "1. Crea una función llamada ``calcular_promedio`` que reciba una lista de números como argumento y retorne el promedio de esos números.\n",
        "\n",
        "    <details><summary>Ver la solución</summary>\n",
        "\n",
        "    ~~~python\n",
        "    def calcular_promedio(numeros):\n",
        "        total = sum(numeros)\n",
        "        promedio = total / len(numeros)\n",
        "        return promedio\n",
        "\n",
        "    notas = [85, 92, 78, 90, 88]\n",
        "    promedio_notas = calcular_promedio(notas)\n",
        "    print(\"El promedio de las notas es:\", promedio_notas)\n",
        "    ~~~\n",
        "    </details>\n",
        "\n",
        "2. Crea una función llamada ``eliminar_duplicados`` que reciba una lista como argumento y retorne una nueva lista sin elementos duplicados, sin modificar la lista original.\n",
        "\n",
        "    <details><summary>Ver la solución</summary>\n",
        "\n",
        "    ~~~python\n",
        "    def calcular_promedio(numeros):\n",
        "        total = sum(numeros)\n",
        "        promedio = total / len(numeros)\n",
        "        return promedio\n",
        "\n",
        "    notas = [85, 92, 78, 90, 88]\n",
        "    promedio_notas = calcular_promedio(notas)\n",
        "    print(\"El promedio de las notas es:\", promedio_notas)\n",
        "    ~~~\n",
        "    </details>\n",
        "\n",
        "3. Crea una función llamada ``calcular_estadisticas`` que reciba una lista de números y retorne la suma, el promedio, el valor mínimo y el valor máximo de la lista.\n",
        "\n",
        "    <details><summary>Ver la solución</summary>\n",
        "\n",
        "    ~~~python\n",
        "    def calcular_estadisticas(numeros):\n",
        "        suma = sum(numeros)\n",
        "        promedio = suma / len(numeros)\n",
        "        minimo = min(numeros)\n",
        "        maximo = max(numeros)\n",
        "        return suma, promedio, minimo, maximo\n",
        "\n",
        "    datos = [10, 5, 8, 12, 3]\n",
        "    resultados = calcular_estadisticas(datos)\n",
        "    print(\"Suma:\", resultados[0])\n",
        "    print(\"Promedio:\", resultados[1])\n",
        "    print(\"Mínimo:\", resultados[2])\n",
        "    print(\"Máximo:\", resultados[3])\n",
        "    ~~~\n",
        "    </details>\n",
        "\n",
        "#### Ejercicios:\n",
        "\n",
        "1. Escribe una función llamada ``es_par`` que tome un número como parámetro y devuelva ``True`` si el número es par y ``False`` si es impar.\n",
        "2. Crea una función llamada ``calcular_factorial`` que tome un número entero positivo como parámetro y devuelva su factorial. El factorial de un número ``n`` se define como el producto de todos los números enteros positivos desde 1 hasta ``n``. Por ejemplo, el factorial de 5 es 5 * 4 * 3 * 2 * 1 = 120.\n",
        "3. Escribe una función llamada ``contar_vocales`` que tome una cadena de texto como parámetro y devuelva la cantidad de vocales que contiene. Considera tanto mayúsculas como minúsculas.\n",
        "4. Crea una función llamada ``es_palindromo`` que tome una cadena de texto como parámetro y devuelva ``True`` si la cadena es un palíndromo (se lee igual de izquierda a derecha que de derecha a izquierda) y ``False`` en caso contrario. Por ejemplo, \"radar\" y \"ana\" son palíndromos.\n",
        "5. Escribe una función llamada ``calcular_maximo`` que tome una cantidad variable de números como argumentos y devuelva el número más grande entre ellos.\n",
        "\n",
        "**Soluciones**\n",
        "\n",
        "<details><summary>Click para ver las soluciones</summary>\n",
        "\n",
        "1. Función ``es_par``:\n",
        "\n",
        "    ~~~python\n",
        "    def es_par(numero):\n",
        "        return numero % 2 == 0\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #resultado = es_par(10)\n",
        "    #print(resultado)  # Esto imprimirá True porque 10 es un número par\n",
        "\n",
        "    #resultado = es_par(7)\n",
        "    #print(resultado)  # Esto imprimirá False porque 7 es un número impar\n",
        "    ~~~\n",
        "\n",
        "2. Función ``calcular_factorial``:\n",
        "\n",
        "    ~~~python\n",
        "    def calcular_factorial(n):\n",
        "        # Verifica si el número es 0 o 1, el factorial de ambos es 1\n",
        "        if n == 0 or n == 1:\n",
        "            return 1\n",
        "        \n",
        "        # Inicializa el resultado en 1\n",
        "        factorial = 1\n",
        "        \n",
        "        # Multiplica todos los números desde 1 hasta n\n",
        "        for i in range(2, n + 1):\n",
        "            factorial *= i\n",
        "        \n",
        "        return factorial\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #resultado = calcular_factorial(5)\n",
        "    #print(f\"El factorial de 5 es: {resultado}\")  # Esto imprimirá 120\n",
        "    ~~~\n",
        "\n",
        "3. Función ``contar_vocales``:\n",
        "\n",
        "    ~~~python\n",
        "    def contar_vocales(cadena):\n",
        "        # Definir las vocales que se van a contar\n",
        "        vocales = \"aeiouAEIOU\"\n",
        "        # Inicializar el contador en 0\n",
        "        contador = 0\n",
        "        \n",
        "        # Recorrer cada carácter de la cadena\n",
        "        for caracter in cadena:\n",
        "            # Si el carácter es una vocal, incrementar el contador\n",
        "            if caracter in vocales:\n",
        "                contador += 1\n",
        "        \n",
        "        return contador\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #resultado = contar_vocales(\"Hola Mundo\")\n",
        "    #print(f\"La cantidad de vocales es: {resultado}\")  # Esto imprimirá 4\n",
        "    ~~~\n",
        "\n",
        "4. Función ``es_palindromo``:\n",
        "\n",
        "    ~~~python\n",
        "    def es_palindromo(cadena):\n",
        "        # Eliminar espacios en blanco y convertir la cadena a minúsculas para una comparación uniforme\n",
        "        cadena = cadena.replace(\" \", \"\").lower()\n",
        "        \n",
        "        # Comparar la cadena original con su reverso\n",
        "        return cadena == cadena[::-1]\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #resultado = es_palindromo(\"Anita lava la tina\")\n",
        "    #print(f\"¿Es palíndromo? {resultado}\")  # Esto imprimirá True\n",
        "    ~~~\n",
        "\n",
        "5. Función ``calcular_maximo``:\n",
        "\n",
        "    ~~~python\n",
        "    def calcular_maximo(*numeros):\n",
        "        # Verifica si se proporcionaron números\n",
        "        if len(numeros) == 0:\n",
        "            return None\n",
        "        \n",
        "        # Devuelve el máximo entre los números proporcionados\n",
        "        return max(numeros)\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #resultado = calcular_maximo(5, 12, 3, 7, 18, 1)\n",
        "    #print(f\"El número más grande es: {resultado}\")  # Esto imprimirá 18\n",
        "    ~~~\n",
        "</details>\n"
      ],
      "metadata": {
        "id": "dJ9bW0EDz_A5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Parámetros de Funciones en Python\n",
        "\n",
        "#### Parámetros posicionales\n",
        "\n",
        "* Los parámetros posicionales son aquellos que se pasan a una función en un orden específico.\n",
        "\n",
        "* Los argumentos deben coincidir con el orden de los parámetros definidos en la función.\n",
        "\n",
        "~~~python\n",
        "def saludar(nombre, apellido):\n",
        "    print(f\"¡Hola, {nombre} {apellido}!\")\n",
        "\n",
        "saludar(\"Clifford\", \"Torres\")  # Salida: ¡Hola, Clifford Torres!\n",
        "~~~\n",
        "\n",
        "#### Parámetros con valores predeterminados\n",
        "\n",
        "- Los parámetros con valores predeterminados permiten especificar un valor por defecto para un parámetro.\n",
        "\n",
        "- Si no se proporciona un argumento para ese parámetro al llamar a la función, se utilizará el valor predeterminado.\n",
        "\n",
        "~~~python\n",
        "def saludar(nombre, mensaje=\"¡Hola!\"):\n",
        "    print(f\"{mensaje}, {nombre}\")\n",
        "\n",
        "saludar(\"Clifford\")  # Salida: ¡Hola!, Clifford\n",
        "saludar(\"Joaquín\", \"¡Buenos días!\")  # Salida: ¡Buenos días!, Joaquín\n",
        "~~~\n",
        "\n",
        "#### Argumentos de palabras clave\n",
        "\n",
        "- Los argumentos de palabras clave permiten pasar argumentos a una función utilizando el nombre del parámetro seguido de un signo igual <font color='blue'>=</font> y el valor.\n",
        "\n",
        "- Esto permite especificar los argumentos en cualquier orden.\n",
        "\n",
        "~~~python\n",
        "def saludar(nombre, apellido):\n",
        "    print(f\"¡Hola, {nombre} {apellido}!\")\n",
        "\n",
        "saludar(apellido=\"Torres\", nombre=\"Joaquín\")  # Salida: ¡Hola, Joaquín Torres!\n",
        "~~~\n",
        "\n",
        "#### \\*args y **kwargs\n",
        "- <font color='blue'>\\*args</font> y <font color='blue'>**kwargs</font> son parámetros especiales que permiten pasar una cantidad variable de argumentos a una función.\n",
        "\n",
        "- <font color='blue'>\\*args</font> se utiliza para pasar una cantidad variable de argumentos posicionales como una tupla.\n",
        "-<font color='blue'>**kwargs</font> se utiliza para pasar una cantidad variable de argumentos de palabras clave como un diccionario.\n",
        "\n",
        "~~~python\n",
        "def imprimir_args(*args):\n",
        "    for arg in args:\n",
        "        print(arg)\n",
        "\n",
        "imprimir_args(1, 2, 3)  # Salida: 1 2 3\n",
        "\n",
        "def imprimir_kwargs(**kwargs):\n",
        "    for clave, valor in kwargs.items():\n",
        "        print(f\"{clave}: {valor}\")\n",
        "\n",
        "imprimir_kwargs(nombre=\"Katha\", edad=35)  # Salida: nombre: Katha \\n edad: 35\n",
        "~~~\n",
        "\n",
        "### Alcance y Tiempo de Vida de las Variables en Python\n",
        "\n",
        "#### Variables locales y globales\n",
        "\n",
        "* En Python, las variables tienen un alcance que determina dónde pueden ser accedidas y utilizadas.\n",
        "\n",
        "* Las variables locales se definen dentro de una función y solo son accesibles dentro de esa función.\n",
        "\n",
        "* Las variables globales se definen fuera de cualquier función y pueden ser accedidas desde cualquier parte del programa.\n",
        "\n",
        "~~~python\n",
        "x = 10  # Variable global\n",
        "\n",
        "def funcion():\n",
        "    y = 20  # Variable local\n",
        "    print(x)  # Accediendo a la variable global 'x'\n",
        "    print(y)  # Accediendo a la variable local 'y'\n",
        "\n",
        "funcion()  # Salida: 10 20\n",
        "print(x)  # Salida: 10\n",
        "print(y)  # Error: NameError: name 'y' is not defined\n",
        "~~~\n",
        "\n",
        "#### La palabra clave 'global'\n",
        "\n",
        "* Si queremos modificar una variable global dentro de una función, debemos utilizar la palabra clave <font color='blue'>global</font> para indicar que nos estamos refiriendo a la variable global.\n",
        "\n",
        "~~~python\n",
        "contador = 0\n",
        "\n",
        "def incrementar():\n",
        "    global contador\n",
        "    contador += 1\n",
        "\n",
        "incrementar()\n",
        "print(contador)  # Salida: 1\n",
        "~~~\n",
        "\n",
        "#### Funciones anidadas y nonlocal\n",
        "\n",
        "* Python permite definir funciones dentro de otras funciones, conocidas como funciones anidadas.\n",
        "\n",
        "* Las variables definidas en la función externa son accesibles desde las funciones internas, pero si queremos modificar una variable de la función externa desde una función interna, debemos utilizar la palabra clave <font color='blue'>nonlocal</font>.\n",
        "\n",
        "~~~python\n",
        "def funcion_externa():\n",
        "    x = 10\n",
        "    \n",
        "    def funcion_interna():\n",
        "        nonlocal x\n",
        "        x += 1\n",
        "        print(x)\n",
        "\n",
        "    funcion_interna()  # Salida: 11\n",
        "    print(x)  # Salida: 11\n",
        "\n",
        "funcion_externa()\n",
        "~~~"
      ],
      "metadata": {
        "id": "p9SakgFs18BA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Ejemplos\n",
        "\n",
        "1. Crear una función llamada <font color='blue'>calcular_precio</font> que toma tres parámetros: <font color='blue'>precio_base</font>, <font color='blue'>impuesto</font> (con un valor predeterminado de 0.15) y <font color='blue'>descuento</font> (con un valor predeterminado de 0). La función calcula el precio final aplicando el impuesto y restando el descuento al precio base.\n",
        "\n",
        "    <details><summary>Ver la solución</summary>\n",
        "\n",
        "    ~~~python\n",
        "    def calcular_precio(precio_base, impuesto=0.15, descuento=0):\n",
        "        precio = precio_base * (1 + impuesto)\n",
        "        precio -= descuento\n",
        "        return precio\n",
        "\n",
        "    #precio_final = calcular_precio(100)  # precio_final = 115.0\n",
        "    #precio_final = calcular_precio(100, impuesto=0.1)  # precio_final = 110.0\n",
        "    #precio_final = calcular_precio(100, descuento=10)  # precio_final = 105.0\n",
        "    ~~~\n",
        "    </details>\n",
        "\n",
        "2. Crea una función llamada ``calcular_factorial`` que calcule el factorial de un número utilizando una variable local para almacenar el resultado parcial.\n",
        "\n",
        "    <details><summary>Ver la solución</summary>\n",
        "\n",
        "    ~~~python\n",
        "    def calcular_factorial(n):\n",
        "    resultado = 1\n",
        "    for i in range(1, n + 1):\n",
        "        resultado *= i\n",
        "    return resultado\n",
        "\n",
        "    #numero = 5\n",
        "    #factorial = calcular_factorial(numero)\n",
        "    #print(f\"El factorial de {numero} es: {factorial}\")\n",
        "    ~~~\n",
        "    </details>\n",
        "\n",
        "3. Crea una función llamada ``incrementar`` que incremente en uno la variable global ``contador``.\n",
        "\n",
        "    <details><summary>Ver la solución</summary>\n",
        "\n",
        "    ~~~python\n",
        "    def incrementar():\n",
        "        global contador\n",
        "        contador += 1\n",
        "        print(\"Dentro de la función:\", contador)\n",
        "\n",
        "    #contador = 0\n",
        "    #incrementar()\n",
        "    #print(\"Fuera de la función:\", contador)\n",
        "    ~~~\n",
        "    </details>\n",
        "\n",
        "4. Crear una función <font color='blue'>calcular_promedio</font> que toma una lista de notas como parámetro. Dentro de la función, calculamos el total y la cantidad de notas. Luego, definimos una función interna llamada <font color='blue'>validar_notas</font> que filtra las notas válidas (entre 0 y 100) y actualiza las variables <font color='blue'>total</font> y <font color='blue'>cantidad</font> utilizando la palabra clave <font color='blue'>nonlocal</font>. Después de llamar a <font color='blue'>validar_notas</font>, verificamos si hay notas válidas. Si es así, calculamos el promedio y lo devolvemos. De lo contrario, devolvemos <font color='blue'>None</font>. Finalmente, llamamos a la función <font color='blue'>calcular_promedio</font> con diferentes listas de notas y mostramos los promedios resultantes.\n",
        "\n",
        "    <details><summary>Ver la solución</summary>\n",
        "\n",
        "    ~~~python\n",
        "    def calcular_promedio(notas):\n",
        "        total = sum(notas)\n",
        "        cantidad = len(notas)\n",
        "\n",
        "        def validar_notas():\n",
        "            nonlocal total, cantidad\n",
        "            notas_validas = [nota for nota in notas if 0 <= nota <= 100]\n",
        "            total = sum(notas_validas)\n",
        "            cantidad = len(notas_validas)\n",
        "\n",
        "        validar_notas()\n",
        "\n",
        "        if cantidad > 0:\n",
        "            promedio = total / cantidad\n",
        "            return promedio\n",
        "        else:\n",
        "            return None\n",
        "\n",
        "    #notas_estudiante1 = [85, 92, 78, 90, 88]\n",
        "    #promedio_estudiante1 = calcular_promedio(notas_estudiante1)\n",
        "    #print(f\"Promedio del estudiante 1: {promedio_estudiante1}\")  \n",
        "    # Salida: Promedio del estudiante 1: 86.6\n",
        "\n",
        "    #notas_estudiante2 = [100, 90, 85, 200, -10]\n",
        "    #promedio_estudiante2 = calcular_promedio(notas_estudiante2)\n",
        "    #print(f\"Promedio del estudiante 2: {promedio_estudiante2}\")  \n",
        "    # Salida: Promedio del estudiante 2: 91.66666666666667\n",
        "    ~~~\n",
        "    </details>\n",
        "\n",
        "#### Ejercicios\n",
        "\n",
        "1. Escribe una función llamada ``calcular_promedio`` que tome una cantidad variable de números como argumentos y devuelva el promedio de esos números.\n",
        "2. Crea una función llamada ``imprimir_info`` que tome el nombre, la edad y una cantidad variable de palabras clave adicionales (como ``ciudad``, ``profesion``, etc.) y muestre una oración con toda la información.\n",
        "3. Escribe una función llamada ``filtrar_pares`` que tome una lista de números como argumento y devuelva una nueva lista que contenga solo los números pares de la lista original.\n",
        "4. Crea una función llamada ``calcular_descuento`` que tome el precio y un porcentaje de descuento opcional (con un valor predeterminado de 10%) y devuelva el precio con el descuento aplicado.\n",
        "5. Escribe una función llamada ``combinar_diccionarios`` que tome una cantidad variable de diccionarios como argumentos y devuelva un nuevo diccionario que contenga la combinación de todos los diccionarios pasados.\n",
        "6. Crea una función llamada ``contar_parametros`` que tome una cantidad variable de argumentos y devuelva la cantidad de argumentos pasados. Utiliza una variable local dentro de la función para realizar el conteo.\n",
        "7. Escribe una función llamada ``factorial`` que calcule el factorial de un número utilizando una función interna recursiva. Utiliza la palabra clave ``nonlocal`` para acceder y modificar la variable que almacena el resultado en la función externa.\n",
        "8. Crea una función llamada ``calcular_estadisticas`` que tome una lista de números como argumento y devuelva la suma, el promedio, el valor mínimo y el valor máximo de la lista. Utiliza funciones internas para calcular cada estadística y variables locales para almacenar los resultados.\n",
        "9. Escribe una función llamada ``crear_contador`` que devuelva otra función. La función devuelta debe incrementar y devolver un contador cada vez que se llama. Utiliza una variable local en la función externa para mantener el estado del contador.\n",
        "10. Crea una función llamada ``sumar_numero`` que tome una cantidad variable de argumentos numéricos y devuelva la suma de esos números. Utiliza una variable local para almacenar la suma y una función interna para realizar la suma de manera recursiva.\n",
        "\n",
        "**Soluciones**\n",
        "<details><summary>Click para ver las soluciones</summary>\n",
        "\n",
        "1. Función ``calcular_promedio``:\n",
        "\n",
        "~~~python\n",
        "    def calcular_promedio(*numeros):\n",
        "        # Verifica si se proporcionaron números\n",
        "        if len(numeros) == 0:\n",
        "            return None\n",
        "        \n",
        "        # Calcula la suma de los números y divide entre la cantidad de elementos\n",
        "        suma = sum(numeros)\n",
        "        promedio = suma / len(numeros)\n",
        "        \n",
        "        return promedio\n",
        "\n",
        "    #Ejemplo de uso\n",
        "    #resultado = calcular_promedio(5, 12, 3, 7, 18, 1)\n",
        "    #print(f\"El promedio es: {resultado}\")  # Esto imprimirá 7.666666666666667\n",
        "~~~\n",
        "\n",
        "2. Función ``imprimir_info``:\n",
        "\n",
        "~~~python\n",
        "    def imprimir_info(nombre, edad, **info_adicional):\n",
        "        # Crear la oración básica con el nombre y la edad\n",
        "        oracion = f\"{nombre} tiene {edad} años\"\n",
        "        \n",
        "        # Añadir la información adicional, si existe\n",
        "        for clave, valor in info_adicional.items():\n",
        "            oracion += f\", {clave}: {valor}\"\n",
        "        \n",
        "        # Imprimir la oración completa\n",
        "        print(oracion)\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #imprimir_info(\"Clifford\", 30, ciudad=\"Lima\", profesion=\"Ingeniero\", #hobby=\"Leer\")\n",
        "~~~\n",
        "\n",
        "3. Función ``filtrar_pares``:\n",
        "\n",
        "~~~python\n",
        "    def filtrar_pares(numeros):\n",
        "        # Crear una nueva lista que contenga solo los números pares\n",
        "        pares = [numero for numero in numeros if numero % 2 == 0]\n",
        "        return pares\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #lista_original = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "    #lista_pares = filtrar_pares(lista_original)\n",
        "    #print(f\"Números pares: {lista_pares}\")  # Esto imprimirá [2, 4, 6, 8, 10]\n",
        "~~~\n",
        "\n",
        "4. Función ``calcular_descuento``:\n",
        "\n",
        "~~~python\n",
        "    def calcular_descuento(precio, porcentaje_descuento=10):\n",
        "        \"\"\"\n",
        "        Calcula el precio con un descuento aplicado.\n",
        "\n",
        "        :param precio: El precio original del producto.\n",
        "        :param porcentaje_descuento: El porcentaje de descuento a aplicar (valor predeterminado: 10).\n",
        "        :return: El precio con el descuento aplicado.\n",
        "        \"\"\"\n",
        "        descuento = precio * (porcentaje_descuento / 100)\n",
        "        precio_con_descuento = precio - descuento\n",
        "        return precio_con_descuento\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #precio_original = 100\n",
        "    #precio_final = calcular_descuento(precio_original)\n",
        "    #print(f\"Precio final con descuento: {precio_final:.2f}\")\n",
        "\n",
        "    #precio_final_con_15 = calcular_descuento(precio_original, 15)\n",
        "    #print(f\"Precio final con descuento del 15%: {precio_final_con_15:.2f}\")\n",
        "~~~\n",
        "\n",
        "5. Función ``combinar_diccionarios``:\n",
        "\n",
        "~~~python\n",
        "    def combinar_diccionarios(*diccionarios):\n",
        "        \"\"\"\n",
        "        Combina una cantidad variable de diccionarios en uno solo.\n",
        "\n",
        "        :param diccionarios: Diccionarios a combinar.\n",
        "        :return: Un diccionario combinado que contiene todas las claves y valores.\n",
        "        \"\"\"\n",
        "        combinado = {}\n",
        "        for diccionario in diccionarios:\n",
        "            combinado.update(diccionario)\n",
        "        return combinado\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #dic1 = {'a': 1, 'b': 2}\n",
        "    #dic2 = {'b': 3, 'c': 4}\n",
        "    #dic3 = {'d': 5}\n",
        "    #resultado = combinar_diccionarios(dic1, dic2, dic3)\n",
        "    #print(resultado)\n",
        "~~~\n",
        "\n",
        "6. Función ``contar_parametros``:\n",
        "\n",
        "~~~python\n",
        "    def contar_parametros(*args):\n",
        "        \"\"\"\n",
        "        Cuenta la cantidad de argumentos pasados a la función.\n",
        "\n",
        "        :param args: Argumentos a contar.\n",
        "        :return: La cantidad de argumentos.\n",
        "        \"\"\"\n",
        "        cantidad = len(args)\n",
        "        return cantidad\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #print(contar_parametros(1, 2, 3, 4))  # Salida: 4\n",
        "~~~\n",
        "\n",
        "7. Función ``factorial``:\n",
        "\n",
        "~~~python\n",
        "    def factorial(n):\n",
        "        resultado = 1\n",
        "\n",
        "        def calcular_factorial(n):\n",
        "            nonlocal resultado\n",
        "            if n > 1:\n",
        "                resultado *= n\n",
        "                calcular_factorial(n - 1)\n",
        "\n",
        "        calcular_factorial(n)\n",
        "        return resultado\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #print(factorial(5))  # Salida: 120\n",
        "~~~\n",
        "\n",
        "8. Función ``calcular_estadisticas``:\n",
        "\n",
        "~~~python\n",
        "    def calcular_estadisticas(numeros):\n",
        "\n",
        "        def calcular_suma():\n",
        "            return sum(lista)\n",
        "\n",
        "        def calcular_promedio():\n",
        "            return calcular_suma() / len(lista)\n",
        "        \n",
        "        def obtener_minimo():\n",
        "            return min(numeros)\n",
        "\n",
        "        def obtener_maximo():\n",
        "            return max(numeros)\n",
        "\n",
        "        suma = calcular_suma()\n",
        "        promedio = calcular_promedio()\n",
        "        minimo = obtener_minimo()\n",
        "        maximo = obtener_maximo()\n",
        "\n",
        "        return suma, promedio, minimo, maximo\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #numeros = [10, 20, 30, 40, 50]\n",
        "    #print(calcular_estadisticas(numeros))\n",
        "~~~\n",
        "\n",
        "9. Función ``crear_contador``:\n",
        "\n",
        "~~~python\n",
        "    def crear_contador():\n",
        "        contador = 0\n",
        "\n",
        "        def incrementar():\n",
        "            nonlocal contador\n",
        "            contador += 1\n",
        "            return contador\n",
        "\n",
        "        return incrementar\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #contador = crear_contador()\n",
        "    #print(contador())  # Salida: 1\n",
        "    #print(contador())  # Salida: 2\n",
        "~~~\n",
        "\n",
        "10. Función ``sumar_numeros``:\n",
        "\n",
        "~~~python\n",
        "    def sumar_numeros(*numeros):\n",
        "        suma = 0\n",
        "\n",
        "        def sumar_recursivamente(var_numeros):\n",
        "            nonlocal suma\n",
        "            if var_numeros:\n",
        "                suma += var_numeros[0]\n",
        "                sumar_recursivamente(var_numeros[1:])\n",
        "\n",
        "        sumar_recursivamente(numeros)\n",
        "        return suma\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #print(sumar_numero(1, 2, 3, 4))  # Salida: 10\n",
        "~~~\n",
        "\n",
        "</details>\n",
        "\n"
      ],
      "metadata": {
        "id": "ADxZqmxX3Shc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Funciones como Objetos de Primera Clase en Python\n",
        "- En Python, las funciones son objetos de primera clase, lo que significa que pueden ser tratadas como cualquier otro objeto.\n",
        "- Esto nos permite asignar funciones a variables, pasarlas como argumentos a otras funciones y devolverlas como resultados de funciones.\n",
        "\n",
        "#### Asignación de funciones a variables\n",
        "- Podemos asignar funciones a variables y luego llamar a la función a través de la variable.\n",
        "\n",
        "~~~python\n",
        "def saludar(nombre):\n",
        "    return f\"¡Hola, {nombre}!\"\n",
        "\n",
        "saludo = saludar\n",
        "print(saludo(\"Clifford\"))  # Salida: ¡Hola, Clifford!\n",
        "~~~\n",
        "\n",
        "#### Funciones como argumentos\n",
        "* Podemos pasar funciones como argumentos a otras funciones, lo que nos permite crear funciones de orden superior.\n",
        "\n",
        "~~~python\n",
        "def aplicar_operacion(funcion, numeros):\n",
        "    return [funcion(num) for num in numeros]\n",
        "\n",
        "def cuadrado(x):\n",
        "    return x ** 2\n",
        "\n",
        "def cubo(x):\n",
        "    return x ** 3\n",
        "\n",
        "numeros = [1, 2, 3, 4, 5]\n",
        "cuadrados = aplicar_operacion(cuadrado, numeros)\n",
        "cubos = aplicar_operacion(cubo, numeros)\n",
        "\n",
        "print(cuadrados)  # Salida: [1, 4, 9, 16, 25]\n",
        "print(cubos)  # Salida: [1, 8, 27, 64, 125]\n",
        "~~~\n",
        "\n",
        "#### Funciones que devuelven funciones\n",
        "- Podemos crear funciones que devuelvan otras funciones como resultado.\n",
        "\n",
        "~~~python\n",
        "def crear_multiplicador(factor):\n",
        "    def multiplicar(x):\n",
        "        return x * factor\n",
        "    return multiplicar\n",
        "\n",
        "duplicar = crear_multiplicador(2)\n",
        "triplicar = crear_multiplicador(3)\n",
        "\n",
        "print(duplicar(5))  # Salida: 10\n",
        "print(triplicar(5))  # Salida: 15\n",
        "~~~\n",
        "\n",
        "### Ejemplo práctico\n",
        "\n",
        "En este ejemplo, definimos una función <font color='blue'>``crear_operacion``</font> que toma un operador como argumento y devuelve la función correspondiente para realizar esa operación. Dentro de <font color='blue'>``crear_operacion``</font>, definimos las funciones <font color='blue'>``sumar``</font>, <font color='blue'>``restar``</font>, <font color='blue'>``multiplicar``</font> y <font color='blue'>``dividir``</font>.\n",
        "\n",
        "Luego, utilizamos <font color='blue'>``crear_operacion``</font> para obtener la función adecuada según el operador proporcionado y la asignamos a la variable <font color='blue'>``operacion``</font>. Podemos llamar a <font color='blue'>``operacion``</font> con diferentes argumentos para realizar la operación correspondiente.\n",
        "\n",
        "También manejamos casos especiales, como la división entre cero y operadores no válidos, lanzando excepciones apropiadas.\n",
        "\n"
      ],
      "metadata": {
        "id": "bd3IHfofNX6I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Ejemplos\n",
        "\n",
        "1. definimos una función <font color='blue'>crear_operacion</font> que toma un operador como argumento y devuelve la función correspondiente para realizar esa operación. Dentro de <font color='blue'>crear_operacion</font>, definimos las funciones <font color='blue'>sumar</font>, <font color='blue'>restar</font>, <font color='blue'>multiplicar</font> y <font color='blue'>dividir</font>.\n",
        "\n",
        "Luego, utilizamos <font color='blue'>crear_operacion</font> para obtener la función adecuada según el operador proporcionado y la asignamos a la variable <font color='blue'>operacion</font>. Podemos llamar a <font color='blue'>operacion</font> con diferentes argumentos para realizar la operación correspondiente.\n",
        "\n",
        "También manejamos casos especiales, como la división entre cero y operadores no válidos, lanzando excepciones apropiadas.\n",
        "\n",
        "\n",
        "~~~python\n",
        "def crear_operacion(operador):\n",
        "    def sumar(a, b):\n",
        "        return a + b\n",
        "\n",
        "    def restar(a, b):\n",
        "        return a - b\n",
        "\n",
        "    def multiplicar(a, b):\n",
        "        return a * b\n",
        "\n",
        "    def dividir(a, b):\n",
        "        if b != 0:\n",
        "            return a / b\n",
        "        else:\n",
        "            raise ValueError(\"No se puede dividir entre cero\")\n",
        "\n",
        "    if operador == \"+\":\n",
        "        return sumar\n",
        "    elif operador == \"-\":\n",
        "        return restar\n",
        "    elif operador == \"*\":\n",
        "        return multiplicar\n",
        "    elif operador == \"/\":\n",
        "        return dividir\n",
        "    else:\n",
        "        raise ValueError(\"Operador no válido\")\n",
        "\n",
        "operacion = crear_operacion(\"+\")\n",
        "resultado = operacion(5, 3)\n",
        "print(resultado)  # Salida: 8\n",
        "\n",
        "operacion = crear_operacion(\"-\")\n",
        "resultado = operacion(10, 7)\n",
        "print(resultado)  # Salida: 3\n",
        "\n",
        "operacion = crear_operacion(\"*\")\n",
        "resultado = operacion(4, 6)\n",
        "print(resultado)  # Salida: 24\n",
        "\n",
        "operacion = crear_operacion(\"/\")\n",
        "resultado = operacion(10, 2)\n",
        "print(resultado)  # Salida: 5.0\n",
        "\n",
        "# operacion = crear_operacion(\"%\")  # Lanza ValueError: Operador no válido\n",
        "# resultado = operacion(10, 0)  # Lanza ValueError: No se puede dividir entre cero\n",
        "~~~\n",
        "\n",
        "##### Ejercicios\n",
        "\n",
        "1. Crea una función llamada aplicar_funciones que tome una lista de funciones y un valor como argumentos, y devuelva una lista con el resultado de aplicar cada función al valor.\n",
        "\n",
        "2. Escribe una función llamada crear_validador que tome una función de validación como argumento y devuelva una función que valide un valor utilizando la función de validación proporcionada. Si el valor no pasa la validación, la función devuelta debe lanzar una excepción ValueError con un mensaje apropiado.\n",
        "\n",
        "3. Crea una función llamada ordenar_por que tome una lista de diccionarios y una clave como argumentos, y devuelva la lista ordenada según el valor de la clave especificada. Utiliza la función sorted y pasa una función de clave personalizada.\n",
        "\n",
        "4. Escribe una función llamada crear_ejecutor que tome una función y un número variable de argumentos, y devuelva una función que ejecute la función original con los argumentos proporcionados cuando sea llamada.\n",
        "\n",
        "5. Crea una función llamada memoizar que tome una función como argumento y devuelva una versión memoizada de la función. La función memoizada debe almacenar en caché los resultados de las llamadas anteriores y devolver el resultado almacenado en caché si se llama con los mismos argumentos.\n",
        "\n",
        "**Soluciones**\n",
        "\n",
        "<details><summary>Click para ver las soluciones</summary>\n",
        "\n",
        "1. Función aplicar_funciones:\n",
        "\n",
        "    ~~~python\n",
        "    def aplicar_funciones(lista_funciones, valor):\n",
        "        \"\"\"\n",
        "        Aplica una lista de funciones a un valor dado y devuelve una lista con los resultados.\n",
        "\n",
        "        :param lista_funciones: Lista de funciones a aplicar.\n",
        "        :param valor: El valor al que se aplicarán las funciones.\n",
        "        :return: Lista con los resultados de aplicar cada función al valor.\n",
        "        \"\"\"\n",
        "        resultados = []  # Lista para almacenar los resultados\n",
        "\n",
        "        # Itera sobre cada función en la lista de funciones\n",
        "        for funcion in lista_funciones:\n",
        "            # Aplica la función al valor y añade el resultado a la lista de resultados\n",
        "            resultado = funcion(valor)\n",
        "            resultados.append(resultado)\n",
        "        \n",
        "        return resultados\n",
        "\n",
        "    # Ejemplo de uso\n",
        "\n",
        "    # Definimos algunas funciones de ejemplo\n",
        "    #def sumar_dos(x):\n",
        "    #    return x + 2\n",
        "\n",
        "    #def multiplicar_por_tres(x):\n",
        "    #    return x * 3\n",
        "\n",
        "    #def elevar_al_cuadrado(x):\n",
        "    #    return x ** 2\n",
        "\n",
        "    # Lista de funciones a aplicar\n",
        "    #funciones = [sumar_dos, multiplicar_por_tres, elevar_al_cuadrado]\n",
        "\n",
        "    # Aplicamos las funciones al valor 5\n",
        "    #resultados = aplicar_funciones(funciones, 5)\n",
        "    #print(resultados)  # Salida esperada: [7, 15, 25]\n",
        "    ~~~\n",
        "\n",
        "2. Función crear_validador:\n",
        "\n",
        "    ~~~python\n",
        "    def crear_validador(funcion_validacion):\n",
        "        \"\"\"\n",
        "        Crea un validador que usa la función de validación proporcionada para validar valores.\n",
        "        Si el valor no pasa la validación, se lanza una excepción ValueError.\n",
        "\n",
        "        :param funcion_validacion: Función que valida un valor y devuelve True si es válido, False de lo contrario.\n",
        "        :return: Una función que valida un valor utilizando la función de validación proporcionada.\n",
        "        \"\"\"\n",
        "        def validador(valor):\n",
        "            # Aplica la función de validación al valor\n",
        "            if not funcion_validacion(valor):\n",
        "                # Lanza una excepción ValueError si la validación falla\n",
        "                raise ValueError(f\"El valor {valor} no es válido según la función de validación.\")\n",
        "            return valor\n",
        "\n",
        "        return validador\n",
        "\n",
        "    # Ejemplo de uso\n",
        "\n",
        "    # Definimos una función de validación que verifica si un número es positivo\n",
        "    #def es_positivo(x):\n",
        "    #    return x > 0\n",
        "\n",
        "    # Creamos un validador usando la función de validación es_positivo\n",
        "    #validador_positivo = crear_validador(es_positivo)\n",
        "\n",
        "    # Prueba de validación con un valor válido\n",
        "    #try:\n",
        "    #    print(validador_positivo(10))  # Salida: 10\n",
        "    #except ValueError as e:\n",
        "    #    print(e)\n",
        "\n",
        "    # Prueba de validación con un valor no válido\n",
        "    #try:\n",
        "    #    print(validador_positivo(-5))  # Esto lanzará una excepción ValueError\n",
        "    #except ValueError as e:\n",
        "    #    print(e)  # Salida: El valor -5 no es válido según la función de validación.\n",
        "    ~~~\n",
        "\n",
        "3. Función ordenar_por:\n",
        "\n",
        "    ~~~python\n",
        "    def ordenar_por(lista, clave):\n",
        "        # Utiliza sorted con una función de clave personalizada que accede al valor de la clave\n",
        "        return sorted(lista, key=lambda x: x[clave])\n",
        "\n",
        "    # Ejemplo de uso\n",
        "\n",
        "    # Lista de diccionarios de ejemplo\n",
        "    #lista = [\n",
        "    #    {'nombre': 'Ana', 'edad': 30},\n",
        "    #    {'nombre': 'Luis', 'edad': 25},\n",
        "    #    {'nombre': 'Pedro', 'edad': 35}\n",
        "    #]\n",
        "\n",
        "    # Ordenamos la lista por la clave 'edad'\n",
        "    #ordenada_por_edad = ordenar_por(lista, 'edad')\n",
        "    #print(ordenada_por_edad)\n",
        "    # Salida esperada: [{'nombre': 'Luis', 'edad': 25}, {'nombre': 'Ana', 'edad': 30}, {'nombre': 'Pedro', 'edad': 35}]\n",
        "    ~~~\n",
        "\n",
        "4. Función crear_ejecutor:\n",
        "\n",
        "    ~~~python\n",
        "    def crear_ejecutor(funcion_original, *args):\n",
        "        \"\"\"\n",
        "        Crea una función que, cuando es llamada, ejecuta la función original con los argumentos proporcionados.\n",
        "\n",
        "        :param funcion_original: La función que se ejecutará.\n",
        "        :param args: Argumentos que se pasarán a la función original.\n",
        "        :return: Una función que ejecuta la función original con los argumentos proporcionados.\n",
        "        \"\"\"\n",
        "        def ejecutor():\n",
        "            return funcion_original(*args)\n",
        "        \n",
        "        return ejecutor\n",
        "\n",
        "    # Ejemplo de uso\n",
        "\n",
        "    # Definimos una función de ejemplo\n",
        "    #def saludar(nombre, saludo):\n",
        "    #    return f\"{saludo}, {nombre}!\"\n",
        "\n",
        "    # Creamos un ejecutor para la función saludar con argumentos específicos\n",
        "    #ejecutor_saludar = crear_ejecutor(saludar, \"Juan\", \"Hola\")\n",
        "\n",
        "    # Llamamos al ejecutor para obtener el resultado\n",
        "    #resultado = ejecutor_saludar()\n",
        "    #print(resultado)  # Salida esperada: \"Hola, Juan!\"\n",
        "    ~~~\n",
        "\n",
        "5. Función memoizar:\n",
        "\n",
        "    ~~~python\n",
        "    def memoizar(funcion):\n",
        "        \"\"\"\n",
        "        Crea una versión memoizada de la función proporcionada, almacenando en caché los resultados\n",
        "        de llamadas anteriores para evitar cálculos redundantes.\n",
        "\n",
        "        :param funcion: La función a memoizar.\n",
        "        :return: Una versión memoizada de la función.\n",
        "        \"\"\"\n",
        "        cache = {}  # Diccionario para almacenar los resultados en caché\n",
        "\n",
        "        def funcion_memoizada(*args):\n",
        "            if args in cache:\n",
        "                # Si los argumentos ya están en caché, devuelve el resultado almacenado\n",
        "                return cache[args]\n",
        "            else:\n",
        "                # Calcula el resultado y almacénalo en caché\n",
        "                resultado = funcion(*args)\n",
        "                cache[args] = resultado\n",
        "                return resultado\n",
        "\n",
        "        return funcion_memoizada\n",
        "\n",
        "    # Ejemplo de uso\n",
        "\n",
        "    # Definimos una función de ejemplo que simula un cálculo costoso\n",
        "    #def calcular_fibonacci(n):\n",
        "    #    if n <= 1:\n",
        "    #        return n\n",
        "    #    return calcular_fibonacci(n - 1) + calcular_fibonacci(n - 2)\n",
        "\n",
        "    # Creamos una versión memoizada de la función calcular_fibonacci\n",
        "    #calcular_fibonacci_memoizado = memoizar(calcular_fibonacci)\n",
        "\n",
        "    # Llamadas a la función memoizada\n",
        "    #print(calcular_fibonacci_memoizado(10))  # Salida esperada: 55\n",
        "    #print(calcular_fibonacci_memoizado(10))  # Salida esperada: 55 (de caché)\n",
        "    ~~~\n",
        "</details>"
      ],
      "metadata": {
        "id": "6tRVAf-tN11U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Funciones Lambda en Python\n",
        "\n",
        "- Las funciones lambda, también conocidas como **funciones anónimas**, son funciones sin nombre que <u>se definen en una sola línea</u> utilizando la palabra clave <font color='blue'>``lambda``</font>.\n",
        "\n",
        "- Son útiles cuando necesitamos crear funciones pequeñas y concisas sin la necesidad de definirlas formalmente.\n",
        "\n",
        "La sintaxis de una función lambda es la siguiente:\n",
        "\n",
        "~~~python\n",
        "lambda argumentos: expresión\n",
        "~~~\n",
        "\n",
        "* <font color='blue'>``argumentos``</font>: Los argumentos de la función lambda, separados por comas si hay más de uno.\n",
        "* <font color='blue'>``expresión``</font>: Una única expresión que se evalúa y se devuelve como resultado de la función.\n",
        "\n",
        "### Ejemplo:\n",
        "\n",
        "~~~python\n",
        "cuadrado = lambda x: x ** 2\n",
        "resultado = cuadrado(5)\n",
        "print(resultado)  # Salida: 25\n",
        "~~~\n",
        "\n",
        "##Aplicaciones comunes\n",
        "- Las funciones lambda se utilizan comúnmente en combinación con funciones de orden superior, como <font color='blue'>``map()``</font>, <font color='blue'>``filter()``</font> y <font color='blue'>``reduce()``</font>, para realizar operaciones de manera concisa y funcional.\n",
        "\n",
        "### Ejemplo con map():\n",
        "\n",
        "~~~python\n",
        "numeros = [1, 2, 3, 4, 5]\n",
        "cuadrados = list(map(lambda x: x ** 2, numeros))\n",
        "print(cuadrados)  # Salida: [1, 4, 9, 16, 25]\n",
        "~~~\n",
        "\n",
        "### Ejemplo con filter():\n",
        "\n",
        "~~~python\n",
        "numeros = [1, 2, 3, 4, 5]\n",
        "pares = list(filter(lambda x: x % 2 == 0, numeros))\n",
        "print(pares)  # Salida: [2, 4]\n",
        "~~~\n"
      ],
      "metadata": {
        "id": "tfgbKgqWOW5r"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Ejemplos\n",
        "\n",
        "1. Tenemos una lista de figuras representadas como diccionarios. Cada figura tiene un tipo (\"rectángulo\" o \"círculo\") y las dimensiones correspondientes.\n",
        "\n",
        "Utilizamos la función <font color='blue'>``map()``</font> junto con una función lambda para calcular el área de cada figura. La función lambda toma una figura como argumento y llama a la función <font color='blue'>``calcular_area()``</font> para obtener el área de esa figura.\n",
        "\n",
        "Luego, convertimos el resultado de <font color='blue'>``map()``</font> en una lista usando <font color='blue'>``list()``</font> y sumamos todas las áreas utilizando la función <font color='blue'>``sum()``</font> para obtener el área total.\n",
        "\n",
        "~~~python\n",
        "# Función para calcular el área de una figura\n",
        "def calcular_area(figura):\n",
        "    if figura['tipo'] == 'rectángulo':\n",
        "        return figura['ancho'] * figura['alto']\n",
        "    elif figura['tipo'] == 'círculo':\n",
        "        return 3.14159 * figura['radio'] ** 2\n",
        "    else:\n",
        "        raise ValueError(\"Tipo de figura no soportado\")\n",
        "\n",
        "# Lista de figuras\n",
        "figuras = [\n",
        "    {'tipo': 'rectángulo', 'ancho': 5, 'alto': 3},\n",
        "    {'tipo': 'círculo', 'radio': 4},\n",
        "    {'tipo': 'rectángulo', 'ancho': 2, 'alto': 6},\n",
        "    {'tipo': 'círculo', 'radio': 1},\n",
        "    {'tipo': 'rectángulo', 'ancho': 8, 'alto': 2}\n",
        "]\n",
        "\n",
        "# Calcular el área total utilizando map() y una función lambda\n",
        "areas = list(map(lambda figura: calcular_area(figura), figuras))\n",
        "area_total = sum(areas)\n",
        "\n",
        "print(\"Áreas de las figuras:\", areas)\n",
        "print(\"Área total:\", area_total)\n",
        "~~~\n",
        "\n",
        "##### Ejercicios\n",
        "\n",
        "1. Escribe una función lambda que tome dos números como argumentos y devuelva el mayor de ellos.\n",
        "\n",
        "2. Utiliza una función lambda junto con ``filter()`` para filtrar una lista de cadenas y obtener solo las cadenas que contienen la letra 'a'.\n",
        "\n",
        "3. Crea una función lambda que tome una lista de tuplas, donde cada tupla contiene un nombre y una edad, y devuelva una nueva lista con los nombres de las personas mayores de 18 años.\n",
        "\n",
        "4. Utiliza una función lambda en combinación con ``map()`` para convertir una lista de números en una lista de sus valores absolutos.\n",
        "\n",
        "5. Escribe una función lambda que tome una cadena y devuelva ``True`` si la cadena es un palíndromo (se lee igual de izquierda a derecha que de derecha a izquierda), y ``False`` en caso contrario.\n",
        "\n",
        "**Soluciones**\n",
        "\n",
        "<details><summary>Click para ver las soluciones</summary>\n",
        "\n",
        "1. Función lambda para devolver el mayor de dos números:\n",
        "\n",
        "    ~~~python\n",
        "    mayor = lambda x, y: x if x > y else y\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    print(mayor(10, 20))  # Salida esperada: 20\n",
        "    print(mayor(30, 15))  # Salida esperada: 30\n",
        "    ~~~\n",
        "\n",
        "2. Filtrar cadenas que contienen la letra 'a':\n",
        "\n",
        "    ~~~python\n",
        "    # Lista de cadenas de ejemplo\n",
        "    cadenas = [\"manzana\", \"banana\", \"cereza\", \"kiwi\", \"mango\", \"uva\"]\n",
        "\n",
        "    # Usamos filter con una función lambda para obtener solo las cadenas que contienen la letra 'a'\n",
        "    cadenas_con_a = list(filter(lambda x: 'a' in x, cadenas))\n",
        "\n",
        "    # Imprimimos el resultado\n",
        "    #print(cadenas_con_a)  # Salida esperada: ['manzana', 'banana', 'cereza', 'mango']\n",
        "    ~~~\n",
        "\n",
        "3. Obtener nombres de personas mayores de 18 años:\n",
        "\n",
        "    ~~~python\n",
        "    # Lista de tuplas de ejemplo\n",
        "    personas = [(\"Ana\", 22), (\"Luis\", 17), (\"Pedro\", 19), (\"María\", 16), (\"José\", 25)]\n",
        "\n",
        "    # Usamos filter con una función lambda para obtener solo los nombres de personas mayores de 18 años\n",
        "    nombres_mayores_de_18 = list(map(lambda x: x[0], filter(lambda x: x[1] > 18, personas)))\n",
        "\n",
        "    # Imprimimos el resultado\n",
        "    #print(nombres_mayores_de_18)  # Salida esperada: ['Ana', 'Pedro', 'José']\n",
        "    ~~~\n",
        "\n",
        "4. Convertir números en sus valores absolutos:\n",
        "\n",
        "    ~~~python\n",
        "    # Lista de números de ejemplo\n",
        "    numeros = [-10, 5, -3, 8, -7]\n",
        "\n",
        "    # Usamos map con una función lambda para obtener los valores absolutos de los números\n",
        "    valores_absolutos = list(map(lambda x: abs(x), numeros))\n",
        "\n",
        "    # Imprimimos el resultado\n",
        "    #print(valores_absolutos)  # Salida esperada: [10, 5, 3, 8, 7]\n",
        "    ~~~\n",
        "\n",
        "5. Verificar si una cadena es un palíndromo:\n",
        "\n",
        "    ~~~python\n",
        "    # Función lambda para verificar si una cadena es un palíndromo\n",
        "    es_palindromo = lambda s: s == s[::-1]\n",
        "\n",
        "    # Ejemplos de uso\n",
        "    #print(es_palindromo(\"radar\"))   # Salida esperada: True\n",
        "    #print(es_palindromo(\"hello\"))   # Salida esperada: False\n",
        "    #print(es_palindromo(\"level\"))   # Salida esperada: True\n",
        "    #print(es_palindromo(\"world\"))   # Salida esperada: False\n",
        "    ~~~\n",
        "\n",
        "</details>"
      ],
      "metadata": {
        "id": "ptG9M_6BOldh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Funciones de Orden Superior en Python\n",
        "- Las funciones de orden superior son funciones que pueden tomar otras funciones como argumentos y/o devolver funciones como resultado.\n",
        "- En Python, las funciones  <font color='blue'>``map()``</font>,  <font color='blue'>``filter()``</font> y  <font color='blue'>``reduce()``</font> son ejemplos destacados de funciones de orden superior.\n",
        "\n",
        "### ``map()``\n",
        "- La función <font color='blue'>``map()``</font> aplica una función a cada elemento de un iterable y devuelve un nuevo iterable con los resultados.\n",
        "\n",
        "~~~python\n",
        "def cuadrado(x):\n",
        "    return x ** 2\n",
        "\n",
        "numeros = [1, 2, 3, 4, 5]\n",
        "cuadrados = list(map(cuadrado, numeros))\n",
        "print(cuadrados)  # Salida: [1, 4, 9, 16, 25]\n",
        "~~~\n",
        "\n",
        "- También se puede utilizar una función lambda con <font color='blue'>``map()``</font>:\n",
        "\n",
        "~~~python\n",
        "numeros = [1, 2, 3, 4, 5]\n",
        "cuadrados = list(map(lambda x: x ** 2, numeros))\n",
        "print(cuadrados)  # Salida: [1, 4, 9, 16, 25]\n",
        "~~~\n",
        "\n",
        "### ``filter()``\n",
        "- La función <font color='blue'>``filter()``</font> filtra los elementos de un iterable en función de un predicado (una función que devuelve True o False) y devuelve un nuevo iterable con los elementos que cumplen la condición.\n",
        "\n",
        "~~~python\n",
        "def es_par(x):\n",
        "    return x % 2 == 0\n",
        "\n",
        "numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "pares = list(filter(es_par, numeros))\n",
        "print(pares)  # Salida: [2, 4, 6, 8, 10]\n",
        "~~~\n",
        "\n",
        "- Uso de una función lambda con <font color='blue'>``filter()``</font>:\n",
        "\n",
        "~~~python\n",
        "numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "pares = list(filter(lambda x: x % 2 == 0, numeros))\n",
        "print(pares)  # Salida: [2, 4, 6, 8, 10]\n",
        "~~~\n",
        "\n",
        "### ``reduce()``\n",
        "- La función <font color='blue'>``reduce()``</font> aplica una función de dos argumentos acumulativamente a los elementos de un iterable, reduciendo el iterable a un único valor.\n",
        "- A partir de Python 3, <font color='blue'>``reduce()``</font> se encuentra en el módulo functools.\n",
        "\n",
        "~~~python\n",
        "from functools import reduce\n",
        "\n",
        "def suma(x, y):\n",
        "    return x + y\n",
        "\n",
        "numeros = [1, 2, 3, 4, 5]\n",
        "suma_total = reduce(suma, numeros)\n",
        "print(suma_total)  # Salida: 15\n",
        "~~~\n",
        "\n",
        "- Uso de una función lambda con <font color='blue'>``reduce()``</font>:\n",
        "\n",
        "~~~python\n",
        "from functools import reduce\n",
        "\n",
        "numeros = [1, 2, 3, 4, 5]\n",
        "suma_total = reduce(lambda x, y: x + y, numeros)\n",
        "print(suma_total)  # Salida: 15\n",
        "~~~"
      ],
      "metadata": {
        "id": "lajtN8l3O_dX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Ejemplos\n",
        "\n",
        "1. Tenemos una lista de productos, donde cada producto es un diccionario con su nombre, precio y cantidad.\n",
        "\n",
        "    Utilizamos <font color='blue'>``map()``</font> para calcular el valor total de cada producto multiplicando su precio por la cantidad.\n",
        "\n",
        "    Luego, utilizamos <font color='blue'>``filter()``</font> para filtrar los productos cuyo valor total sea mayor a 100.\n",
        "\n",
        "    Finalmente, utilizamos <font color='blue'>``reduce()``</font> para calcular el valor total de todos los productos sumando los valores totales individuales.\n",
        "\n",
        "~~~python\n",
        "from functools import reduce\n",
        "\n",
        "# Lista de productos\n",
        "productos = [\n",
        "    {'nombre': 'Camiseta', 'precio': 20, 'cantidad': 5},\n",
        "    {'nombre': 'Pantalón', 'precio': 30, 'cantidad': 4},\n",
        "    {'nombre': 'Zapatos', 'precio': 50, 'cantidad': 2},\n",
        "    {'nombre': 'Gorra', 'precio': 10, 'cantidad': 7},\n",
        "    {'nombre': 'Calcetines', 'precio': 5, 'cantidad': 10}\n",
        "]\n",
        "\n",
        "# Calcular el valor total de cada producto\n",
        "valores_totales = list(map(lambda x: x['precio'] * x['cantidad'], productos))\n",
        "\n",
        "# Filtrar los productos con un valor total mayor a 100\n",
        "productos_filtrados = list(filter(lambda x: x['precio'] * x['cantidad'] > 100, productos))\n",
        "\n",
        "# Calcular el valor total de todos los productos\n",
        "valor_total = reduce(lambda x, y: x + y['precio'] * y['cantidad'], productos, 0)\n",
        "\n",
        "print(\"Valores totales de cada producto:\", valores_totales)\n",
        "print(\"Productos con valor total mayor a 100:\", productos_filtrados)\n",
        "print(\"Valor total de todos los productos:\", valor_total)\n",
        "~~~\n",
        "\n",
        "##### Ejercicios\n",
        "\n",
        "1. Utiliza ``map()`` para convertir una lista de grados Celsius a grados Fahrenheit.\n",
        "\n",
        "2. Utiliza ``filter()`` para obtener una lista de las palabras que tienen más de 5 caracteres en una lista dada.\n",
        "\n",
        "3. Utiliza ``reduce()`` para calcular el producto de todos los números en una lista.\n",
        "\n",
        "4. Crea una función de orden superior llamada ``aplicar_operaciones`` que tome una lista de números y una lista de funciones, y devuelva una nueva lista con el resultado de aplicar cada función a cada número.\n",
        "\n",
        "5. Escribe una función de orden superior llamada ``composicion`` que tome dos funciones ``f`` y ``g`` como argumentos y devuelva una nueva función que sea la composición de ``f`` y ``g``.\n",
        "\n",
        "**Soluciones**\n",
        "\n",
        "<details><summary>Click para ver las soluciones</summary>\n",
        "\n",
        "1. Conversión de grados Celsius a Fahrenheit:\n",
        "\n",
        "    ~~~python\n",
        "    # Lista de grados Celsius\n",
        "    celsius = [0, 20, 37, 100]\n",
        "\n",
        "    # Función lambda para convertir Celsius a Fahrenheit\n",
        "    celsius_a_fahrenheit = lambda c: (c * 9/5) + 32\n",
        "\n",
        "    # Usamos map para aplicar la conversión a cada elemento de la lista\n",
        "    fahrenheit = list(map(celsius_a_fahrenheit, celsius))\n",
        "\n",
        "    #print(fahrenheit)  # Salida esperada: [32.0, 68.0, 98.6, 212.0]\n",
        "    ~~~\n",
        "\n",
        "2. Filtrar palabras con más de 5 caracteres:\n",
        "\n",
        "    ~~~python\n",
        "    # Lista de palabras\n",
        "    palabras = [\"manzana\", \"pera\", \"plátano\", \"kiwi\", \"sandía\", \"uva\"]\n",
        "\n",
        "    # Usamos filter con una función lambda para obtener solo las palabras con más de 5 caracteres\n",
        "    palabras_largas = list(filter(lambda palabra: len(palabra) > 5, palabras))\n",
        "\n",
        "    #print(palabras_largas)  # Salida esperada: ['manzana', 'plátano', 'sandía']\n",
        "    ~~~\n",
        "\n",
        "3. Calcular el producto de los números en una lista:\n",
        "\n",
        "    ~~~python\n",
        "    from functools import reduce\n",
        "\n",
        "    # Lista de números\n",
        "    numeros = [2, 3, 4, 5]\n",
        "\n",
        "    # Función lambda para calcular el producto\n",
        "    producto = reduce(lambda x, y: x * y, numeros)\n",
        "\n",
        "    #print(producto)  # Salida esperada: 120\n",
        "    ~~~\n",
        "\n",
        "4. Función aplicar_operaciones:\n",
        "\n",
        "    ~~~python\n",
        "    def aplicar_operaciones(lista_numeros, lista_funciones):\n",
        "        \"\"\"\n",
        "        Aplica una lista de funciones a cada número en la lista de números.\n",
        "        \n",
        "        :param lista_numeros: Lista de números a procesar.\n",
        "        :param lista_funciones: Lista de funciones a aplicar.\n",
        "        :return: Una nueva lista con el resultado de aplicar cada función a cada número.\n",
        "        \"\"\"\n",
        "        resultado = []\n",
        "        for numero in lista_numeros:\n",
        "            for funcion in lista_funciones:\n",
        "                resultado.append(funcion(numero))\n",
        "        return resultado\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #numeros = [1, 2, 3]\n",
        "    #funciones = [lambda x: x * 2, lambda x: x + 3]\n",
        "\n",
        "    #resultado = aplicar_operaciones(numeros, funciones)\n",
        "    #print(resultado)  # Salida esperada: [2, 4, 6, 4, 5, 6]\n",
        "    ~~~\n",
        "\n",
        "5. Función composicion:\n",
        "\n",
        "    ~~~python\n",
        "    def composicion(f, g):\n",
        "        \"\"\"\n",
        "        Devuelve una nueva función que es la composición de f y g.\n",
        "        \n",
        "        :param f: Función a aplicar después.\n",
        "        :param g: Función a aplicar antes.\n",
        "        :return: Una nueva función que aplica g y luego f.\n",
        "        \"\"\"\n",
        "        return lambda x: f(g(x))\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #def sumar_dos(x):\n",
        "    #    return x + 2\n",
        "\n",
        "    #def cuadrado(x):\n",
        "    #    return x * x\n",
        "\n",
        "    # Composición de sumar_dos y cuadrado\n",
        "    #funcion_compuesta = composicion(sumar_dos, cuadrado)\n",
        "\n",
        "    #print(funcion_compuesta(3))  # Salida esperada: 11 (porque (3^2) + 2 = 11)\n",
        "    ~~~\n",
        "\n",
        "</details>\n"
      ],
      "metadata": {
        "id": "FTMbHuvUPPhT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##  Decoradores en Python\n",
        "* Los decoradores en Python son una forma de modificar o extender el comportamiento de una función sin modificar su código fuente directamente.\n",
        "* Son funciones que toman otra función como argumento y devuelven una nueva función que envuelve o decora la función original.\n",
        "\n",
        "### Concepto y sintaxis\n",
        "\n",
        "* Un decorador se define como una función que toma otra función como argumento y devuelve una nueva función.\n",
        "* La sintaxis para aplicar un decorador a una función es colocar el nombre del decorador precedido por el símbolo <font color=\"blue\">``@``</font> justo antes de la definición de la función.\n",
        "\n",
        "~~~python\n",
        "def decorador(funcion):\n",
        "    def nueva_funcion(*args, **kwargs):\n",
        "        # Código antes de llamar a la función original\n",
        "        resultado = funcion(*args, **kwargs)\n",
        "        # Código después de llamar a la función original\n",
        "        return resultado\n",
        "    return nueva_funcion\n",
        "\n",
        "@decorador\n",
        "def funcion_original(arg1, arg2):\n",
        "    # Código de la función original\n",
        "    return resultado\n",
        "~~~\n",
        "\n",
        "### Decoradores con argumentos\n",
        "* Los decoradores también pueden tomar argumentos adicionales para personalizar su comportamiento.\n",
        "* En este caso, se define una función adicional que toma los argumentos del decorador y devuelve el decorador real.\n",
        "\n",
        "~~~python\n",
        "def decorador_con_argumentos(arg_decorador):\n",
        "    def decorador(funcion):\n",
        "        def nueva_funcion(*args, **kwargs):\n",
        "            # Código antes de llamar a la función original\n",
        "            resultado = funcion(*args, **kwargs)\n",
        "            # Código después de llamar a la función original\n",
        "            return resultado\n",
        "        return nueva_funcion\n",
        "    return decorador\n",
        "\n",
        "@decorador_con_argumentos(arg_decorador)\n",
        "def funcion_original(arg1, arg2):\n",
        "    # Código de la función original\n",
        "    return resultado\n",
        "~~~\n",
        "\n",
        "### Decoradores de clases\n",
        "* Los decoradores también se pueden aplicar a las clases para modificar o extender su comportamiento.\n",
        "* En este caso, el decorador toma la clase como argumento y devuelve una nueva clase que envuelve o decora la clase original.\n",
        "\n",
        "~~~python\n",
        "def decorador_clase(cls):\n",
        "    class NuevaClase(cls):\n",
        "        def __init__(self, *args, **kwargs):\n",
        "            # Código antes de inicializar la clase original\n",
        "            super().__init__(*args, **kwargs)\n",
        "            # Código después de inicializar la clase original\n",
        "\n",
        "        def nuevo_metodo(self):\n",
        "            # Código del nuevo método\n",
        "            pass\n",
        "\n",
        "    return NuevaClase\n",
        "\n",
        "@decorador_clase\n",
        "class ClaseOriginal:\n",
        "    def __init__(self, arg1, arg2):\n",
        "        # Código de inicialización de la clase original\n",
        "        pass\n",
        "~~~\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "NiuG-PPCQOOR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Ejemplos\n",
        "\n",
        "1. Definimos un decorador llamado <font color=\"blue\">``medir_tiempo``</font> que mide el tiempo de ejecución de una función. El decorador toma la función original como argumento, guarda el tiempo de inicio antes de llamar a la función original, guarda el tiempo de finalización después de que la función original retorna y calcula el tiempo de ejecución restando el tiempo de finalización del tiempo de inicio.\n",
        "\n",
        "    Luego, aplicamos el decorador <font color=\"blue\">``@medir_tiempo``</font> a la función <font color=\"blue\">``funcion_lenta``</font>, que realiza un cálculo lento sumando números en un bucle. Al llamar a <font color=\"blue\">``funcion_lenta``</font>, el decorador envuelve la función original y muestra el tiempo de ejecución antes de devolver el resultado.\n",
        "\n",
        "~~~python\n",
        "import time\n",
        "\n",
        "def medir_tiempo(funcion):\n",
        "    def nueva_funcion(*args, **kwargs):\n",
        "        inicio = time.time()\n",
        "        resultado = funcion(*args, **kwargs)\n",
        "        fin = time.time()\n",
        "        tiempo_ejecucion = fin - inicio\n",
        "        print(f\"Tiempo de ejecución de {funcion.__name__}: {tiempo_ejecucion:.5f} segundos\")\n",
        "        return resultado\n",
        "    return nueva_funcion\n",
        "\n",
        "@medir_tiempo\n",
        "def funcion_lenta(n):\n",
        "    resultado = 0\n",
        "    for i in range(n):\n",
        "        resultado += i\n",
        "    return resultado\n",
        "\n",
        "resultado = funcion_lenta(10000000)\n",
        "print(f\"Resultado: {resultado}\")\n",
        "~~~\n",
        "\n",
        "##### Ejercicios\n",
        "\n",
        "1. Crea un decorador llamado ``cache`` que almacene en caché los resultados de una función para evitar cálculos repetidos. Si la función se llama con los mismos argumentos, el decorador debe devolver el resultado almacenado en caché en lugar de volver a calcular el resultado.\n",
        "\n",
        "2. Escribe un decorador llamado ``retry`` que intente llamar a una función un número específico de veces si se produce una excepción. Si la función se ejecuta sin errores, el decorador debe devolver el resultado. Si se agotan los reintentos y la función sigue generando una excepción, el decorador debe propagar la excepción.\n",
        "\n",
        "3. Crea un decorador llamado ``authorization`` que verifique si un usuario tiene permisos suficientes para ejecutar una función. El decorador debe tomar un argumento que especifique el nivel de autorización requerido y compararlo con el nivel de autorización del usuario. Si el usuario no tiene suficientes permisos, el decorador debe lanzar una excepción.\n",
        "\n",
        "4. Escribe un decorador llamado ``log`` que registre información sobre las llamadas a una función, como los argumentos pasados, el valor de retorno y el tiempo de ejecución. El decorador debe escribir esta información en un archivo de registro.\n",
        "\n",
        "5. Crea un decorador llamado ``validate`` que valide los argumentos pasados a una función según criterios específicos. El decorador debe tomar los criterios de validación como argumentos y lanzar una excepción si los argumentos no cumplen con los criterios.\n",
        "\n",
        "Soluciones\n",
        "\n",
        "<details><summary>Click para ver las soluciones</summary>\n",
        "\n",
        "1. Decorador ``cache``:\n",
        "\n",
        "    ~~~python\n",
        "    def cache(func):\n",
        "    \"\"\"\n",
        "    Decorador para almacenar en caché los resultados de una función para evitar cálculos repetidos.\n",
        "    \"\"\"\n",
        "    cache_dict = {}  # Diccionario para almacenar los resultados en caché\n",
        "\n",
        "        def wrapper(*args):\n",
        "        \"\"\"\n",
        "        La función wrapper envuelve la función original func. Utiliza *args para aceptar un número variable de argumentos, ya que la caché se basa en los argumentos de la función.\n",
        "        \"\"\"\n",
        "            if args in cache_dict:\n",
        "                # Si los argumentos están en el caché, devuelve el resultado almacenado\n",
        "                return cache_dict[args]\n",
        "            else:\n",
        "                # Calcula el resultado y almacénalo en caché\n",
        "                result = func(*args)\n",
        "                cache_dict[args] = result\n",
        "                return result\n",
        "\n",
        "    return wrapper\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #@cache\n",
        "    #def factorial(n):\n",
        "    #    \"\"\"\n",
        "    #    Calcula el factorial de un número de manera recursiva.\n",
        "    #    \"\"\"\n",
        "    #    if n == 0:\n",
        "    #        return 1\n",
        "    #   return n * factorial(n - 1)\n",
        "\n",
        "    #print(factorial(5))  # Calcula y almacena el resultado\n",
        "    #print(factorial(5))  # Devuelve el resultado almacenado en caché\n",
        "    #print(factorial(6))  # Calcula el resultado y lo almacena en caché\n",
        "    #print(factorial(6))  # Devuelve el resultado almacenado en caché\n",
        "    ~~~\n",
        "\n",
        "2. Decorador ``retry``:\n",
        "\n",
        "    ~~~python\n",
        "    import time\n",
        "\n",
        "    def retry(max_retries=3, delay=1):\n",
        "        \"\"\"\n",
        "        Decorador para intentar llamar a una función un número específico de veces si se produce una excepción.\n",
        "\n",
        "        :param max_retries: Número máximo de reintentos.\n",
        "        :param delay: Tiempo en segundos para esperar entre intentos.\n",
        "        :return: El resultado de la función si se ejecuta sin errores, o propaga la excepción si se agotan los reintentos.\n",
        "        \"\"\"\n",
        "        def decorator(func):\n",
        "            \"\"\"\n",
        "            Define el decorador real que recibe la función func que se va a decorar.\n",
        "            \"\"\"\n",
        "\n",
        "            def wrapper(*args, **kwargs):\n",
        "            \"\"\"\n",
        "            La función wrapper intenta ejecutar func con los argumentos proporcionados. Si ocurre una excepción, captura la excepción y vuelve a intentar.\n",
        "            \"\"\"\n",
        "                # Guarda la excepción capturada en cada intento fallido\n",
        "                last_exception = None\n",
        "\n",
        "                for attempt in range(max_retries):\n",
        "                    try:\n",
        "                        return func(*args, **kwargs)\n",
        "                    except Exception as e:\n",
        "                        last_exception = e\n",
        "                        print(f\"Intento {attempt + 1} fallido: {e}\")\n",
        "                        if attempt < max_retries - 1:\n",
        "                            time.sleep(delay)  # Espera antes del próximo intento\n",
        "                        else:\n",
        "                            raise last_exception  # Propaga la última excepción si se agotan los reintentos\n",
        "            return wrapper\n",
        "        return decorator\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #@retry(max_retries=5, delay=2)\n",
        "    #def may_fail(divisor):\n",
        "    #    return 10 / divisor\n",
        "\n",
        "    # Llamada a la función que generará una excepción (división por cero)\n",
        "    #try:\n",
        "    #    print(may_fail(0))  # Intentará varias veces antes de propagar la excepción\n",
        "    #except ZeroDivisionError as e:\n",
        "    #    print(f\"Excepción final: {e}\")\n",
        "    ~~~\n",
        "\n",
        "3. Decorador ``authorization``:\n",
        "\n",
        "    ~~~python\n",
        "    def authorization(required_level):\n",
        "        \"\"\"\n",
        "        Decorador para verificar si un usuario tiene permisos suficientes para ejecutar una función.\n",
        "\n",
        "        :param required_level: Nivel de autorización requerido para ejecutar la función.\n",
        "        :return: La función decorada si el usuario tiene permisos suficientes, o lanza una excepción si no los tiene.\n",
        "        \"\"\"\n",
        "\n",
        "        def decorator(func):\n",
        "            \"\"\"\n",
        "            Define el decorador real que recibe la función func que se va a decorar.\n",
        "            \"\"\"\n",
        "\n",
        "            def wrapper(user_level, *args, **kwargs):\n",
        "                \"\"\"\n",
        "                La función wrapper acepta el user_level y otros argumentos (*args y **kwargs). Verifica si el nivel de autorización del usuario\n",
        "                \"\"\"\n",
        "                if user_level < required_level:\n",
        "                    # Verifica el nivel de autorización del usuario\n",
        "                    raise PermissionError(f\"No tienes permisos suficientes. Se requiere nivel {required_level}.\")\n",
        "                return func(user_level, *args, **kwargs)\n",
        "            return wrapper\n",
        "        return decorator\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #@authorization(required_level=3)\n",
        "    #def access_resource(user_level):\n",
        "    #    \"\"\"\n",
        "    #    Función que simula el acceso a un recurso protegido basado en el nivel de autorización del usuario.\n",
        "    #    \"\"\"\n",
        "    #    return \"Recurso accesible\"\n",
        "\n",
        "    # Prueba con un usuario que tiene el nivel de autorización suficiente\n",
        "    #try:\n",
        "    #    print(access_resource(4))  # El usuario tiene nivel 4, que es suficiente\n",
        "    #except PermissionError as e:\n",
        "    #    print(f\"Error: {e}\")\n",
        "\n",
        "    # Prueba con un usuario que no tiene el nivel de autorización suficiente\n",
        "    #try:\n",
        "    #    print(access_resource(2))  # El usuario tiene nivel 2, que no es suficiente\n",
        "    #except PermissionError as e:\n",
        "    #    print(f\"Error: {e}\")\n",
        "    ~~~\n",
        "\n",
        "4. Decorador ``log``:\n",
        "\n",
        "    ~~~python\n",
        "    import time\n",
        "\n",
        "    def log(func):\n",
        "        \"\"\"\n",
        "        Decorador para registrar información sobre las llamadas a una función, incluyendo los argumentos,\n",
        "        el valor de retorno y el tiempo de ejecución. La información se escribe en un archivo de registro.\n",
        "        \"\"\"\n",
        "\n",
        "        def wrapper(*args, **kwargs):\n",
        "            \"\"\"\n",
        "            La función wrapper mide el tiempo de ejecución de func y captura su valor de retorno.\n",
        "            \"\"\"\n",
        "\n",
        "            start_time = time.time()  # Registrar el tiempo de inicio\n",
        "            result = None # Inicializar el resultado para manejar posibles excepciones\n",
        "\n",
        "            try:\n",
        "                result = func(*args, **kwargs)\n",
        "                return result\n",
        "            finally:\n",
        "                end_time = time.time()  # Registrar el tiempo de finalización\n",
        "                execution_time = end_time - start_time\n",
        "\n",
        "                with open('function_log.txt', 'a') as log_file:\n",
        "                    log_file.write(f\"Función: {func.__name__}\\n\")\n",
        "                    log_file.write(f\"Arguments: {args}, {kwargs}\\n\")\n",
        "                    log_file.write(f\"Return value: {result}\\n\")\n",
        "                    log_file.write(f\"Execution time: {execution_time:.4f} seconds\\n\")\n",
        "                    log_file.write('-' * 40 + '\\n')  # Separador para cada entrada en el log\n",
        "        \n",
        "        return wrapper\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #@log\n",
        "    #def calculate_sum(a, b):\n",
        "    #    \"\"\"\n",
        "    #    Calcula la suma de dos números.\n",
        "    #    \"\"\"\n",
        "    #    return a + b\n",
        "\n",
        "    #@log\n",
        "    #def divide(a, b):\n",
        "    #    \"\"\"\n",
        "    #    Divide dos números, manejando la excepción de división por cero.\n",
        "    #    \"\"\"\n",
        "    #    if b == 0:\n",
        "    #        raise ValueError(\"No se puede dividir por cero\")\n",
        "    #    return a / b\n",
        "\n",
        "    # Llamadas a las funciones para generar registros\n",
        "    #try:\n",
        "    #    print(calculate_sum(5, 10))  # Registra la llamada a la función\n",
        "    #    print(divide(10, 2))         # Registra la llamada a la función\n",
        "    #    print(divide(10, 0))         # Lanza una excepción y la registra\n",
        "    #except ValueError as e:\n",
        "    #    print(f\"Error: {e}\")\n",
        "    ~~~\n",
        "\n",
        "5. Decorador ``validate``:\n",
        "\n",
        "    ~~~python\n",
        "    def validate(*validators):\n",
        "        \"\"\"\n",
        "        Decorador para validar los argumentos pasados a una función según los criterios proporcionados.\n",
        "        \n",
        "        :param validators: Funciones de validación que toman un argumento y levantan una excepción si el argumento es inválido.\n",
        "        :return: La función decorada si todos los argumentos pasan las validaciones, o lanza una excepción si algún argumento es inválido.\n",
        "        \"\"\"\n",
        "\n",
        "        def decorator(func):\n",
        "            \"\"\"\n",
        "            Esta es la función interna que define el decorador real. Toma la función que será decorada (func).\n",
        "            \"\"\"\n",
        "\n",
        "            def wrapper(*args, **kwargs):\n",
        "                \"\"\"\n",
        "                Esta función envuelve la función original (func). Aquí es donde se aplican las validaciones a los argumentos.\n",
        "                \"\"\"\n",
        "\n",
        "                # Aplicar los validadores a los argumentos posicionales\n",
        "                for i, arg in enumerate(args):\n",
        "                    if i < len(validators):\n",
        "                        validators[i](arg)\n",
        "                \n",
        "                # Aplicar los validadores a los argumentos de palabra clave\n",
        "                for key, value in kwargs.items():\n",
        "                    for validator in validators:\n",
        "                        if isinstance(value, (int, float, str)):  # Asegúrate de que los validadores se aplican solo a tipos válidos\n",
        "                            validator(value)\n",
        "                \n",
        "                # Si todas las validaciones pasan, llamar a la función original\n",
        "                return func(*args, **kwargs)\n",
        "            \n",
        "            return wrapper\n",
        "        return decorator\n",
        "\n",
        "    # Ejemplo de validadores\n",
        "    #def is_positive(value):\n",
        "    #    \"\"\"Valida que el valor sea positivo. Solo aplica para números.\"\"\"\n",
        "    #    if not isinstance(value, (int, float)):\n",
        "    #        raise ValueError(f\"Se esperaba un número positivo, pero se recibió {value}.\")\n",
        "    #    if value <= 0:\n",
        "    #        raise ValueError(f\"El valor debe ser positivo, pero se recibió {value}.\")\n",
        "\n",
        "    #def is_non_empty_string(value):\n",
        "    #    \"\"\"Valida que el valor sea una cadena no vacía.\"\"\"\n",
        "    #    if not isinstance(value, str) or not value.strip():\n",
        "    #        raise ValueError(f\"El valor debe ser una cadena no vacía, pero se recibió {value}.\")\n",
        "\n",
        "    # Ejemplo de uso\n",
        "    #@validate(is_positive, is_non_empty_string)\n",
        "    #def process_data(amount, description):\n",
        "    #    \"\"\"\n",
        "    #    Función que procesa datos, requiere que `amount` sea positivo y `description` sea una cadena no vacía.\n",
        "    #    \"\"\"\n",
        "    #    return f\"Processing {amount} units of {description}\"\n",
        "\n",
        "    # Prueba con datos válidos\n",
        "    #print(process_data(10, \"Sample Data\"))  # Debería funcionar correctamente\n",
        "\n",
        "    # Prueba con datos inválidos\n",
        "    #try:\n",
        "    #    print(process_data(-5, \"Sample Data\"))  # Lanza una excepción de validación\n",
        "    #except ValueError as e:\n",
        "    #    print(f\"Error: {e}\")\n",
        "\n",
        "    #try:\n",
        "    #    print(process_data(10, \"\"))  # Lanza una excepción de validación\n",
        "    #except ValueError as e:\n",
        "    #    print(f\"Error: {e}\")\n",
        "\n",
        "    ~~~\n",
        "\n",
        "</details>"
      ],
      "metadata": {
        "id": "Y8AXF6nmQYib"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2. Manejo de errores y excepciones\n",
        "\n",
        "## A. Error y excepción\n",
        "\n",
        "- En Python, los **errores** y las **excepciones** son situaciones excepcionales que interrumpen el flujo normal del programa. Los errores pueden ser de dos tipos principales:\n",
        "\n",
        "    1. Errores de sintaxis: Ocurren cuando el código no sigue las reglas de sintaxis de Python y se detectan durante la fase de análisis del código.\n",
        "\n",
        "    2. Excepciones: Ocurren durante la ejecución del programa cuando se produce una situación inesperada o un error en tiempo de ejecución.\n",
        "\n",
        "- Las excepciones se pueden manejar utilizando los bloques <font color='blue'>try</font>,  <font color='blue'>except</font>,  <font color='blue'>else</font> y  <font color='blue'>finally</font>.\n",
        "\n",
        "- El bloque <font color='blue'>try</font> contiene el código que puede generar una excepción, mientras que los bloques <font color='blue'>except</font> especifican cómo se deben manejar las excepciones capturadas.\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "~~~python\n",
        "try:\n",
        "    resultado = 10 / 0\n",
        "except ZeroDivisionError:\n",
        "    print(\"Error: No se puede dividir entre cero.\")\n",
        "\n",
        "#Salida:\n",
        "#Error: No se puede dividir entre cero.\n",
        "~~~\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "Supongamos que est´as implementando una funci´on para reservar\n",
        "habitaciones en un hotel. La funci´on debe verificar que el número de noches y el número de habitaciones solicitadas sean v´alidos, y\n",
        "que el saldo del cliente sea suficiente para cubrir el costo total.\n",
        "\n",
        "~~~python\n",
        "def reserve_hotel_room(user_balance, room_price_per_night, num_nights, num_rooms):\n",
        "    # Asegurarse de que el número de noches y habitaciones sean válidos\n",
        "    assert num_nights > 0, \"El número de noches debe ser mayor a cero.\"\n",
        "    assert num_rooms > 0, \"El número de habitaciones debe ser mayor a cero.\"\n",
        "\n",
        "    total_cost = room_price_per_night * num_nights * num_rooms\n",
        "\n",
        "    # Si el número de habitaciones es mayor a 5, lanzar una excepción\n",
        "    if num_rooms > 5:\n",
        "        raise ValueError(\"No puedes reservar más de 5 habitaciones a la vez.\")\n",
        "\n",
        "    # Si el saldo del usuario es insuficiente, lanzar una excepción\n",
        "    if user_balance < total_cost:\n",
        "        raise ValueError(\"Fondos insuficientes para completar la reserva.\")\n",
        "\n",
        "    # Si todo está bien, proceder con la reserva\n",
        "    user_balance -= total_cost\n",
        "    print(f\"Reserva exitosa! Has reservado {num_rooms} habitaciones por {num_nights} noches.\")\n",
        "    print(f\"Saldo restante: ${user_balance:.2f}\")\n",
        "\n",
        "    return user_balance\n",
        "\n",
        "# Simulación de una reserva de hotel\n",
        "try:\n",
        "    balance = 500.0  # Saldo del usuario\n",
        "    price_per_night = 80.0  # Precio por noche por habitación\n",
        "    nights = 3  # Número de noches a reservar\n",
        "    rooms = 2  # Número de habitaciones a reservar\n",
        "\n",
        "    new_balance = reserve_hotel_room(balance, price_per_night, nights, rooms)\n",
        "except ValueError as e:\n",
        "    print(f\"Error durante la reserva: {e}\")\n",
        "~~~\n",
        "\n",
        "### Adicional:\n",
        "Aqui tienes una descripción detallada de <font color='blue'>try</font>,  <font color='blue'>except</font>,  <font color='blue'>else</font> y  <font color='blue'>finally</font>:\n",
        "\n",
        "* <font color='blue'>try</font>:\n",
        "    - El bloque <font color='blue'>try</font> se utiliza para encapsular el código que puede generar una excepción.\n",
        "    -  Permite separar el código que puede lanzar una excepción del código que maneja la excepción.\n",
        "    - Si se produce una excepción dentro del bloque <font color='blue'>try</font>, el flujo de control se transfiere inmediatamente al bloque <font color='blue'>except</font> correspondiente.\n",
        "\n",
        "\n",
        "* <font color='blue'>except</font>:\n",
        "\n",
        "    - El bloque <font color='blue'>except</font> se utiliza para manejar las excepciones que pueden ocurrir dentro del bloque  <font color='blue'>try</font>.\n",
        "    - Se especifica el tipo de excepción que se desea capturar después de la palabra clave <font color='blue'>except</font>.\n",
        "    - Si se produce una excepción del tipo especificado, el bloque <font color='blue'>except</font> se ejecuta y se pueden tomar acciones apropiadas para manejar el error.\n",
        "    - Se pueden tener múltiples bloques <font color='blue'>except</font> para manejar diferentes tipos de excepciones.\n",
        "\n",
        "* <font color='blue'>else</font>:\n",
        "\n",
        "    - El bloque <font color='blue'>else</font> es opcional y se ejecuta si no se produce ninguna excepción dentro del bloque <font color='blue'>try</font>.\n",
        "    - Se coloca después de todos los bloques <font color='blue'>except</font>.\n",
        "    - Se utiliza para especificar código que debe ejecutarse solo si no se han producido excepciones.\n",
        "\n",
        "* <font color='blue'>finally</font>:\n",
        "\n",
        "    - El bloque <font color='blue'>finally</font> es opcional y se ejecuta siempre, independientemente de si se ha producido una excepción o no.\n",
        "    - Se coloca después de los bloques  <font color='blue'>try</font>,  <font color='blue'>except</font> y  <font color='blue'>else</font>.\n",
        "    - Se utiliza para especificar código de limpieza o finalización que siempre debe ejecutarse, como cerrar archivos, liberar recursos, etc.\n",
        "\n",
        "## B. Uso de depurador\n",
        "\n",
        "- El depurador (debugger) es una herramienta que permite examinar el estado del programa durante su ejecución y ayuda a identificar y corregir errores.\n",
        "\n",
        "- Python proporciona un depurador integrado llamado <font color='blue'>pdb</font> (Python Debugger) que permite realizar un seguimiento paso a paso de la ejecución del programa, inspeccionar variables y modificar el flujo de control.\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "~~~python\n",
        "import pdb\n",
        "\n",
        "def calcular_factorial(n):\n",
        "    resultado = 1\n",
        "    for i in range(1, n + 1):\n",
        "        resultado *= i\n",
        "        pdb.set_trace()  # Punto de interrupción del depurador\n",
        "    return resultado\n",
        "\n",
        "numero = 5\n",
        "factorial = calcular_factorial(numero)\n",
        "print(f\"El factorial de {numero} es: {factorial}\")\n",
        "~~~\n",
        "\n",
        "- Durante la ejecución, el programa se detendrá en el punto de interrupción del depurador, y podrás utilizar comandos como\n",
        "\n",
        "    * n (next): Ejecuta la siguiente línea de código.\n",
        "    * s (step): Entra en la función llamada en la siguiente línea de código.\n",
        "    * c (continue): Continúa la ejecución hasta el siguiente punto de interrupción o hasta el final del programa.\n",
        "    * p (print): Imprime el valor de una expresión.\n",
        "    * q (quit): Sale del depurador y termina la ejecución del programa.\n",
        "\n",
        "## C. Pila de llamadas\n",
        "\n",
        "- La pila de llamadas es una estructura que rastrea las funciones que se están ejecutando en un momento dado.\n",
        "\n",
        "- Cuando se llama a una función, se agrega un nuevo marco de pila (stack frame) a la pila de llamadas, que contiene información sobre los argumentos de la función, las variables locales y el punto de retorno.\n",
        "\n",
        "- Cuando una función retorna, su marco de pila se elimina de la pila de llamadas.\n",
        "\n",
        "\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "~~~python\n",
        "def funcion_a():\n",
        "    valor = 10 / 0\n",
        "\n",
        "def funcion_b():\n",
        "    funcion_a()\n",
        "\n",
        "def funcion_c():\n",
        "    funcion_b()\n",
        "\n",
        "funcion_c()\n",
        "~~~\n",
        "\n",
        "En Python, cuando se produce una excepción y no se maneja adecuadamente, se imprime un traceback que muestra la pila de llamadas en el momento en que ocurrió la excepción, lo que ayuda a identificar la ubicación y la causa del\n",
        "error."
      ],
      "metadata": {
        "id": "zpgXNNRZ7oF5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Ejemplos\n",
        "1. Crea una función llamada ``calcular_raiz_cuadrada`` que calcule la raíz cuadrada de un número. Si se pasa un número negativo a la función, debe lanzar una excepción ``ValueError`` con un mensaje apropiado.\n",
        "\n",
        "<details><summary>Ver la solución</summary>\n",
        "\n",
        "~~~python\n",
        "import math\n",
        "\n",
        "def calcular_raiz_cuadrada(numero):\n",
        "    \"\"\"\n",
        "    Calcula la raíz cuadrada de un número.\n",
        "\n",
        "    :param numero: Número del cual se calculará la raíz cuadrada.\n",
        "                   Debe ser un número no negativo.\n",
        "    :return: La raíz cuadrada del número proporcionado.\n",
        "    :raises ValueError: Si el número es negativo, se lanza una excepción ValueError.\n",
        "    \"\"\"\n",
        "    # Verificar si el número es negativo\n",
        "    if numero < 0:\n",
        "        # Lanzar una excepción ValueError con un mensaje descriptivo si el número es negativo\n",
        "        raise ValueError(f\"No se puede calcular la raíz cuadrada de un número negativo: {numero}.\")\n",
        "    \n",
        "    # Calcular la raíz cuadrada utilizando math.sqrt y devolver el resultado\n",
        "    return math.sqrt(numero)\n",
        "\n",
        "# Ejemplos de uso de la función\n",
        "try:\n",
        "    print(calcular_raiz_cuadrada(16))  # Debería imprimir 4.0 (raíz cuadrada de 16)\n",
        "    print(calcular_raiz_cuadrada(25))  # Debería imprimir 5.0 (raíz cuadrada de 25)\n",
        "    print(calcular_raiz_cuadrada(-9))  # Debería lanzar una excepción ValueError\n",
        "except ValueError as e:\n",
        "    # Captura y muestra el mensaje de la excepción si ocurre un error\n",
        "    print(f\"Error: {e}\")\n",
        "~~~\n",
        "</details>\n",
        "\n",
        "2. Utiliza el depurador de Python para identificar y corregir el error en la siguiente función que calcula el promedio de una lista de números:\n",
        "\n",
        "    ~~~python\n",
        "    def calcular_promedio(numeros):\n",
        "        suma = 0\n",
        "        for numero in numeros:\n",
        "            suma += numero\n",
        "        promedio = suma / len(numeros)\n",
        "        return promedio\n",
        "\n",
        "    lista_numeros = [10, 20, 30, 40, 50]\n",
        "    resultado = calcular_promedio(lista_numeros)\n",
        "    print(\"El promedio es:\", resultado)\n",
        "    ~~~\n",
        "\n",
        "    <details><summary>Ver la solución</summary>\n",
        "    Después de utilizar el depurador y examinar el estado de las variables durante la ejecución, se puede identificar que el error está en la línea promedio = suma / len(numeros), donde se intenta dividir la suma por la longitud de la lista de números. Sin embargo, la variable numeros no está definida en ese ámbito, ya que el parámetro de la función se llama numeros.\n",
        "\n",
        "    ~~~python\n",
        "    def calcular_promedio(numeros):\n",
        "    suma = 0\n",
        "    for numero in numeros:\n",
        "        suma += numero\n",
        "    promedio = suma / len(numeros)\n",
        "    return promedio\n",
        "\n",
        "    lista_numeros = [10, 20, 30, 40, 50]\n",
        "    resultado = calcular_promedio(lista_numeros)\n",
        "    print(\"El promedio es:\", resultado)\n",
        "    ~~~\n",
        "    </details>\n",
        "\n",
        "3. Crea una función llamada calcular_promedio_divisor que reciba una lista de números y un divisor, y calcule el promedio de los números divisibles por el divisor. Si el divisor es cero, la función debe manejar la excepción ZeroDivisionError y mostrar un mensaje de error junto con la pila de llamadas.\n",
        "\n",
        "<details><summary>Ver la solución</summary>\n",
        "\n",
        "~~~python\n",
        "import traceback\n",
        "#Importa el módulo traceback para imprimir la pila de llamadas en caso de excepción.\n",
        "\n",
        "def calcular_promedio_divisor(numeros, divisor):\n",
        "    \"\"\"\n",
        "    Calcula el promedio de los números en la lista que son divisibles por el divisor.\n",
        "\n",
        "    :param numeros: Lista de números a evaluar.\n",
        "    :param divisor: Divisor para determinar la divisibilidad.\n",
        "    :return: El promedio de los números divisibles por el divisor.\n",
        "    :raises ZeroDivisionError: Si el divisor es cero, se maneja la excepción mostrando un mensaje y la pila de llamadas.\n",
        "    \"\"\"\n",
        "    # Lista para almacenar los números divisibles por el divisor\n",
        "    divisibles = []\n",
        "\n",
        "    try:\n",
        "        # Verificar si el divisor es cero\n",
        "        if divisor == 0:\n",
        "            raise ZeroDivisionError(\"El divisor no puede ser cero.\")\n",
        "        \n",
        "        # Filtrar números divisibles por el divisor\n",
        "        for numero in numeros:\n",
        "            if numero % divisor == 0:\n",
        "                divisibles.append(numero)\n",
        "        \n",
        "        # Calcular el promedio de los números divisibles\n",
        "        if len(divisibles) == 0:\n",
        "            return 0  # Retorna 0 si no hay números divisibles para evitar división por cero\n",
        "        \n",
        "        promedio = sum(divisibles) / len(divisibles)\n",
        "        return promedio\n",
        "    \n",
        "    except ZeroDivisionError as e:\n",
        "        # Mostrar un mensaje de error y la pila de llamadas si ocurre una excepción\n",
        "        print(f\"Error: {e}\")\n",
        "        traceback.print_exc()  # Imprime la pila de llamadas de la excepción\n",
        "\n",
        "# Ejemplos de uso\n",
        "print(calcular_promedio_divisor([10, 20, 30, 40, 50], 10))  # Debería imprimir 30.0 (promedio de 10, 20, 30, 40, 50)\n",
        "print(calcular_promedio_divisor([10, 20, 30, 40, 50], 0))   # Debería manejar la excepción ZeroDivisionError\n",
        "\n",
        "~~~\n",
        "</details>\n",
        "\n",
        "4. Cear una función ``calcular_promedio`` de una lista de valores que contemple el uso de ``try``, ``except``, ``else`` y ``finally``\n",
        "\n",
        "<details><summary>Ver la solución</summary>\n",
        "\n",
        "~~~python\n",
        "def calcular_promedio(valores):\n",
        "    \"\"\"\n",
        "    Calcula el promedio de una lista de valores.\n",
        "\n",
        "    :param valores: Lista de números para calcular el promedio.\n",
        "    :return: El promedio de los números en la lista.\n",
        "    :raises ValueError: Si la lista está vacía, se lanza una excepción ValueError.\n",
        "    \"\"\"\n",
        "    try:\n",
        "        # Verificar si la lista está vacía\n",
        "        if not valores:\n",
        "            raise ValueError(\"La lista está vacía. No se puede calcular el promedio.\")\n",
        "        \n",
        "        # Calcular el promedio\n",
        "        suma = sum(valores)\n",
        "        conteo = len(valores)\n",
        "        promedio = suma / conteo\n",
        "    \n",
        "    except ValueError as e:\n",
        "        # Manejar el caso cuando la lista está vacía\n",
        "        print(f\"Error: {e}\")\n",
        "        promedio = None  # Valor de retorno cuando hay un error\n",
        "    \n",
        "    else:\n",
        "        # Este bloque se ejecuta si no hay excepciones\n",
        "        print(\"Promedio calculado exitosamente.\")\n",
        "    \n",
        "    finally:\n",
        "        # Este bloque siempre se ejecuta, independientemente de si ocurrió una excepción o no\n",
        "        print(\"Ejecución de la función finalizarizada.\")\n",
        "    \n",
        "    return promedio\n",
        "\n",
        "# Ejemplos de uso\n",
        "print(calcular_promedio([10, 20, 30, 40, 50]))  # Debería imprimir el promedio y los mensajes de éxito\n",
        "print(calcular_promedio([]))  # Debería manejar la excepción de lista vacía y mostrar los mensajes de error\n",
        "\n",
        "~~~\n",
        "</details>\n",
        "\n",
        "5. Analice el uso de ``pdb`` en el siguiente codigo. Durante la ejecución, el programa se detendrá en el punto de interrupción del depurador. Puedes utilizar comandos como n (next) para avanzar línea por línea, p (print) para imprimir el valor de una variable, entre otros.\n",
        "\n",
        "~~~python\n",
        "import pdb\n",
        "\n",
        "def calcular_mediana(lista):\n",
        "    pdb.set_trace()  # Punto de interrupción del depurador\n",
        "    lista_ordenada = sorted(lista)\n",
        "    longitud = len(lista_ordenada)\n",
        "    if longitud % 2 == 0:\n",
        "        indice = longitud // 2\n",
        "        mediana = (lista_ordenada[indice - 1] + lista_ordenada[indice]) / 2\n",
        "    else:\n",
        "        indice = longitud // 2\n",
        "        mediana = lista_ordenada[indice]\n",
        "    return mediana\n",
        "\n",
        "datos = [5, 2, 9, 1, 7, 4]\n",
        "resultado = calcular_mediana(datos)\n",
        "print(\"La mediana es:\", resultado)\n",
        "~~~\n",
        "\n",
        "6. Identifique la pila de llamadas en el siguiente codigo.\n",
        "\n",
        "~~~python\n",
        "import traceback\n",
        "\n",
        "def funcion_a(n):\n",
        "    if n == 0:\n",
        "        raise ValueError(\"El argumento no puede ser cero.\")\n",
        "    return 10 / n\n",
        "\n",
        "def funcion_b(n):\n",
        "    resultado = funcion_a(n)\n",
        "    print(\"El resultado es:\", resultado)\n",
        "\n",
        "def funcion_c(n):\n",
        "    funcion_b(n)\n",
        "\n",
        "try:\n",
        "    funcion_c(0)\n",
        "except ValueError as error:\n",
        "    print(\"Error:\", str(error))\n",
        "    print(\"Pila de llamadas:\")\n",
        "    # la pila de llamadas se imprime utilizando\n",
        "    traceback.print_exc()\n",
        "\n",
        "# El método traceback.print_exc() es útil para depurar y entender dónde y cómo se produjo un error en el código. Imprime la pila de llamadas completa que muestra el flujo de ejecución hasta el punto donde ocurrió la excepción.\n",
        "~~~\n",
        "\n",
        "7.  Definimos una función procesar_archivo que intenta abrir un archivo, leer su contenido y procesarlo. Utilizamos múltiples bloques except para manejar diferentes tipos de excepciones que pueden ocurrir, como FileNotFoundError si el archivo no existe o IOError si no se puede leer el archivo. La cláusula finally se utiliza para garantizar que el archivo se cierre correctamente, independientemente de si se produjo una excepción o no. Utilizamos la función locals() para verificar si la variable archivo está definida antes de intentar cerrarla.\n",
        "\n",
        "~~~python\n",
        "def procesar_archivo(ruta_archivo):\n",
        "    \"\"\"\n",
        "    Intenta abrir y leer un archivo, procesar su contenido, y manejar excepciones comunes.\n",
        "\n",
        "    :param ruta_archivo: La ruta al archivo que se va a procesar.\n",
        "    \"\"\"\n",
        "    archivo = None  # Inicializa la variable archivo\n",
        "    try:\n",
        "        # Intentar abrir el archivo\n",
        "        archivo = open(ruta_archivo, 'r')\n",
        "        # Leer el contenido del archivo\n",
        "        contenido = archivo.read()\n",
        "        # Procesar el contenido (esto es solo un ejemplo; aquí podrías añadir lógica específica)\n",
        "        print(\"Contenido del archivo:\")\n",
        "        print(contenido)\n",
        "    \n",
        "    except FileNotFoundError:\n",
        "        # Manejar el caso en que el archivo no se encuentra\n",
        "        print(f\"Error: El archivo '{ruta_archivo}' no se encuentra.\")\n",
        "    \n",
        "    except IOError:\n",
        "        # Manejar errores de entrada/salida, como problemas al leer el archivo\n",
        "        print(f\"Error: No se puede leer el archivo '{ruta_archivo}'.\")\n",
        "    \n",
        "    finally:\n",
        "        # Asegurarse de que el archivo se cierra, si ha sido abierto\n",
        "        if 'archivo' in locals() and archivo is not None:\n",
        "            archivo.close()\n",
        "            print(\"El archivo ha sido cerrado correctamente.\")\n",
        "        else:\n",
        "            print(\"No se abrió ningún archivo, por lo que no hay que cerrarlo.\")\n",
        "\n",
        "# Ejemplo de uso\n",
        "procesar_archivo('archivo_de_prueba.txt')  # Cambia 'archivo_de_prueba.txt' por una ruta válida o inexistente para probar\n",
        "\n",
        "~~~\n",
        "\n",
        "\n",
        "#### Ejercicios\n",
        "\n",
        "1. Crea una función llamada ``calcular_raiz_cuadrada`` que calcule la raíz cuadrada de un número. Si se pasa un número negativo a la función, debe lanzar una excepción ``ValueError`` con un mensaje apropiado. Utiliza ``try``, ``except`` y ``else`` para manejar la excepción y mostrar el resultado.\n",
        "\n",
        "~~~python\n",
        "import math\n",
        "\n",
        "def calcular_raiz_cuadrada(numero):\n",
        "    \"\"\"\n",
        "    Calcula la raíz cuadrada de un número. Lanza una excepción ValueError si el número es negativo.\n",
        "\n",
        "    :param numero: El número del cual se calculará la raíz cuadrada.\n",
        "    :return: La raíz cuadrada del número.\n",
        "    :raises ValueError: Si el número es negativo.\n",
        "    \"\"\"\n",
        "    try:\n",
        "        # Verificar si el número es negativo\n",
        "        if numero < 0:\n",
        "            raise ValueError(\"No se puede calcular la raíz cuadrada de un número negativo.\")\n",
        "        \n",
        "        # Calcular la raíz cuadrada\n",
        "        raiz = math.sqrt(numero)\n",
        "    \n",
        "    except ValueError as e:\n",
        "        # Manejar la excepción si el número es negativo\n",
        "        print(f\"Error: {e}\")\n",
        "        raiz = None  # Asigna None si ocurre una excepción\n",
        "    \n",
        "    else:\n",
        "        # Este bloque se ejecuta si no hay excepciones\n",
        "        print(f\"La raíz cuadrada de {numero} es {raiz}.\")\n",
        "    \n",
        "    return raiz\n",
        "\n",
        "# Ejemplos de uso\n",
        "print(calcular_raiz_cuadrada(25))  # Debería imprimir la raíz cuadrada y el mensaje correspondiente\n",
        "print(calcular_raiz_cuadrada(-9))  # Debería imprimir el mensaje de error\n",
        "\n",
        "~~~\n",
        "\n",
        "2. Escribe una función llamada ``dividir_numeros`` que reciba dos números como argumentos y realice la división del primer número por el segundo. Utiliza ``try``, ``except``, ``else`` y ``finally`` para manejar la excepción ``ZeroDivisionError`` si el segundo número es cero y mostrar un mensaje de error. En el bloque ``else``, muestra el resultado de la división. En el bloque ``finally``, muestra un mensaje indicando que la operación ha finalizado.\n",
        "\n",
        "~~~python\n",
        "def dividir_numeros(dividendo, divisor):\n",
        "    \"\"\"\n",
        "    Realiza la división del primer número (dividendo) por el segundo número (divisor).\n",
        "    Maneja la excepción ZeroDivisionError si el divisor es cero y muestra un mensaje de error.\n",
        "    En el bloque else, muestra el resultado de la división.\n",
        "    En el bloque finally, muestra un mensaje indicando que la operación ha finalizado.\n",
        "\n",
        "    :param dividendo: El número que se dividirá.\n",
        "    :param divisor: El número por el cual se divide.\n",
        "    :return: El resultado de la división, o None si ocurre un error.\n",
        "    \"\"\"\n",
        "    resultado = None  # Inicializa el resultado\n",
        "    try:\n",
        "        # Intentar realizar la división\n",
        "        resultado = dividendo / divisor\n",
        "    \n",
        "    except ZeroDivisionError:\n",
        "        # Manejar el caso en que el divisor es cero\n",
        "        print(\"Error: No se puede dividir por cero.\")\n",
        "    \n",
        "    else:\n",
        "        # Este bloque se ejecuta si no se produce ninguna excepción\n",
        "        print(f\"El resultado de la división de {dividendo} entre {divisor} es {resultado}.\")\n",
        "    \n",
        "    finally:\n",
        "        # Este bloque se ejecuta siempre, sin importar si ocurrió una excepción o no\n",
        "        print(\"La operación de división ha finalizado.\")\n",
        "\n",
        "    return resultado\n",
        "\n",
        "# Ejemplos de uso\n",
        "print(dividir_numeros(10, 2))  # Debería mostrar el resultado de la división y el mensaje de finalización\n",
        "print(dividir_numeros(10, 0))  # Debería mostrar un mensaje de error y el mensaje de finalización\n",
        "\n",
        "~~~\n",
        "\n",
        "3. Crea una función llamada ``calcular_promedio_archivo`` que lea números desde un archivo de texto y calcule su promedio. Utiliza ``pdb`` para establecer puntos de interrupción y depurar la función. Asegúrate de manejar las excepciones apropiadas, como ``FileNotFoundError`` si el archivo no existe y ``ValueError`` si el archivo contiene datos no numéricos.\n",
        "\n",
        "~~~python\n",
        "import pdb\n",
        "\n",
        "def calcular_promedio_archivo(ruta_archivo):\n",
        "    \"\"\"\n",
        "    Lee números desde un archivo de texto y calcula su promedio.\n",
        "    Maneja excepciones para archivos no encontrados y datos no numéricos.\n",
        "\n",
        "    :param ruta_archivo: Ruta al archivo de texto que contiene números.\n",
        "    :return: El promedio de los números leídos desde el archivo.\n",
        "    \"\"\"\n",
        "    numeros = []\n",
        "    try:\n",
        "        with open(ruta_archivo, 'r') as archivo:\n",
        "            # Establecer un punto de interrupción para depuración\n",
        "            pdb.set_trace()\n",
        "            \n",
        "            # Leer líneas del archivo y procesar cada línea\n",
        "            for linea in archivo:\n",
        "                try:\n",
        "                    # Convertir cada línea en un número flotante y agregar a la lista\n",
        "                    numero = float(linea.strip())\n",
        "                    numeros.append(numero)\n",
        "                except ValueError:\n",
        "                    # Manejar el caso en que los datos en el archivo no son números\n",
        "                    print(f\"Advertencia: '{linea.strip()}' no es un número válido y será ignorado.\")\n",
        "        \n",
        "        # Calcular el promedio si hay números en la lista\n",
        "        if numeros:\n",
        "            promedio = sum(numeros) / len(numeros)\n",
        "        else:\n",
        "            promedio = None  # No hay números en el archivo\n",
        "\n",
        "    except FileNotFoundError:\n",
        "        # Manejar el caso en que el archivo no se encuentra\n",
        "        print(f\"Error: El archivo '{ruta_archivo}' no se encontró.\")\n",
        "        promedio = None\n",
        "    \n",
        "    except Exception as e:\n",
        "        # Manejar cualquier otra excepción no esperada\n",
        "        print(f\"Se produjo un error inesperado: {e}\")\n",
        "        promedio = None\n",
        "\n",
        "    # Mostrar el resultado del promedio\n",
        "    print(f\"El promedio de los números en el archivo es: {promedio}\" if promedio is not None else \"No se pudo calcular el promedio.\")\n",
        "\n",
        "    return promedio\n",
        "\n",
        "# Ejemplo de uso\n",
        "# Asegúrate de reemplazar 'ruta_del_archivo.txt' con la ruta real de tu archivo de texto\n",
        "print(calcular_promedio_archivo('ruta_del_archivo.txt'))\n",
        "\n",
        "~~~\n",
        "\n",
        "4. Escribe una función llamada ``calcular_factorial`` que calcule el factorial de un número dado. Si se pasa un número negativo a la función, debe lanzar una excepción ``ValueError`` con un mensaje apropiado. Crea otra función llamada ``calcular_combinaciones`` que utilice la función ``calcular_factorial`` para calcular el número de combinaciones de ``n`` elementos tomados de ``k`` en ``k`` ($\\displaystyle C^n_k)$). Maneja las excepciones y muestra la pila de llamadas en caso de error.\n",
        "\n",
        "~~~python\n",
        "import traceback\n",
        "\n",
        "def calcular_factorial(n):\n",
        "    \"\"\"\n",
        "    Calcula el factorial de un número no negativo.\n",
        "\n",
        "    :param n: El número para calcular el factorial.\n",
        "    :return: El factorial del número.\n",
        "    :raises ValueError: Si el número es negativo.\n",
        "    \"\"\"\n",
        "    if n < 0:\n",
        "        raise ValueError(\"El número no puede ser negativo.\")\n",
        "    \n",
        "    factorial = 1\n",
        "    for i in range(2, n + 1):\n",
        "        factorial *= i\n",
        "    \n",
        "    return factorial\n",
        "\n",
        "def calcular_combinaciones(n, k):\n",
        "    \"\"\"\n",
        "    Calcula el número de combinaciones de n elementos tomados de k en k.\n",
        "    Utiliza la función calcular_factorial para realizar el cálculo.\n",
        "\n",
        "    :param n: Número total de elementos.\n",
        "    :param k: Número de elementos a tomar.\n",
        "    :return: El número de combinaciones.\n",
        "    \"\"\"\n",
        "    try:\n",
        "        if k > n:\n",
        "            raise ValueError(\"El número de elementos a tomar no puede ser mayor que el total de elementos.\")\n",
        "        \n",
        "        factorial_n = calcular_factorial(n)\n",
        "        factorial_k = calcular_factorial(k)\n",
        "        factorial_n_minus_k = calcular_factorial(n - k)\n",
        "        \n",
        "        combinaciones = factorial_n / (factorial_k * factorial_n_minus_k)\n",
        "    \n",
        "    except ValueError as error:\n",
        "        print(\"Error:\", str(error))\n",
        "        print(\"Pila de llamadas:\")\n",
        "        traceback.print_exc()\n",
        "        combinaciones = None\n",
        "    \n",
        "    except Exception as e:\n",
        "        print(\"Se produjo un error inesperado:\", e)\n",
        "        print(\"Pila de llamadas:\")\n",
        "        traceback.print_exc()\n",
        "        combinaciones = None\n",
        "\n",
        "    return combinaciones\n",
        "\n",
        "# Ejemplos de uso\n",
        "print(calcular_combinaciones(5, 3))  # Ejemplo válido\n",
        "print(calcular_combinaciones(3, 5))  # Ejemplo con error\n",
        "print(calcular_combinaciones(5, -1)) # Ejemplo con error\n",
        "\n",
        "~~~\n",
        "\n",
        "5. Crea una función llamada calcular_promedio que tome una lista de números como argumento y calcule el promedio de esos números. La función debe manejar la excepción ZeroDivisionError si la lista está vacía y la excepción TypeError si algún elemento de la lista no es un número.\n",
        "\n",
        "~~~python\n",
        "def calcular_promedio(lista):\n",
        "    \"\"\"\n",
        "    Calcula el promedio de una lista de números.\n",
        "\n",
        "    :param lista: Lista de números (int o float).\n",
        "    :return: El promedio de los números en la lista.\n",
        "    :raises ZeroDivisionError: Si la lista está vacía.\n",
        "    :raises TypeError: Si algún elemento de la lista no es un número.\n",
        "    \"\"\"\n",
        "    try:\n",
        "        # Verifica que todos los elementos en la lista sean números (int o float)\n",
        "        if not all(isinstance(x, (int, float)) for x in lista):\n",
        "            raise TypeError(\"Todos los elementos de la lista deben ser números.\")\n",
        "\n",
        "        # Calcula la suma de los números en la lista\n",
        "        suma = sum(lista)\n",
        "        \n",
        "        # Calcula el promedio. Si la lista está vacía, esto lanzará una excepción ZeroDivisionError\n",
        "        promedio = suma / len(lista)\n",
        "    \n",
        "    except ZeroDivisionError:\n",
        "        print(\"Error: La lista está vacía, no se puede dividir por cero.\")\n",
        "        promedio = None\n",
        "    \n",
        "    except TypeError as error:\n",
        "        print(\"Error:\", str(error))\n",
        "        promedio = None\n",
        "\n",
        "    return promedio\n",
        "\n",
        "# Ejemplos de uso\n",
        "print(calcular_promedio([10, 20, 30, 40, 50]))  # Debería imprimir 30.0\n",
        "print(calcular_promedio([]))  # Debería manejar el error de división por cero\n",
        "print(calcular_promedio([10, 'a', 30]))  # Debería manejar el error de tipo\n",
        "\n",
        "~~~\n",
        "\n",
        "6. Escribe una función llamada convertir_a_entero que tome una cadena como argumento e intente convertirla a un número entero. La función debe manejar la excepción ValueError si la cadena no representa un número válido y devolver None en ese caso.\n",
        "\n",
        "~~~python\n",
        "def convertir_a_entero(cadena):\n",
        "    \"\"\"\n",
        "    Convierte una cadena a un número entero.\n",
        "\n",
        "    :param cadena: La cadena que se intentará convertir a entero.\n",
        "    :return: El número entero convertido, o None si la conversión falla.\n",
        "    :raises ValueError: Si la cadena no representa un número entero válido.\n",
        "    \"\"\"\n",
        "    try:\n",
        "        # Intenta convertir la cadena a un número entero\n",
        "        entero = int(cadena)\n",
        "    \n",
        "    except ValueError:\n",
        "        # Maneja el error si la cadena no se puede convertir a entero\n",
        "        print(\"Error: La cadena no representa un número entero válido.\")\n",
        "        entero = None\n",
        "\n",
        "    return entero\n",
        "\n",
        "# Ejemplos de uso\n",
        "print(convertir_a_entero(\"123\"))  # Debería imprimir 123\n",
        "print(convertir_a_entero(\"abc\"))  # Debería manejar el error y imprimir None\n",
        "print(convertir_a_entero(\"456.78\"))  # Debería manejar el error y imprimir None\n",
        "\n",
        "~~~\n",
        "\n",
        "7. Crea una función llamada obtener_valor_diccionario que tome un diccionario y una clave como argumentos, y devuelva el valor asociado a esa clave en el diccionario. La función debe manejar la excepción KeyError si la clave no existe en el diccionario y devolver un valor predeterminado en ese caso.\n",
        "\n",
        "~~~python\n",
        "def obtener_valor_diccionario(diccionario, clave, valor_predeterminado=None):\n",
        "    \"\"\"\n",
        "    Obtiene el valor asociado a una clave en un diccionario.\n",
        "\n",
        "    :param diccionario: El diccionario del cual se obtendrá el valor.\n",
        "    :param clave: La clave cuyo valor se desea obtener.\n",
        "    :param valor_predeterminado: El valor a devolver si la clave no existe. Por defecto es None.\n",
        "    :return: El valor asociado a la clave en el diccionario, o el valor predeterminado si la clave no existe.\n",
        "    :raises KeyError: Si la clave no existe en el diccionario y no se proporciona un valor predeterminado.\n",
        "    \"\"\"\n",
        "    try:\n",
        "        # Intenta obtener el valor asociado a la clave\n",
        "        valor = diccionario[clave]\n",
        "    \n",
        "    except KeyError:\n",
        "        # Maneja el error si la clave no existe en el diccionario\n",
        "        print(f\"Clave '{clave}' no encontrada en el diccionario.\")\n",
        "        valor = valor_predeterminado\n",
        "\n",
        "    return valor\n",
        "\n",
        "# Ejemplos de uso\n",
        "mi_diccionario = {'nombre': 'Alice', 'edad': 30, 'ciudad': 'Wonderland'}\n",
        "\n",
        "print(obtener_valor_diccionario(mi_diccionario, 'nombre'))  # Debería imprimir 'Alice'\n",
        "print(obtener_valor_diccionario(mi_diccionario, 'pais', 'Desconocido'))  # Debería imprimir 'Desconocido'\n",
        "print(obtener_valor_diccionario(mi_diccionario, 'pais'))  # Debería imprimir 'None'\n",
        "\n",
        "~~~\n",
        "\n",
        "8. Escribe una función llamada dividir_numeros que tome dos números como argumentos y calcule la división del primer número por el segundo. La función debe manejar la excepción ZeroDivisionError si el segundo número es cero y devolver None en ese caso. Además, la función debe manejar la excepción TypeError si alguno de los argumentos no es un número.\n",
        "\n",
        "~~~python\n",
        "def dividir_numeros(dividendo, divisor):\n",
        "    \"\"\"\n",
        "    Divide el primer número por el segundo número.\n",
        "\n",
        "    :param dividendo: El número que será dividido.\n",
        "    :param divisor: El número por el cual se dividirá el primer número.\n",
        "    :return: El resultado de la división, o None si ocurre un error.\n",
        "    :raises TypeError: Si alguno de los argumentos no es un número.\n",
        "    :raises ZeroDivisionError: Si el divisor es cero.\n",
        "    \"\"\"\n",
        "    try:\n",
        "        # Verifica que ambos argumentos sean números\n",
        "        if not isinstance(dividendo, (int, float)) or not isinstance(divisor, (int, float)):\n",
        "            raise TypeError(\"Ambos argumentos deben ser números.\")\n",
        "        \n",
        "        # Realiza la división\n",
        "        resultado = dividendo / divisor\n",
        "    \n",
        "    except TypeError as e:\n",
        "        # Maneja el error si alguno de los argumentos no es un número\n",
        "        print(\"Error:\", e)\n",
        "        resultado = None\n",
        "\n",
        "    except ZeroDivisionError:\n",
        "        # Maneja el error si el divisor es cero\n",
        "        print(\"Error: No se puede dividir por cero.\")\n",
        "        resultado = None\n",
        "\n",
        "    return resultado\n",
        "\n",
        "# Ejemplos de uso\n",
        "print(dividir_numeros(10, 2))    # Debería imprimir 5.0\n",
        "print(dividir_numeros(10, 0))    # Debería imprimir None y mostrar un mensaje de error\n",
        "print(dividir_numeros(10, 'a'))  # Debería imprimir None y mostrar un mensaje de error\n",
        "print(dividir_numeros('a', 2))   # Debería imprimir None y mostrar un mensaje de error\n",
        "\n",
        "~~~\n",
        "\n",
        "9. Crea una función llamada procesar_datos que tome una lista de diccionarios como argumento y realice algunas operaciones en cada diccionario. La función debe manejar la excepción KeyError si alguna clave necesaria no está presente en un diccionario y continuar con el siguiente diccionario en la lista. Al final, la función debe devolver una lista con los diccionarios procesados correctamente.\n",
        "\n",
        "~~~python\n",
        "def procesar_datos(lista_diccionarios):\n",
        "    \"\"\"\n",
        "    Procesa una lista de diccionarios, realizando operaciones en cada diccionario.\n",
        "\n",
        "    :param lista_diccionarios: Una lista de diccionarios a procesar.\n",
        "    :return: Una lista con los diccionarios procesados correctamente.\n",
        "    \"\"\"\n",
        "    resultados = []  # Lista para almacenar los diccionarios procesados correctamente\n",
        "    \n",
        "    for diccionario in lista_diccionarios:\n",
        "        try:\n",
        "            # Realiza operaciones en el diccionario, por ejemplo:\n",
        "            # Suponiendo que necesitamos las claves 'nombre' y 'edad'\n",
        "            nombre = diccionario['nombre']\n",
        "            edad = diccionario['edad']\n",
        "            \n",
        "            # Realiza alguna operación, como añadir un nuevo campo\n",
        "            diccionario['mayor_de_edad'] = edad >= 18\n",
        "            \n",
        "            # Añade el diccionario procesado a la lista de resultados\n",
        "            resultados.append(diccionario)\n",
        "        \n",
        "        except KeyError as e:\n",
        "            # Maneja el error si falta una clave en el diccionario\n",
        "            print(f\"Error: Falta la clave '{e.args[0]}' en el diccionario. Se omite el diccionario.\")\n",
        "            # Continuar con el siguiente diccionario en la lista\n",
        "\n",
        "    return resultados\n",
        "\n",
        "# Ejemplos de uso\n",
        "datos = [\n",
        "    {'nombre': 'Alice', 'edad': 30},\n",
        "    {'nombre': 'Bob', 'edad': 15},\n",
        "    {'nombre': 'Charlie'},  # Falta la clave 'edad'\n",
        "    {'edad': 25}  # Falta la clave 'nombre'\n",
        "]\n",
        "\n",
        "resultados = procesar_datos(datos)\n",
        "print(\"Datos procesados:\", resultados)\n",
        "\n",
        "~~~\n"
      ],
      "metadata": {
        "id": "XH30LM9X9h6d"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 3. Módulos y paquetes\n",
        "\n",
        "## A. Importación de módulos y paquetes\n",
        "\n",
        "- En Python, los módulos son archivos que contienen definiciones de funciones, clases y variables que se pueden reutilizar en otros programas.\n",
        "\n",
        "- Los paquetes son directorios que contienen múltiples módulos relacionados.\n",
        "\n",
        "- La importación de módulos y paquetes se realiza utilizando la palabra clave <font color='blue'>import</font>.\n",
        "\n",
        "- Se pueden importar módulos completos, funciones o clases específicas de un módulo, o utilizar un alias para el módulo importado.\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "~~~python\n",
        "import math                # Importa el módulo math completo\n",
        "from math import sqrt      # Importa la función sqrt del módulo math\n",
        "import numpy as np         # Importa el módulo numpy con el alias np\n",
        "from scipy import stats    # Importa el submódulo stats del paquete scipy\n",
        "\n",
        "import random\n",
        "\n",
        "# Generar un número aleatorio entre 0 y 1\n",
        "numero_aleatorio = random.random()\n",
        "print(\"Número aleatorio:\", numero_aleatorio)\n",
        "\n",
        "# Generar un número entero aleatorio entre 1 y 10\n",
        "numero_entero = random.randint(1, 10)\n",
        "print(\"Número entero aleatorio:\", numero_entero)\n",
        "\n",
        "from math import pi\n",
        "\n",
        "# Calcular el área de un círculo\n",
        "radio = 5\n",
        "area_circulo = pi * radio ** 2\n",
        "print(\"Área del círculo:\", area_circulo)\n",
        "~~~\n",
        "\n",
        "## B. Creación de módulos y paquetes\n",
        "\n",
        "- Para crear un módulo en Python, simplemente crea un archivo con la extensión <font color='blue'>.py</font> y define las funciones, clases y variables que deseas incluir en el módulo.\n",
        "\n",
        "- Para crear un paquete, crea un directorio con un archivo <font color='blue'>__init__.py</font> (que puede estar vacío) y coloca los módulos relacionados dentro de ese directorio.\n",
        "\n",
        "- La estructura de un paquete puede ser similar a la siguiente:\n",
        "\n",
        "~~~bash\n",
        "mi_paquete/\n",
        "    __init__.py\n",
        "    modulo1.py\n",
        "    modulo2.py\n",
        "    subpaquete/\n",
        "        __init__.py\n",
        "        modulo3.py\n",
        "~~~\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "Supongamos que queremos crear un paquete llamado  <font color='blue'>estadisticas</font> con dos módulos:  <font color='blue'>>descriptiva.py</font> y  <font color='blue'>inferencial.py</font>.\n",
        "\n",
        "~~~python\n",
        "# estadisticas/descriptiva.py\n",
        "def calcular_media(datos):\n",
        "    return sum(datos) / len(datos)\n",
        "\n",
        "def calcular_mediana(datos):\n",
        "    datos_ordenados = sorted(datos)\n",
        "    n = len(datos_ordenados)\n",
        "    if n % 2 == 0:\n",
        "        indice = n // 2\n",
        "        mediana = (datos_ordenados[indice - 1] + datos_ordenados[indice]) / 2\n",
        "    else:\n",
        "        indice = (n - 1) // 2\n",
        "        mediana = datos_ordenados[indice]\n",
        "    return mediana\n",
        "~~~\n",
        "\n",
        "~~~python\n",
        "# estadisticas/inferencial.py\n",
        "from scipy import stats\n",
        "\n",
        "def prueba_t(muestra1, muestra2):\n",
        "    t_statistic, p_value = stats.ttest_ind(muestra1, muestra2)\n",
        "    return t_statistic, p_value\n",
        "\n",
        "def prueba_anova(muestras):\n",
        "    f_statistic, p_value = stats.f_oneway(*muestras)\n",
        "    return f_statistic, p_value\n",
        "~~~\n",
        "\n",
        "Para utilizar los módulos del paquete estadisticas, podemos importarlos de la siguiente manera:\n",
        "\n",
        "~~~python\n",
        "from estadisticas.descriptiva import calcular_media, calcular_mediana\n",
        "from estadisticas.inferencial import prueba_t, prueba_anova\n",
        "\n",
        "datos = [4, 7, 2, 9, 3, 6]\n",
        "media = calcular_media(datos)\n",
        "mediana = calcular_mediana(datos)\n",
        "print(\"Media:\", media)\n",
        "print(\"Mediana:\", mediana)\n",
        "\n",
        "muestra1 = [2, 4, 6, 8, 10]\n",
        "muestra2 = [1, 3, 5, 7, 9]\n",
        "t_statistic, p_value = prueba_t(muestra1, muestra2)\n",
        "print(\"Estadístico t:\", t_statistic)\n",
        "print(\"Valor p:\", p_value)\n",
        "~~~"
      ],
      "metadata": {
        "id": "wUVSWxVKGfG5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Ejemplos\n",
        "\n",
        "1. Crea un programa que utilice el módulo <font color='blue'>datetime</font> para obtener la fecha y hora actual, y luego calcule la diferencia entre esa fecha y una fecha específica que represente tu cumpleaños. Muestra la diferencia en días.\n",
        "\n",
        "    ~~~python\n",
        "    from datetime import datetime\n",
        "\n",
        "    # Obtener la fecha y hora actual\n",
        "    fecha_actual = datetime.now()\n",
        "\n",
        "    # Definir la fecha de tu cumpleaños\n",
        "    fecha_cumpleanos = datetime(2023, 12, 15)  # Reemplaza con tu fecha de cumpleaños\n",
        "\n",
        "    # Calcular la diferencia entre las fechas\n",
        "    diferencia = fecha_cumpleanos - fecha_actual\n",
        "\n",
        "    # Mostrar la diferencia en días\n",
        "    print(\"Faltan\", diferencia.days, \"días para tu cumpleaños.\")\n",
        "    ~~~\n",
        "\n",
        "2.  Crea un paquete llamado  <font color='blue'>analisis_datos</font> con dos módulos:  <font color='blue'>limpieza.py</font> y  <font color='blue'>visualizacion.py</font>. En el módulo  <font color='blue'>limpieza.py</font>, define funciones para eliminar valores faltantes y duplicados de un DataFrame de pandas. En el módulo  <font color='blue'>visualizacion.py</font>, define funciones para crear un histograma y un diagrama de dispersión utilizando matplotlib. Crea un programa que importe y utilice las funciones de ambos módulos.\n",
        "\n",
        "    ~~~python\n",
        "    # analisis_datos/limpieza.py\n",
        "    import pandas as pd\n",
        "\n",
        "    def eliminar_faltantes(df):\n",
        "        df_limpio = df.dropna()\n",
        "        return df_limpio\n",
        "\n",
        "    def eliminar_duplicados(df):\n",
        "        df_sin_duplicados = df.drop_duplicates()\n",
        "        return df_sin_duplicados\n",
        "    ~~~\n",
        "\n",
        "    ~~~python\n",
        "    # analisis_datos/visualizacion.py\n",
        "    import matplotlib.pyplot as plt\n",
        "\n",
        "    def crear_histograma(datos):\n",
        "        plt.hist(datos)\n",
        "        plt.xlabel('Valores')\n",
        "        plt.ylabel('Frecuencia')\n",
        "        plt.title('Histograma')\n",
        "        plt.show()\n",
        "\n",
        "    def crear_diagrama_dispersion(x, y):\n",
        "        plt.scatter(x, y)\n",
        "        plt.xlabel('Eje X')\n",
        "        plt.ylabel('Eje Y')\n",
        "        plt.title('Diagrama de dispersión')\n",
        "        plt.show()\n",
        "    ~~~\n",
        "\n",
        "    ~~~python\n",
        "    # programa_principal.py\n",
        "    import pandas as pd\n",
        "    from analisis_datos.limpieza import eliminar_faltantes, eliminar_duplicados\n",
        "    from analisis_datos.visualizacion import crear_histograma, crear_diagrama_dispersion\n",
        "\n",
        "    # Cargar datos desde un archivo CSV\n",
        "    datos = pd.read_csv('datos.csv')\n",
        "\n",
        "    # Eliminar valores faltantes y duplicados\n",
        "    datos_limpios = eliminar_faltantes(datos)\n",
        "    datos_sin_duplicados = eliminar_duplicados(datos_limpios)\n",
        "\n",
        "    # Crear un histograma de una columna específica\n",
        "    crear_histograma(datos_sin_duplicados['columna1'])\n",
        "\n",
        "    # Crear un diagrama de dispersión entre dos columnas\n",
        "    crear_diagrama_dispersion(datos_sin_duplicados['columna1'], datos_sin_duplicados['columna2'])\n",
        "    ~~~\n",
        "\n",
        "#### Ejercicios\n",
        "\n",
        "1. Crear un Módulo Simple: Crear un módulo que contenga una función para sumar dos números.\n",
        "\n",
        "    - Crea un archivo llamado operaciones.py en el directorio de tu proyecto.\n",
        "\n",
        "    - Define una función llamada sumar que tome dos argumentos y devuelva su suma.\n",
        "\n",
        "~~~python\n",
        "# operaciones.py\n",
        "\n",
        "def sumar(a, b):\n",
        "    \"\"\"\n",
        "    Suma dos números y devuelve el resultado.\n",
        "    \n",
        "    :param a: Primer número.\n",
        "    :param b: Segundo número.\n",
        "    :return: La suma de a y b.\n",
        "    \"\"\"\n",
        "    return a + b\n",
        "\n",
        "# Ejemplo de uso dentro del módulo\n",
        "if __name__ == \"__main__\":\n",
        "    resultado = sumar(5, 3)\n",
        "    print(f\"La suma de 5 y 3 es: {resultado}\")\n",
        "~~~\n",
        "\n",
        "~~~python\n",
        "# prueba_operaciones.py\n",
        "\n",
        "import operaciones\n",
        "\n",
        "resultado = operaciones.sumar(10, 15)\n",
        "print(f\"La suma de 10 y 15 es: {resultado}\")\n",
        "~~~\n",
        "\n",
        "2. Crear un Paquete con Módulos: Crear un paquete que contenga varios módulos con funciones matemáticas básicas.\n",
        "\n",
        "Estructura del Proyecto:\n",
        "~~~bash\n",
        "matematica/\n",
        "    __init__.py\n",
        "    operaciones.py\n",
        "    trigonometria.py\n",
        "\n",
        "~~~\n",
        "\n",
        "Contenido de matematica/operaciones.py\n",
        "~~~python\n",
        "# matematica/operaciones.py\n",
        "\n",
        "def sumar(a, b):\n",
        "    \"\"\"\n",
        "    Suma dos números y devuelve el resultado.\n",
        "    \n",
        "    :param a: Primer número.\n",
        "    :param b: Segundo número.\n",
        "    :return: La suma de a y b.\n",
        "    \"\"\"\n",
        "    return a + b\n",
        "\n",
        "def restar(a, b):\n",
        "    \"\"\"\n",
        "    Resta el segundo número del primer número y devuelve el resultado.\n",
        "    \n",
        "    :param a: Primer número.\n",
        "    :param b: Segundo número.\n",
        "    :return: La resta de a y b.\n",
        "    \"\"\"\n",
        "    return a - b\n",
        "\n",
        "~~~\n",
        "\n",
        "Contenido de matematica/trigonometria.py\n",
        "\n",
        "~~~python\n",
        "# matematica/trigonometria.py\n",
        "\n",
        "import math\n",
        "\n",
        "def seno(radianes):\n",
        "    \"\"\"\n",
        "    Calcula el seno de un ángulo dado en radianes.\n",
        "    \n",
        "    :param radianes: Ángulo en radianes.\n",
        "    :return: El seno del ángulo.\n",
        "    \"\"\"\n",
        "    return math.sin(radianes)\n",
        "\n",
        "def coseno(radianes):\n",
        "    \"\"\"\n",
        "    Calcula el coseno de un ángulo dado en radianes.\n",
        "    \n",
        "    :param radianes: Ángulo en radianes.\n",
        "    :return: El coseno del ángulo.\n",
        "    \"\"\"\n",
        "    return math.cos(radianes)\n",
        "~~~\n",
        "\n",
        "Contenido de matematica/__init__.py\n",
        "\n",
        "~~~python\n",
        "# matematica/__init__.py\n",
        "\n",
        "from .operaciones import sumar, restar\n",
        "from .trigonometria import seno, coseno\n",
        "~~~\n",
        "\n",
        "Prueba\n",
        "\n",
        "~~~python\n",
        "# prueba_paquete.py\n",
        "\n",
        "import matematica\n",
        "\n",
        "print(f\"La suma de 7 y 3 es: {matematica.sumar(7, 3)}\")\n",
        "print(f\"El seno de pi/2 es: {matematica.seno(math.pi / 2)}\")\n",
        "\n",
        "~~~\n",
        "\n",
        "3. Crear un Paquete con Subpaquetes y Configuración: Crear un paquete más complejo con subpaquetes y un archivo setup.py para instalación.\n",
        "\n",
        "Estructura del Proyecto:\n",
        "~~~bash\n",
        "mi_paquete/\n",
        "    __init__.py\n",
        "    matematicas/\n",
        "        __init__.py\n",
        "        operaciones.py\n",
        "        trigonometria.py\n",
        "    utils/\n",
        "        __init__.py\n",
        "        helpers.py\n",
        "    setup.py\n",
        "\n",
        "~~~\n",
        "\n",
        "Contenido de mi_paquete/matematicas/operaciones.py:\n",
        "~~~python\n",
        "# mi_paquete/matematicas/operaciones.py\n",
        "\n",
        "def sumar(a, b):\n",
        "    \"\"\"\n",
        "    Suma dos números y devuelve el resultado.\n",
        "    \n",
        "    :param a: Primer número.\n",
        "    :param b: Segundo número.\n",
        "    :return: La suma de a y b.\n",
        "    \"\"\"\n",
        "    return a + b\n",
        "\n",
        "~~~\n",
        "\n",
        "Contenido de mi_paquete/utils/helpers.py:\n",
        "~~~python\n",
        "# mi_paquete/utils/helpers.py\n",
        "\n",
        "def imprimir_mensaje(mensaje):\n",
        "    \"\"\"\n",
        "    Imprime un mensaje.\n",
        "    \n",
        "    :param mensaje: Mensaje a imprimir.\n",
        "    \"\"\"\n",
        "    print(mensaje)\n",
        "\n",
        "~~~\n",
        "\n",
        "Contenido de mi_paquete/__init__.py:\n",
        "~~~python\n",
        "# mi_paquete/__init__.py\n",
        "\n",
        "from .matematicas.operaciones import sumar\n",
        "from .utils.helpers import imprimir_mensaje\n",
        "\n",
        "~~~\n",
        "\n",
        "Contenido de mi_paquete/setup.py:\n",
        "~~~python\n",
        "from setuptools import setup, find_packages\n",
        "\n",
        "setup(\n",
        "    name=\"mi_paquete\",\n",
        "    version=\"0.1\",\n",
        "    packages=find_packages(),\n",
        "    description=\"Un paquete de ejemplo con matemáticas y utilidades.\",\n",
        "    author=\"Tu Nombre\",\n",
        "    author_email=\"tuemail@example.com\",\n",
        "    url=\"https://github.com/tu_usuario/mi_paquete\",\n",
        ")\n",
        "\n",
        "~~~\n",
        "\n",
        "Prueba: Instala el paquete y utiliza las funciones desde otro script.\n",
        "~~~python\n",
        "pip install .\n",
        "~~~\n",
        "\n",
        "~~~python\n",
        "# prueba_paquete_avanzado.py\n",
        "\n",
        "import mi_paquete\n",
        "\n",
        "resultado = mi_paquete.sumar(10, 5)\n",
        "mi_paquete.imprimir_mensaje(f\"El resultado de la suma es: {resultado}\")\n",
        "\n",
        "~~~\n"
      ],
      "metadata": {
        "id": "Npr-MQCpHIwh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 4. Manejo de archivos\n",
        "\n",
        "## A. Lectura de archivos\n",
        "\n",
        "- En Python, se pueden leer datos desde archivos utilizando la función open() y los métodos read(), readline() y readlines().\n",
        "\n",
        "- La función open() abre un archivo y devuelve un objeto de archivo que se puede utilizar para leer o escribir datos. El modo de apertura por defecto es lectura ('r').\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "~~~python\n",
        "# Leer todo el contenido de un archivo\n",
        "with open('datos.txt', 'r') as archivo:\n",
        "    contenido = archivo.read()\n",
        "\n",
        "# Leer línea por línea\n",
        "with open('datos.txt', 'r') as archivo:\n",
        "    for linea in archivo:\n",
        "        print(linea)\n",
        "\n",
        "# Leer todas las líneas en una lista\n",
        "with open('datos.txt', 'r') as archivo:\n",
        "    lineas = archivo.readlines()\n",
        "~~~\n",
        "\n",
        "- Es recomendable utilizar la declaración with al trabajar con archivos, ya que garantiza que el archivo se cierre correctamente después de su uso.\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "~~~python\n",
        "# Leer un archivo CSV y calcular el promedio de una columna específica\n",
        "import csv\n",
        "\n",
        "def calcular_promedio(archivo, columna):\n",
        "    suma = 0\n",
        "    contador = 0\n",
        "    with open(archivo, 'r') as file:\n",
        "        lector_csv = csv.reader(file)\n",
        "        next(lector_csv)  # Saltar la fila de encabezado\n",
        "        for fila in lector_csv:\n",
        "            valor = float(fila[columna])\n",
        "            suma += valor\n",
        "            contador += 1\n",
        "    promedio = suma / contador\n",
        "    return promedio\n",
        "\n",
        "promedio = calcular_promedio('datos.csv', 2)\n",
        "print(\"Promedio:\", promedio)\n",
        "~~~\n",
        "\n",
        "## B. Escritura de archivos\n",
        "\n",
        "- Para escribir datos en un archivo, se utiliza la función open() con el modo de escritura ('w') o el modo de añadir ('a').\n",
        "\n",
        "- El modo de escritura sobrescribe el contenido existente del archivo, mientras que el modo de añadir agrega el contenido al final del archivo.\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "~~~python\n",
        "# Escribir en un archivo\n",
        "with open('resultados.txt', 'w') as archivo:\n",
        "    archivo.write('Estos son los resultados:\\n')\n",
        "    archivo.write('Resultado 1\\n')\n",
        "    archivo.write('Resultado 2\\n')\n",
        "\n",
        "# Añadir contenido a un archivo existente\n",
        "with open('resultados.txt', 'a') as archivo:\n",
        "    archivo.write('Resultado 3\\n')\n",
        "    archivo.write('Resultado 4\\n')\n",
        "~~~\n",
        "\n",
        "\n",
        "~~~python\n",
        "# Escribir un DataFrame de pandas en un archivo CSV\n",
        "import pandas as pd\n",
        "\n",
        "datos = {'Nombre': ['Juan', 'María', 'Pedro', 'Ana'],\n",
        "         'Edad': [25, 30, 28, 35],\n",
        "         'Ciudad': ['Madrid', 'Barcelona', 'Madrid', 'Sevilla']}\n",
        "\n",
        "df = pd.DataFrame(datos)\n",
        "\n",
        "df.to_csv('datos.csv', index=False)\n",
        "~~~\n"
      ],
      "metadata": {
        "id": "fLGfx_doJHHZ"
      }
    }
  ]
}