Lectures/Bloque_Cero/Buenas_practicas_al_programar.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `Bloque Cero`\n",
    "\n",
    "## Buenas prácticas al programar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Introducción\n",
    "\n",
    "- Buenas prácticas (generales)\n",
    "\n",
    "- Estilo de codificación y buenas prácticas en Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introducción\n",
    "\n",
    "Cuando se crea una aplicación (software) pueden existir otras que realicen los mismos procedimientos. Entonces, ¿cómo discriminamos cuál es mejor?\n",
    "\n",
    "- Podríamos recurrir a comparar la eficientes de estas en consumo de procesador y/o memoria. \n",
    "- Podríamos recurrir a identificar cuan legibles, fáciles de modificar, fáciles de probar y verificar son.\n",
    "\n",
    "La implementación de una aplicación no se centra en la idea que solo funcione **correctamente**. En muchos de estos casos solo se tendrá una aplicación artesanal. Una aplicación debe ser:\n",
    "- robustas, \n",
    "- eficientes,\n",
    "- fáciles de mantener, etc. \n",
    "\n",
    "A continuación se muestran primeramente una serie de consejos y buenas prácticas acerca de como escribir programas en cualquier lenguaje. Para más información consultar las referencias:\n",
    "\n",
    "* [`Diseño de Programas: Formalismo y Abstracción, Ricardo Peña, Prentice Hall, 1998.`](https://books.google.com.mx/books/about/Diseño_de_programas.html?id=hWLCAAAACAAJ&redir_esc=y)\n",
    "* [`Agile Software Development, Principles, Patterns, and Practices, Robert C. Martin, Pearson. 2ª Edición. Junio 2011.`](https://books.google.com.mx/books/about/Agile_Software_Development.html?id=0HYhAQAAIAAJ&redir_esc=y)\n",
    "\n",
    "Luego se particularizan para el lenguaje [`Phyton`](https://www.python.org)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Buenas Prácticas (generales):\n",
    "\n",
    "1.  **Evitar el uso de variables globales**\n",
    "\n",
    "El uso de variables globales puede resultar tentador, ya que evita la necesidad de pasarlas como parámetros. Sin embargo, su uso puede generar efectos indeseados. El problema radica en que, al ser accesibles globalmente, pueden ser modificadas por otras funciones, asignándoles valores no deseados. Esto puede desencadenar una serie de fallos en cadena."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# En Python, todas las variables definidas dentro de una función son locales por defecto, \n",
    "# lo que significa que solo existen dentro de esa función y no afectan el programa principal. \n",
    "# Aunque los objetos del programa principal (u otras funciones) si pueden afectar a la función. \n",
    "# \n",
    "# Si queremos que una variable local se trate como global dentro de una función, \n",
    "# debemos declararla con la palabra clave `global`.  \n",
    "# Veamos un ejemplo:\n",
    "\n",
    "variable_text = \"variable original\"\n",
    "\n",
    "def variable_global():\n",
    "    global variable_text  # Declaramos que esta variable es global\n",
    "    variable_text = \"variable global modificada\"\n",
    "\n",
    "print(variable_text)  # Imprime: variable original\n",
    "\n",
    "variable_global()\n",
    "\n",
    "print(variable_text)  # Imprime: variable global modificada\n",
    "\n",
    "# ¿Fácil de entender? 😃"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Algunos ejercicios\n",
    "\n",
    "¿Qué valores se imprimirían en cada caso?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TEST 1\n",
    "\n",
    "# del a  # Esta línea está comentada, por lo que no se ejecuta.\n",
    "def subrutina():\n",
    "    global a  # Se declara que 'a' es global\n",
    "    print(a)  # Se imprime el valor actual de 'a'\n",
    "    a += 10   # Se incrementa 'a' + 10\n",
    "\n",
    "a = 33  # Se asigna 33 a 'a'\n",
    "subrutina()  # Llamamos a la función\n",
    "print(a)  # Imprimimos el valor de 'a' después de la función"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🚀 Notar:\n",
    "\n",
    "- Si la línea `del a` no estuviera comentada, habría un error porque \"$a$\" sería eliminada antes de llamar a subrutina(), lo que resultaría en: `NameError: name 'a' is not defined` al intentar imprimir a dentro de la función."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TEST 2\n",
    "\n",
    "def subrutina():\n",
    "    def sub_subrutina():\n",
    "        global a  # Se declara que 'a' es global\n",
    "        a *= 5  # Multiplica 'a' por 5\n",
    "        print(a)  # Imprime el valor de 'a'\n",
    "        return\n",
    "    \n",
    "    a = 4  # Se define una variable local 'a' dentro de 'subrutina'\n",
    "    sub_subrutina()  # Llamamos a 'sub_subrutina'\n",
    "    return\n",
    "\n",
    "a = 3  # Se define la variable global 'a' con valor 3\n",
    "subrutina()  # Se llama a 'subrutina'\n",
    "print(a)  # Se imprime el valor global de 'a'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🚀 Notar:\n",
    "\n",
    "- La variable $a = 4$ dentro de subrutina() no afecta a sub_subrutina(), ya que esta última usa global \"$a$\", accediendo directamente a la variable global.\n",
    "- Si global \"$a$\" no estuviera en sub_subrutina(), se produciría un `UnboundLocalError` al intentar modificar \"$a$\" sin haberla definido en el ámbito local de sub_subrutina()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.  **Evitar el uso de sentencias tipo: `goto`, `break` y `continue` en ciclos de muchas lineas de código**\n",
    "\n",
    "Se debe evitar el uso de comandos que rompan el flujo secuencial de ejecución de un programa. La idea es seguir el principio básico de la [programación estructurada](https://en.wikipedia.org/wiki/Structured_programming). El usar estas sentencias obliga a reflexionar primero sobre qué condición debe cumplirse durante la ejecución del bucle y, a continuación, codificarlo adecuadamente.\n",
    "\n",
    "Si el cuerpo del bucle es extenso y contiene múltiples subbloques anidados, se podría olvidar fácilmente que parte del código no se ejecutará después de la interrupción, lo que podría causar errores difíciles de detectar. Sin embargo, si el ciclo es breve, directo y el propósito de la interrupción es claro, su uso puede ser aceptable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3.  **Usar un único `return` por función y colocarlo en la última linea**\n",
    "\n",
    "Siguiendo los principios de la [programación estructurada](https://en.wikipedia.org/wiki/Structured_programming), una función debe tener un único punto de entrada y un único punto de salida.\n",
    "\n",
    "Por ejemplo, supongamos que tenemos una función que devuelve una longitud en centímetros y necesitamos adaptarla a otro sistema de unidades. La conversión sería tan sencilla como invocar una función `cmANewUnidades(..)` sobre el valor devuelto. Si la función tiene un solo `return`, solo será necesario modificar una línea de código. En cambio, si hay múltiples sentencias return dispersas en el código, cada una deberá ser modificada, lo que aumenta el riesgo de errores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. **Evitar escribir funciones y procedimientos demasiado largos**\n",
    "\n",
    "Para mejorar la legibilidad y comprensión del código, es recomendable que cada procedimiento o función no maneje más de $6$ o $7$ conceptos diferentes a la vez.\n",
    "\n",
    "En general, las funciones demasiado largas suelen contener *bloques de código claramente diferenciados*, los cuales están débilmente acoplados entre sí. Cada uno de estos bloques suele realizar una tarea distinta. Por ejemplo: \n",
    "\n",
    "- Es común que una función primero prepare los datos para realizar un cálculo, luego ejecute una serie de operaciones y, finalmente, muestre los resultados.\n",
    "\n",
    "En estos casos, se recomienda dividir la función en tres subfunciones: \n",
    "- inicializar(..)\n",
    "\n",
    "- calcular(..) \n",
    "- imprimir(..)\n",
    "\n",
    "No importa si, en un principio, la `reutilización` de estas funciones parece poco probable. En general, si se puede elegir entre mantener el código en una sola función o separarlo en subfunciones, la opción recomendada es separarlo, salvo que exista una razón de peso en contra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Método no recomendado (funciona, pero es menos modular)\n",
    "def distancia_entre_AB(coordA, coordB):\n",
    "    # Validación de dimensiones\n",
    "    if len(coordA) != len(coordB):\n",
    "        raise ValueError(\"Los vectores no tienen la misma dimensión\")\n",
    "    \n",
    "    # Cálculo de la distancia euclidiana\n",
    "    distSquared_terms = [(a - b)**2 for a, b in zip(coordA, coordB)]\n",
    "    dist = sum(distSquared_terms)**0.5\n",
    "\n",
    "    return dist\n",
    "\n",
    "# Método recomendado (más modular y reutilizable)\n",
    "def validar_dimensiones(coordA, coordB):\n",
    "    \"\"\"Verifica que ambos vectores tengan la misma dimensión.\"\"\"\n",
    "    if len(coordA) != len(coordB):\n",
    "        raise ValueError(\"Los vectores no tienen la misma dimensión\")\n",
    "\n",
    "def calcular_componentes_cuadradas(coordA, coordB):\n",
    "    \"\"\"Calcula los términos cuadrados de la distancia euclidiana.\"\"\"\n",
    "    return [(a - b)**2 for a, b in zip(coordA, coordB)]\n",
    "\n",
    "def distancia_entre_AB2(coordA, coordB):\n",
    "    \"\"\"Calcula la distancia euclidiana entre dos puntos en cualquier dimensión.\"\"\"\n",
    "    \n",
    "    validar_dimensiones(coordA, coordB)\n",
    "    distSquared_terms = calcular_componentes_cuadradas(coordA, coordB)\n",
    "    \n",
    "    dist = sum(distSquared_terms)**0.5\n",
    "    return dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "coordA, coordB = [0, 0, 2], [0, 0, -2]\n",
    "\n",
    "distancia_entre_AB(coordA, coordB), distancia_entre_AB2(coordA, coordB)\n",
    "\n",
    "# ventajas del v2, que podemos reciclar las funciones y es más facil de modificar y leer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5.  **Evitar el uso de elementos poco comunes de un lenguaje**\n",
    "\n",
    "Muchos lenguajes de programación incluyen elementos específicos que solo son conocidos por aquellos que los dominan a fondo. Sin embargo, un código debe escribirse de manera que pueda ser entendido por el mayor número posible de programadores.\n",
    "\n",
    "Por lo tanto, es recomendable priorizar una escritura clara y sencilla, evitando construcciones demasiado complejas o poco habituales, para facilitar la comprensión y mantenimiento del código."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo\n",
    "\n",
    "# Versión no recomendable\n",
    "def divisionAB(A, B):\n",
    "    \"\"\"Realiza la división A / B, usando una condición implícita para verificar B.\"\"\"\n",
    "    \n",
    "    if B:\n",
    "        return A / B\n",
    "    raise ValueError(\"División por cero no definida\")\n",
    "\n",
    "# En Python y otros lenguajes como C, el 0 se considera Falso y cualquier otro número Verdadero.\n",
    "# Por lo tanto, `if B:` equivale a `if True:` para B ≠ 0 y a `if False:` cuando B = 0.\n",
    "\n",
    "\n",
    "# Recomendación: Explicitar la comparación para mayor claridad.\n",
    "def divisionAB2(A: float, B: float) -> float:\n",
    "    \"\"\"Realiza la división A / B, asegurando que B no sea 0.\"\"\"\n",
    "    \n",
    "    if B != 0:\n",
    "        return A/B\n",
    "    raise ValueError(\"División por cero no definida\")\n",
    "\n",
    "# Notar que se puede hacer más legible adaptandolo para tener el return al final\n",
    "def divisionAB3(A, B):\n",
    "    \"\"\"Realiza la división A / B, asegurando que B no sea 0 y devuelve \n",
    "       el valor en la última línea\"\"\"\n",
    "    \n",
    "    if B!=0:\n",
    "        division = A/B\n",
    "    else:\n",
    "        raise ValueError('División por cero no definida')\n",
    "    \n",
    "    return division\n",
    "\n",
    "# Ejemplo de uso\n",
    "# A, B = 1, 0\n",
    "# divisionAB(A, B)  # Lanza un ValueError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6.  **Comprobar la consistencia semántica de los argumentos de una función**\n",
    "\n",
    "Es una buena práctica verificar los argumentos de entrada de una función antes de proceder con su ejecución. Pueden ocurrir situaciones en las que los argumentos no sean del tipo de dato esperado o no cumplan con las características necesarias para que la función se ejecute correctamente.\n",
    "\n",
    "Dos posibles soluciones son:\n",
    "1.\tComprobar la coherencia de los argumentos antes de ejecutar el cuerpo de la función y lanzar una excepción si los argumentos son inconsistentes.\n",
    "\t\n",
    "2.\tDeclarar precondiciones para la invocación de la función, especificando las expectativas sobre los valores de los argumentos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7.  **Expresar valores literales como constantes**\n",
    "\n",
    "En muchas ocasiones, se requiere utilizar valores literales (por ejemplo, el valor de $\\pi$, el tamaño máximo de un vector, la dimensión de una matriz, etc.). Es recomendable expresar estos valores como constantes, preferentemente en un módulo separado. Esta práctica mejora la adaptabilidad y mantenibilidad de la aplicación, ya que facilita la modificación de los valores en un solo lugar, en lugar de tener que buscar y reemplazar cada instancia en el código"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estilo de codificación y buenas prácticas en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aunque estas normas no son obligatorias, como lo es la propia sintaxis de `Python`, seguir el estilo de codificación [PEP 8](https://legacy.python.org/dev/peps/pep-0008/) facilita la lectura del código y ayuda a identificar posibles errores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.\t**Espaciado o indentación**\n",
    "\n",
    "En Python no es obligatorio un número específico de espacios para la indentación, siempre y cuando la estructura de bloques sea correcta (el intérprete no se preocupa por el número exacto de espacios). Sin embargo, la recomendación es utilizar `cuatro espacios` por nivel de indentación para mejorar la legibilidad del código."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# informal\n",
    "a = 5\n",
    "if a != 5:\n",
    " print('un espacio')  # Este bloque tiene un solo espacio, lo cual puede ser confuso\n",
    "elif a < 5:\n",
    "    print('cuatro espacios')  # Este bloque tiene cuatro espacios\n",
    "else:\n",
    "  print('dos espacios')  # Este bloque tiene dos espacios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# formal\n",
    "a = 5\n",
    "if a != 5:\n",
    "    print('un espacio')  # Ahora todo está correctamente indentado con 4 espacios\n",
    "elif a < 5:\n",
    "    print('cuatro espacios')  # Mantener la indentación coherente\n",
    "else:\n",
    "    print('dos espacios')  # Consistencia en el código"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🚀 Observaciones:\n",
    "\n",
    "1.\t`Indentación consistente`: En el ejemplo formal, se usa $4$ espacios para cada nivel de indentación, que es la convención recomendada en Python según PEP 8.\n",
    "\n",
    "2.\t`Legibilidad`: La indentación coherente ayuda a que el código sea más legible y fácil de mantener.\n",
    "\n",
    "3.\tEvitar `indentación mixta`: Mezclar espacios y tabuladores o usar un número inconsistente de espacios puede hacer que el código sea confuso y propenso a errores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. **Nombres de las variables**:\n",
    "\n",
    "Una variable es un espacio en memoria utilizado para almacenar un objeto. Cada variable debe tener un nombre (apuntador) único, conocido como identificador.\n",
    "\n",
    "Al definir variables, es recomendable (aunque no obligatorio) seguir las siguientes convenciones:\n",
    "\n",
    "- Usar nombres descriptivos y en minúsculas. Esto ayuda a que el propósito de la variable sea claro desde su nombre.\n",
    "\n",
    "- Para nombres compuestos, separar las palabras con guiones bajos (por ejemplo, nombre_completo).\n",
    "- Antes y después del signo $=$, debe haber un espacio en blanco (y solo uno) para mejorar la legibilidad.\n",
    "- Para constantes, utilizar nombres descriptivos y en mayúsculas, separando las palabras por guiones bajos (por ejemplo, PI o TAMANO_MAXIMO)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Incorrectos:\n",
    "MiVariable = 12      # Uso de mayúsculas para nombres de variables (no recomendado)\n",
    "mivariable = 12      # No es claro, ya que no usa un guion bajo para separar palabras\n",
    "mi_variable=12       # Falta espacio alrededor del signo '='\n",
    "mi_variable =12      # Falta espacio después del signo '='\n",
    "mi_constante = 12    # Uso de minúsculas para una constante, debería ser en mayúsculas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correctos:\n",
    "mi_variable = 12     # Uso de minúsculas y guiones bajos para variables\n",
    "MI_CONSTANTE = 12    # Uso de mayúsculas y guiones bajos para constantes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. **Las líneas de código no deben ser muy largas**\n",
    "\n",
    "Es recomendable que las líneas de código no excedan los $72$ caracteres. Si una línea de código es más larga que esto, debe ser partida utilizando una barra invertida `(\\)` para continuar en la siguiente línea."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejemplos:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "vscode": {
     "languageId": "raw"
    }
   },
   "source": [
    "# Línea de código que excede los 72 caracteres y debe ser dividida\n",
    "\n",
    "resultado = una_funcion_que_hace_un_calculo_complejo(parametro1, parametro2, parametro3, parametro4, parametro5)\n",
    "\n",
    "# Se puede dividir con una barra invertida (\\)\n",
    "\n",
    "resultado = una_funcion_que_hace_un_calculo_complejo(parametro1, parametro2, parametro3, \\\n",
    "                                                      parametro4, parametro5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Esta es una frase muy larga, se puede cortar con una \\\n",
    "       y seguir en la línea inferior.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. **Notación de los arreglos**\n",
    "\n",
    "Cuando se usan paréntesis, corchetes o llaves en Python, no se debe dejar espacio inmediatamente dentro de ellos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Incorrecto (no significa q no funciones)\n",
    "\n",
    "`NO`: funcion( num[ 1 ], { pares: 2 } )   # Espacios innecesarios dentro de los corchetes y llaves\n",
    "\n",
    "\n",
    "Correcto\n",
    "\n",
    "`SI`:  funcion(num[1], {pares: 2})   # Sin espacio dentro de los corchetes y llaves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. **Notación de separadores**\n",
    "\n",
    "Cuando se utilizan separadores como coma, punto y coma o punto, siempre debe haber un espacio después del separador, pero nunca antes de él."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Incorrecto (no significa q no funciones)\n",
    "\n",
    "`NO`:  print(x , y) ; x , y = y , x  # Espacios innecesarios antes de la coma y el punto y coma\n",
    "\n",
    "Correcto\n",
    "\n",
    "`SI`:  print(x, y); x, y = y, x  # Espacio después de la coma y el punto y coma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. **Usar funciones predefinidas**\n",
    "\n",
    "Siempre que sea posible, se debe utilizar funciones predefinidas de Python. Estas funciones están optimizadas para ofrecer un rendimiento eficiente y suelen ser más rápidas que las implementaciones personalizadas. Además, el uso de funciones estándar mejora la legibilidad del código, ya que otros programadores están familiarizados con ellas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplos:\n",
    "import time  # Importando módulo time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vía 1 - Tiempo de ejecución: 3.695487976074219e-05 segundos\n",
      "Vía 2 - Tiempo de ejecución: 1.8835067749023438e-05 segundos\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo 1: Sumar elementos de una lista\n",
    "numeros = [1, 2, 3, 4, -9, 8, 7, 5]\n",
    "\n",
    "# Vía 1: Usando un bucle `for`\n",
    "st = time.time()  # Obtener el tiempo de inicio\n",
    "\n",
    "total = 0\n",
    "for i in numeros:\n",
    "    total += i  # añade a total la asignación de i\n",
    "et = time.time()  # Obtener el tiempo de fin\n",
    "\n",
    "elapsed_time = et - st  # Calcular el tiempo de ejecución\n",
    "print('Vía 1 - Tiempo de ejecución:', elapsed_time, 'segundos')\n",
    "\n",
    "# Vía 2: Usando la función predefinida `sum` para sumar los elementos de una lista\n",
    "st = time.time()  # Obtener el tiempo de inicio\n",
    "\n",
    "total = sum(numeros)  # Mejor que implementar un bucle para sumar los elementos\n",
    "et = time.time()  # Obtener el tiempo de fin\n",
    "\n",
    "elapsed_time = et - st  # Calcular el tiempo de ejecución\n",
    "print('Vía 2 - Tiempo de ejecución:', elapsed_time, 'segundos')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lista ordenada: [-0.1, 1, 2, 2, 3, 3.2, 6]\n",
      "Vía 1 - Tiempo de ejecución: 9.918212890625e-05 segundos\n",
      "Lista ordenada: [-0.1, 1, 2, 2, 3, 3.2, 6]\n",
      "Vía 2 - Tiempo de ejecución: 3.0994415283203125e-05 segundos\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo 2: Organizar los numeros de la lista\n",
    "lista = [3, 1, 2, 2, 3.2, -0.1, 6]\n",
    "\n",
    "# Vía 1: Algoritmo Bubble Sort mejorado\n",
    "st = time.time()  # Obtener el tiempo de inicio\n",
    "for i in range(len(lista) - 1):\n",
    "    for j in range(len(lista) - 1 - i):\n",
    "        if lista[j] > lista[j + 1]:  # Intercambio si está desordenado\n",
    "            lista[j], lista[j + 1] = lista[j + 1], lista[j]\n",
    "\n",
    "print(\"Lista ordenada:\", lista)\n",
    "et = time.time()  # Obtener el tiempo de fin\n",
    "elapsed_time = et - st  # Calcular el tiempo de ejecución\n",
    "print('Vía 1 - Tiempo de ejecución:', elapsed_time, 'segundos')\n",
    "\n",
    "\n",
    "# Vía 2: Usar la función predefinida `sorted` para ordenar una lista\n",
    "st = time.time()  # Obtener el tiempo de inicio\n",
    "lista_ordenada = sorted(lista)\n",
    "print(\"Lista ordenada:\", lista_ordenada)\n",
    "et = time.time()  # Obtener el tiempo de fin\n",
    "elapsed_time = et - st  # Calcular el tiempo de ejecución\n",
    "print('Vía 2 - Tiempo de ejecución:', elapsed_time, 'segundos')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vía 1 - Tiempo de ejecución: 4.506111145019531e-05 segundos\n",
      "Vía 2 - Tiempo de ejecución: 3.218650817871094e-05 segundos\n",
      "Vía 3 - Tiempo de ejecución: 3.504753112792969e-05 segundos\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo 3: Seleccionar los números positivos de una lista\n",
    "\n",
    "numeros = [-3, 2, 1, -8, -2, 7]\n",
    "\n",
    "# Vía 1: Usando un bucle `for`\n",
    "st = time.time()  # Obtener el tiempo de inicio\n",
    "\n",
    "positivos = []\n",
    "for i in numeros:\n",
    "    if i > 0:\n",
    "        positivos.append(i)\n",
    "et = time.time()  # Obtener el tiempo de fin\n",
    "\n",
    "elapsed_time = et - st  # Calcular el tiempo de ejecución\n",
    "print('Vía 1 - Tiempo de ejecución:', elapsed_time, 'segundos')\n",
    "\n",
    "# Vía 2: Usando una lista por comprensión (list comprehension)\n",
    "st = time.time()  # Obtener el tiempo de inicio\n",
    "\n",
    "positivos = [i for i in numeros if i > 0]\n",
    "et = time.time()  # Obtener el tiempo de fin\n",
    "\n",
    "elapsed_time = et - st  # Calcular el tiempo de ejecución\n",
    "print('Vía 2 - Tiempo de ejecución:', elapsed_time, 'segundos')\n",
    "\n",
    "\n",
    "# **Vía 3**: Usando `filter()` y `lambda`\n",
    "st = time.time()  # Obtener el tiempo de inicio\n",
    "positivos = list(filter(lambda x: x > 0, numeros))  # Convertir el filtro en lista\n",
    "et = time.time()  # Obtener el tiempo de fin\n",
    "\n",
    "elapsed_time = et - st  # Calcular el tiempo de ejecución\n",
    "print('Vía 3 - Tiempo de ejecución:', elapsed_time, 'segundos')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tiempo de ejecución (Método 1): 3.0994415283203125e-05 seconds\n",
      "Tiempo de ejecución (Método 2): 2.5033950805664062e-05 seconds\n",
      "Tiempo de ejecución (Método 3): 2.7894973754882812e-05 seconds\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo 4: Suma 3 a cada elemento de la lista\n",
    "\n",
    "numeros = [-3, 2, 1, -8, -2, 7, 6, 7, -100]\n",
    "\n",
    "# Método 1: Modificación en el lugar (menos eficiente)\n",
    "st = time.time()\n",
    "for i in range(len(numeros)):  \n",
    "    numeros[i] += 3\n",
    "et = time.time()\n",
    "print('Tiempo de ejecución (Método 1):', et - st, 'seconds')\n",
    "\n",
    "# Método 2: List Comprehension (Rápido y Pythonic)\n",
    "numeros = [-3, 2, 1, -8, -2, 7]\n",
    "st = time.time()\n",
    "numeros = [i + 3 for i in numeros]\n",
    "et = time.time()\n",
    "print('Tiempo de ejecución (Método 2):', et - st, 'seconds')\n",
    "\n",
    "# Método 3: map() con conversión a lista\n",
    "numeros = [-3, 2, 1, -8, -2, 7]\n",
    "st = time.time()\n",
    "numeros = list(map(lambda i: i + 3, numeros))  # Convertir a lista\n",
    "et = time.time()\n",
    "print('Tiempo de ejecución (Método 3):', et - st, 'seconds')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. **Documentación del código** \n",
    "\n",
    "La documentación del código es clave para mejorar la legibilidad y el mantenimiento. Acontinuación veamos algunos puntos clave sobre cómo hacerlo correctamente:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1️⃣ Comentarios en línea\n",
    "\n",
    "- Se recomienda `dos espacios antes del #` si el comentario va en la misma línea del código.\n",
    "\n",
    "- Los comentarios deben ser claros y concisos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10  # Valor inicial de x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2️⃣ Comentarios en bloque\n",
    "\n",
    "- Útiles para explicar partes más largas del código.\n",
    "\n",
    "- Cada línea debe empezar con #."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Este fragmento de código calcula la suma de los elementos\n",
    "# de una lista y devuelve el resultado\n",
    "total = sum([1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3️⃣ Docstrings (\"\"\" \"\"\")\n",
    "\n",
    "Los docstrings son cadenas de documentación que van dentro de `\"\"\" \"\"\"` o `''' '''` y sirven para documentar módulos, clases y funciones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo en una función\n",
    "def suma(a, b):\n",
    "    \"\"\"Devuelve la suma de dos números.\"\"\"\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo en una clase\n",
    "class Persona:\n",
    "    \"\"\"Representa a una persona con nombre y edad.\"\"\"\n",
    "\n",
    "    def __init__(self, nombre, edad):\n",
    "        \"\"\"Inicializa la persona con su nombre y edad.\"\"\"\n",
    "        self.nombre = nombre\n",
    "        self.edad = edad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🔹 Los docstrings son útiles porque se pueden consultar mediante `help()` o `nombre.__doc__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Devuelve la suma de dos números.\n"
     ]
    }
   ],
   "source": [
    "print(suma.__doc__)  # Devuelve: \"Devuelve la suma de dos números.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Persona in module __main__:\n",
      "\n",
      "class Persona(builtins.object)\n",
      " |  Persona(nombre, edad)\n",
      " |  \n",
      " |  Representa a una persona con nombre y edad.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, nombre, edad)\n",
      " |      Inicializa la persona con su nombre y edad.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Persona)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Resumen de buenas prácticas\n",
    "\n",
    "✅ Usa comentarios solo cuando sea necesario (evita explicar lo obvio).\n",
    "\n",
    "✅ Docstrings para clases y funciones.\n",
    "\n",
    "✅ Mantén los comentarios breves y claros.\n",
    "\n",
    "✅ Usa comentarios para explicar el “por qué” más que el “qué”."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola Juan !\n"
     ]
    }
   ],
   "source": [
    "def hola(arg):\n",
    "    \"\"\"El docstring de la función\"\"\"\n",
    "    print(\"Hola\", arg, \"!\")\n",
    "\n",
    "hola(\"Juan\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function hola in module __main__:\n",
      "\n",
      "hola(arg)\n",
      "    El docstring de la función\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(hola)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El docstring de la función\n"
     ]
    }
   ],
   "source": [
    "print(hola.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Por si se lo preguntan:\n",
    "\n",
    "`Pythonic` se refiere a escribir código en Python de una manera que aproveche al máximo las características y convenciones del lenguaje. Es código que es:\n",
    "\n",
    "✅ Claro y legible (sigue PEP 8)\n",
    "\n",
    "✅ Conciso y elegante (evita código innecesariamente largo o complejo)\n",
    "\n",
    "✅ Eficiente y expresivo (usa las herramientas de Python de manera óptima)\n",
    "\n",
    "✅ Idiomatico (aprovecha características propias del lenguaje, como listas por comprensión, zip(), enumerate(), map(), etc.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejemplos:\n",
    "\n",
    "\n",
    "❌ No Pythonic (estilo “Java/C” en Python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "numeros = [1, 2, 3, 4, 5]\n",
    "cuadrados = []\n",
    "for i in range(len(numeros)):  \n",
    "    cuadrados.append(numeros[i]**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notar que:\n",
    "- Usa range(len(numeros)), lo cual no es necesario en Python\n",
    "\n",
    "- Es más largo de lo necesario\n",
    "\n",
    "✅ Pythonic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numeros = [1, 2, 3, 4, 5]\n",
    "cuadrados = [num ** 2 for num in numeros]  # List Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Más corto y legible.\n",
    "\n",
    "- Expresa la intención directamente\n",
    "\n",
    "Otro Ejemplo: Iterar con índice\n",
    "\n",
    "❌ No Pythonic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Índice 0: Ana\n",
      "Índice 1: Juan\n",
      "Índice 2: Pedro\n"
     ]
    }
   ],
   "source": [
    "nombres = [\"Ana\", \"Juan\", \"Pedro\"]\n",
    "for i in range(len(nombres)):\n",
    "    print(f\"Índice {i}: {nombres[i]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El usar `range(len(nombres))` no es necesario.\n",
    "\n",
    "✅ Pythonic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombres = [\"Ana\", \"Juan\", \"Pedro\"]\n",
    "for i, nombre in enumerate(nombres):\n",
    "    print(f\"Índice {i}: {nombre}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usar `enumerate()` es más eficiente y claro.\n",
    "\n",
    "\n",
    "Resumiendo, `Pythonic` significa escribir código que parezca escrito por un programador de Python experimentado, en lugar de alguien que solo traduce código de otro lenguaje. 😃"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}