11-Conceptos_avanzados/05_tiempo_y_optimizacion.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "a35f9256",
   "metadata": {},
   "source": [
    "# Módulo 11: Conceptos avanzados\n",
    "\n",
    "## Parte 5: Tiempo y optimización\n",
    "\n",
    "En Python, a menudo es necesario medir el tiempo de ejecución del código y optimizar su rendimiento para lograr resultados más rápidos y eficientes. Esta sección explora técnicas para medir el tiempo de ejecución del código y optimizar los programas de Python para mejorar su velocidad y eficiencia.\n",
    "\n",
    "### 5.1. Tiempo de ejecución\n",
    "\n",
    "Medir el tiempo de ejecución del código ayuda a identificar cuellos de botella en el rendimiento y le permite evaluar la eficiencia de diferentes implementaciones. El módulo de tiempo en Python proporciona funciones para la ejecución de código de tiempo, como time.time() y timeit.\n",
    "\n",
    "Para medir el tiempo de ejecución de un bloque de código específico, podemos usar el módulo de tiempo de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cdba6366",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "tiempo_inicio = time.time()\n",
    "\n",
    "# Código a cronometrar\n",
    "for i in range(1000000):\n",
    "    pass\n",
    "\n",
    "tiempo_fin = time.time()\n",
    "tiempo_ejecucion = tiempo_fin - tiempo_inicio\n",
    "\n",
    "print(f\"Tiempo de ejecución: {tiempo_ejecucion} segundos\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "108c0381",
   "metadata": {},
   "source": [
    "En este ejemplo, importamos el módulo de tiempo y registramos la hora de inicio usando time.time(). Luego ejecutamos el código a cronometrar, en este caso, un ciclo simple. Después de la ejecución, calculamos el tiempo transcurrido restando la hora de inicio de la hora actual (time.time()). Finalmente, imprimimos el tiempo de ejecución en segundos.\n",
    "\n",
    "Alternativamente, podemos usar el módulo timeit, que proporciona una forma más precisa de medir el tiempo de ejecución:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a13a4c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import timeit\n",
    "\n",
    "def funcion():\n",
    "    i = 1000\n",
    "    for x in range(1000):\n",
    "        i -= 1\n",
    "\n",
    "tiempo_ejecuciun = timeit.timeit(funcion, number=5)\n",
    "print(f\"Tiempo de ejecución: {tiempo_ejecuciun} segundos\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "76d8e413",
   "metadata": {},
   "source": [
    "En este ejemplo, definimos el código para ser cronometrado en func(). La función timeit.timeit() se usa luego para medir\n",
    "el tiempo de ejecución del código. El argumento número especifica el número de veces que se debe ejecutar el código para obtener un resultado de temporización preciso.\n",
    "\n",
    "### 5.2. Optimización de código\n",
    "\n",
    "La optimización de código tiene como objetivo mejorar el rendimiento de un programa al reducir su tiempo de ejecución o el uso de memoria. Las técnicas de optimización comunes incluyen optimizaciones algorítmicas, optimizaciones de estructura de datos y optimizaciones a nivel de código.\n",
    "Al seleccionar el algoritmo y la estructura de datos correctos para un problema determinado, podemos mejorar significativamente el rendimiento de nuestro código.\n",
    "\n",
    "Algunos ejemplos comunes de algoritmos y estructuras de datos eficientes incluyen:\n",
    "- Uso de tablas hash (diccionarios) para búsquedas rápidas de clave-valor.\n",
    "- Empleo de la búsqueda binaria para realizar búsquedas eficientes en listas ordenadas o matrices.\n",
    "- Utilizar programación dinámica para evitar cálculos redundantes en problemas recursivos.\n",
    "- Implementar estructuras de datos como montones o colas de prioridad para la inserción y recuperación eficiente de elementos.\n",
    "- Comprender la complejidad algorítmica (notación Big O) también es importante para evaluar la eficiencia de diferentes algoritmos y elegir el más apropiado para nuestro caso de uso específico.\n",
    "    La notación Big O representa el límite superior o el peor de los casos de la complejidad de tiempo o espacio de un algoritmo. Expresa cómo se escala el rendimiento del algoritmo a medida que aumenta el tamaño de entrada. Se enfoca en el término más significativo en la ecuación de complejidad y descarta constantes y términos de orden inferior.\n",
    "    - O(1): Tiempo constante. El tiempo de ejecución del algoritmo es constante, independientemente del tamaño de entrada.\n",
    "    - O(log n): Tiempo logarítmico. El tiempo de ejecución del algoritmo crece logarítmicamente con el tamaño de entrada.\n",
    "    - O(n): Tiempo lineal. El tiempo de ejecución del algoritmo crece linealmente con el tamaño de entrada.\n",
    "    - O(n log n): Tiempo log-lineal. El tiempo de ejecución del algoritmo crece linealmente multiplicado por un factor logarítmico.\n",
    "    - O(n^2): Tiempo cuadrático. El tiempo de ejecución del algoritmo crece cuadráticamente con el tamaño de entrada.\n",
    "    - O(2^n): Tiempo exponencial. El tiempo de ejecución del algoritmo crece exponencialmente con el tamaño de entrada.\n",
    "\n",
    "Además de las mejoras algorítmicas, existen varias técnicas de codificación que podemos emplear para optimizar la eficiencia del código:\n",
    "- Minimice los cálculos innecesarios y evite los cálculos redundantes.\n",
    "- Utilice funciones y bibliotecas integradas en lugar de reinventar la rueda.\n",
    "- Optimice los bucles reduciendo el número de iteraciones o utilizando operaciones vectorizadas.\n",
    "- Evitar el uso excesivo de memoria mediante la optimización de estructuras de datos y el uso de generadores o iteradores cuando corresponda.\n",
    "- Utilice técnicas eficientes de manipulación de cadenas, como unir cadenas en lugar de concatenarlas en bucles.\n",
    "- Perfile y analice el código para identificar cuellos de botella en el rendimiento y centrar los esfuerzos de optimización en secciones críticas.\n",
    "\n",
    "Es importante tener en cuenta que la optimización del código debe hacerse con criterio. La optimización prematura puede conducir a un código complejo y más difícil de mantener,\n",
    "por lo que se recomienda enfocarse en optimizar secciones críticas que tienen un impacto significativo en el rendimiento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a33116ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "def suma_de_cuadrados(n):\n",
    "    return sum([i**2 for i in range(1, n + 1)])\n",
    "\n",
    "print(suma_de_cuadrados(100))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "42c55602",
   "metadata": {},
   "source": [
    "En este ejemplo, definimos una función llamada suma_de_cuadrados que calcula la suma de cuadrados de 1 a n. Inicialmente, usa una lista de comprensión para generar los cuadrados de cada número del 1 al n y luego calcula su suma usando la función sum(). Esta implementación tiene una complejidad temporal de O(n). Una versión optimizada podría usar una fórmula matemática para calcular directamente la suma de cuadrados, lo que resulta en una complejidad de tiempo de O(1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5738acab",
   "metadata": {},
   "outputs": [],
   "source": [
    "def proceso_datos(datos):\n",
    "    resultado = []\n",
    "\n",
    "    for elemento in datos:\n",
    "        # Realizar algunas operaciones\n",
    "        elemento_procesado = elemento * 2\n",
    "        resultado.append(elemento_procesado)\n",
    "\n",
    "    return resultado\n",
    "\n",
    "datos = [1, 2, 3, 4, 5]\n",
    "datos_procesados = proceso_datos(datos)\n",
    "\n",
    "print(datos_procesados)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "780b25cd",
   "metadata": {},
   "source": [
    "En este ejemplo, tenemos una función llamada proceso_datos que realiza algunas operaciones en una lista de datos determinada. La implementación actual usa un bucle for y agrega repetidamente elementos procesados a una lista de resultados. Una versión optimizada podría utilizar la comprensión de listas o expresiones generadoras para eliminar el bucle explícito y reducir el uso de memoria.\n",
    "\n",
    "### 5.3. Resumen\n",
    "\n",
    "Exploramos las técnicas de sincronización y optimización del código en Python. La ejecución del código de tiempo y la optimización de los programas de Python son aspectos esenciales de la programación. Al medir el tiempo de ejecución, puede identificar cuellos de botella en el rendimiento y áreas de mejora. Las técnicas de optimización, como las optimizaciones algorítmicas y las optimizaciones a nivel de código, le permiten mejorar la velocidad y la eficiencia de su código. Al comprender y aplicar estas técnicas, puede crear programas de Python optimizados y de mayor rendimiento. Recuerde perfilar y probar su código para asegurarse de que los esfuerzos de optimización den como resultado las mejoras deseadas."
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}