Taller_13_guia_de_estilo_de_Python.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/SantiagoMaya10/PPI-MayaRestrepo-2024-2s/blob/main/Taller_13_guia_de_estilo_de_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## «*El código se lee con más frecuencia de la que se escribe*».\n",
        "### [Guido van Rossum](https://es.wikipedia.org/wiki/Guido_van_Rossum)"
      ],
      "metadata": {
        "id": "djdYnssh96Vf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Taller 13 Guía de estilo para escribir código en Python\n",
        "En este taller aprenderá los conceptos **básicos** relativos a la guía de estilo para escribir código en Python [(PEP8)](https://peps.python.org/pep-0008/).\n",
        "\n",
        "La guía de estilo busca mejorar la claridad y la legibilidad del código en Python, pero no afecta su ejecución.\n"
      ],
      "metadata": {
        "id": "m1ragERr9SE3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Referencias\n",
        "\n",
        "Este taller se base en información e ideas recopiladas de las siguientes fuentes:\n",
        "\n",
        "* [Python Style Guide | How to Write Neat and Impressive Python Code](https://www.analyticsvidhya.com/blog/2020/07/python-style-guide/)\n",
        "* [Python PEP 8 tutorial: Get started writing readable code](https://www.educative.io/blog/python-pep8-tutorial)\n",
        "* [Lesson 2. Clean Code Syntax for Python: Introduction to PEP 8 Style Guide](https://www.earthdatascience.org/courses/intro-to-earth-data-science/write-efficient-python-code/intro-to-clean-code/python-pep-8-style-guide/)\n",
        "* [PEP 8 : Coding Style guide in Python](https://www.geeksforgeeks.org/pep-8-coding-style-guide-python/)\n",
        "* [Code Style](https://docs.python-guide.org/writing/style/)\n",
        "* [How to Write Beautiful Python Code With PEP 8](https://realpython.com/python-pep8/)\n",
        "* [5 PEP8 Must-Remember Guidelines](https://towardsdatascience.com/5-pep8-must-remember-guidelines-b8390b9ec03d)\n",
        "* [Chapter 4. Writing Great Code](https://www.oreilly.com/library/view/the-hitchhikers-guide/9781491933213/ch04.html)\n",
        "* [Lesson 1. Introduction to Writing Clean Code and Literate Expressive Programming](https://www.earthdatascience.org/courses/intro-to-earth-data-science/write-efficient-python-code/intro-to-clean-code/)\n",
        "* [Lesson 3. Make Your Code Easier to Read By Using Expressive Variable Names in Python](https://www.earthdatascience.org/courses/intro-to-earth-data-science/write-efficient-python-code/intro-to-clean-code/expressive-variable-names-make-code-easier-to-read/)\n",
        "* [Zen de Python](https://es.wikipedia.org/wiki/Zen_de_Python)\n",
        "* [El Zen de Python Explicado](https://pybaq.co/blog/el-zen-de-python-explicado/)\n",
        "* [PEP 20 – El Zen de Python](https://elpythonista.com/zen-de-python)\n",
        "\n"
      ],
      "metadata": {
        "id": "bSWnQlgNEW--"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# El *Zen de Python*\n",
        "\n",
        "El *Zen de Python* es una recopilación de los principios de *software* utilizados para el diseño de código en Python.\n",
        "\n",
        "Para consultar esos principios basta escribir y ejecutar el siguiente código:\n",
        "\n",
        "**import** this\n"
      ],
      "metadata": {
        "id": "i9MZK6LRl7DZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Código para acceder al Zen de Python\n",
        "import this"
      ],
      "metadata": {
        "id": "KcAsrR7EmAA9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "85b897f0-0ff3-4d7f-e155-996c2afc5f22"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The Zen of Python, by Tim Peters\n",
            "\n",
            "Beautiful is better than ugly.\n",
            "Explicit is better than implicit.\n",
            "Simple is better than complex.\n",
            "Complex is better than complicated.\n",
            "Flat is better than nested.\n",
            "Sparse is better than dense.\n",
            "Readability counts.\n",
            "Special cases aren't special enough to break the rules.\n",
            "Although practicality beats purity.\n",
            "Errors should never pass silently.\n",
            "Unless explicitly silenced.\n",
            "In the face of ambiguity, refuse the temptation to guess.\n",
            "There should be one-- and preferably only one --obvious way to do it.\n",
            "Although that way may not be obvious at first unless you're Dutch.\n",
            "Now is better than never.\n",
            "Although never is often better than *right* now.\n",
            "If the implementation is hard to explain, it's a bad idea.\n",
            "If the implementation is easy to explain, it may be a good idea.\n",
            "Namespaces are one honking great idea -- let's do more of those!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Facilita la lectura de tu código"
      ],
      "metadata": {
        "id": "To50p4zVmfU5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Cómo importar librerías y módulos\n",
        "\n",
        "Escriba en líneas separadas, al inicio del archivo, el código utilizado para importar las librerías requeridas.\n",
        "\n",
        "Se sugiere el siguiente orden:\n",
        "* Importar librerías de la biblioteca estándar.\n",
        "* Importar librerías de terceros.\n",
        "* Importar librerías específicas de bibliotecas y aplicaciones locales.\n"
      ],
      "metadata": {
        "id": "PWTfLtfRJaAe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Uso de la sangría (*indentation*)\n",
        "\n",
        "Python utiliza la sangría como herramienta para identificar los diferentes bloques (*if*, *for*, *while*, *function*, *Class*, etcétera). La falta de consistencia en las sangrías puede generar errores cuando se ejecute el código.\n",
        "\n",
        "La sangría facilita la visualización del código.\n",
        "\n",
        "Se recomienda usar cuatro espacios como sangría para cada nivel de código. Los tabuladores solo se recomiendan para mantener la consistencia de un código que ya los está utilizando.\n",
        "\n",
        "**Importante**: no mezcle espacios y tabuladores (aunque el ojo humano no detecta la diferencia, la máquina sí la detecta y pueden surgir errores al ejecutar el código)."
      ],
      "metadata": {
        "id": "kaNvoJqkE9Ql"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## No exceda la longitud máxima permitida para cada línea\n",
        "\n",
        "Las líneas largas de código son muy difíciles de leer. Escriba líneas de 79 o menos caracteres. En caso de que requiera partir una línea utilice **\\**.\n",
        "\n",
        "Si la línea de código contiene operadores binarios (**+**, **-**,  **/**, **=**,**<=**) divida la línea **antes** del operador binario."
      ],
      "metadata": {
        "id": "LhzELDdRQDqh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Manejo de líneas en blanco\n",
        "\n",
        "Las líneas en blanco permiten identificar con claridad los diferentes bloques que componen un código. Se recomienda utilizar al menos una línea en blanco entre bloques de diferente propósito.\n",
        "\n",
        "**Agregue una línea en blanco antes de una línea, o un bloque, con comentarios; salvo que el comentario sea la primera línea del código."
      ],
      "metadata": {
        "id": "yiqojCqiMMTY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Manejo de los espacios en blanco\n",
        "\n",
        "El exceso y la deficiencia de espacios en blanco afectan la legibilidad del código.\n",
        "\n",
        "Siempre use **un espacio en blanco** en los siguientes casos:\n",
        "\n",
        "* Antes y después de un operador binario (**+**, **-**,  **/**, **+=**, **-=**), de comparaciones (**==**, **<**, **>**, **!=**, **<>**, **<=**, **>=**, **in**, **not in**, **is**, **is not**), y Booleanos (**and**, **or**, **not**).\n",
        "* Después de una coma (**,**) que separa una secuencia de elementos.\n",
        "\n",
        "**No utilice** espacios en blanco en los siguientes casos:\n",
        "* Antes del primer elemento dentro de paréntesis, corchetes o llaves.\n",
        "* Después de una coma «*trasera*» y el paréntesis de cierra.\n",
        "* Antes de una coma (**,**), dos puntos (**:**), o un punto y coma (**;**).\n",
        "* Antes del primer paréntesis cuando se va a invocar una función."
      ],
      "metadata": {
        "id": "mZ9KmyUgaJnJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Describe la lógica de tu código\n",
        "\n",
        "Los códigos se escriben para resolver algún tipo de problema. Cada persona soluciona el problema basada en su lógica particular. Aunque no todos los caminos conduzcan a Roma, sí se puede llegar a Roma por diversos caminos. Python ofrece dos herramientas: comentarios y documentación, que permiten explicar la lógica utilizada para escribir el código.\n",
        "\n",
        "**Comentar es diferente a documentar**.Los comentarios permiten entender el desarrollo del código. La documentación sirve de referencia sobre las operaciones de funciones, clases, librerías.\n",
        "\n",
        "Su *yo del futuro* y los usuarios de su código agradecerán a su *yo del presente* que comente y documente de manera adecuada su código."
      ],
      "metadata": {
        "id": "qL6xIIlYmRj1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Los comentarios\n",
        "\n",
        "Los comentarios explican qué hace el código, para qué o por qué lo hace. Es decir, los comentarios expresan en lenguaje entendible por seres humanos lo que se pretende que haga el código al momento de su ejecución. Los comentarios deben ser frases completas, claras y concisas.\n",
        "\n",
        "Antes de cada comentario escriba el signo numeral y deje un espacio en blanco (# ). También puede escribir comentarios usando (' ' ') antes y después del comentario.\n",
        "\n",
        "La primera palabra de cada comentario inicia con mayúscula.\n",
        "\n",
        "Los comentarios llevan la misma sangría que el bloque al que se refieren.\n",
        "\n",
        "**Actualice los comentarios cada vez que modifique el código**."
      ],
      "metadata": {
        "id": "XgPtxOeYEck1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## La documentación\n",
        "\n",
        "La documentación de funciones, clases y módulos sigue la convención [PEP 257 – Docstring Conventions](https://peps.python.org/pep-0257/).\n",
        "\n",
        "Después de la línea donde se define la función, la clase o módulo se escribe la documentación respectiva. La documentación inicia y termina con tres comillas dobles (\"\"\").\n",
        "\n",
        "Si la documentación ocupa una sola línea, las comillas de apertura y de cierre van en la misma línea; en caso contrario (documentación multilínea) las comillas de cierre van solas en una línea independiente.\n",
        "\n",
        "La primera línea después de la línea de definición debe indicar lo que hace ese elemento. Las líneas posteriores contienen información adicional sobre el elemento."
      ],
      "metadata": {
        "id": "8lLfOOQqEfgt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ejemplo de documentación de una función\n",
        "\n",
        "def calculate_sum(rainfall, time=\"month\"):\n",
        "  \"\"\"Returns a single sum value of all precipitation.\n",
        "\n",
        "  This function takes a pandas dataframe with time series as the index,\n",
        "  and calculates the total sum, aggregated by month.\n",
        "  \"\"\"\n",
        "\n",
        "  # Code here\n",
        "\n",
        "  return the_total_sum"
      ],
      "metadata": {
        "id": "B1mbtgUHSF7j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# ¿Y qué nombre le pondrás?\n",
        "\n",
        "Los nombres utilizados en un código para designar sus elementos (variables, constantes funciones, objetos, clases, etcétera) ayudan a entender la forma en que el código funciona. Las convenciones de escritura facilitan conocer de qué tipo de elemento se trata.\n",
        "\n",
        "Utilice nombres **significativos**, es decir **descriptivos** y mnemotécnicos (que faciliten la asociación mental con su propósito en la resolución del problema)."
      ],
      "metadata": {
        "id": "SNBe2P26mRqx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Nombres peligrosos\n",
        "\n",
        "Se sugiere no utilizar letras aisladas (un solo carácter)  como nombres de elementos en los casos en que pueden ser confundidas con números.\n",
        "\n",
        "Por ejemplo:\n",
        "\n",
        "* **l**: letra minúscula ele\n",
        "* **I**: letra mayúscula i\n",
        "* **O**: letra mayúscula o\n",
        "\n",
        "en algunas fuentes tipográficas no se distinguen de los números 1 (uno) y O (cero).\n"
      ],
      "metadata": {
        "id": "it_jPF1M_JYq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## nombres_de_variables y de funciones\n",
        "\n",
        "Los nombres de las variables y de las funciones deben ser cortos y **significativos**. Se escriben en minúsculas (*lowercase*). Se permite el uso de guiones bajos (*underscores*) para incrementar el significado del elemento.\n",
        "\n",
        "Esta convención también aplica para métodos e instancias."
      ],
      "metadata": {
        "id": "7mwRU_N_D0ff"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## NombresDeClases\n",
        "Los nombres de clases deben ser cortos y **significativos**. Se escriben siguiendo la convención *CamelCase*, también conocida como *CapitalizedWords*, es decur, iniciar con mayúscula cada palabra que compone el nombre y no utilizar guiones bajos (*underscores*)."
      ],
      "metadata": {
        "id": "Key9Wos8Co2C"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## nombres de paquetes y de módulos\n",
        "\n",
        "Los nombres deben ser cortos y **significativos**. Se escriben en minúsculas (*lowercase*). Se permite, **pero no se recomienda**, el uso de guiones bajos(*underscores*)."
      ],
      "metadata": {
        "id": "J1VOVFhfBgSa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## NOMBRES_DE_CONSTANTES\n",
        "\n",
        "Los nombres de constantes deben ser cortos y **significativos**. Se escriben en mayúsculas sostenidas (*UPPERCASE*). En caso de necesidad se permite el uso de guiones bajos (*underscores*).\n",
        "\n",
        "**Las constantes solo se utilizan a nivel de módulo. No cree constantes en programas, funciones o clases**."
      ],
      "metadata": {
        "id": "sDstQqy_FSvo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Herramientas para ajustar el código al estilo PEP8.\n",
        "\n",
        "Las herramientas que ayudan a verificar que el código se ajusta a las normas de estilo se denominan *lintern*.\n",
        "\n",
        "Entre las herramientas más populares se encuentran:\n",
        "* [pycodestyle 2.2.0](https://pypi.org/project/pycodestyle/2.2.0/)\n",
        "* [autopep8](https://github.com/hhatto/autopep8)\n",
        "* [npep8](https://github.com/nbpep8/nbpep8) Diseñada para Google Colab y Kaggle."
      ],
      "metadata": {
        "id": "9T_mN3V_b58F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Código para instalar npep8 en Google Colab.\n",
        "# Es necesario instalar primero pycodestyle.\n",
        "# Instalar las librerías requeridas.\n",
        "!pip install pycodestyle\n",
        "!pip install --index-url https://test.pypi.org/simple/ nbpep8"
      ],
      "metadata": {
        "id": "6px85mGtd9uc",
        "outputId": "99d28de5-7361-4056-a5d5-41914be90991",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting pycodestyle\n",
            "  Downloading pycodestyle-2.11.1-py2.py3-none-any.whl (31 kB)\n",
            "Installing collected packages: pycodestyle\n",
            "Successfully installed pycodestyle-2.11.1\n",
            "Looking in indexes: https://test.pypi.org/simple/\n",
            "Collecting nbpep8\n",
            "  Downloading https://test-files.pythonhosted.org/packages/c1/07/6b91c986efe7c3adac9e2ec061037f0cc4307925819d37277c3802c2d117/nbpep8-0.0.15-py3-none-any.whl (3.2 kB)\n",
            "Installing collected packages: nbpep8\n",
            "Successfully installed nbpep8-0.0.15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar la librería npep8\n",
        "from nbpep8.nbpep8 import pep8"
      ],
      "metadata": {
        "id": "3MVXrXWeesBG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Escriba acá su código\n",
        "print(   \"Hola mundo\"    )\n",
        "\n",
        "# Instrucción para verificar el estilo PEP8.\n",
        "# Requiere instalar e importar, de manera previa, los módulos asociados\n",
        "pep8(_ih)"
      ],
      "metadata": {
        "id": "EFkCXSY3fpaX",
        "outputId": "eecc01b6-68e3-4762-ad3e-f063c8ae3376",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hola mundo\n",
            "cell_content.py:2:7: E201 whitespace after '('\n",
            "cell_content.py:2:25: E202 whitespace before ')'\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Escritura y modificación de código con la ayuda de LLM\n",
        "\n",
        "[Document Your Python Code and Projects With ChatGPT](https://realpython.com/document-python-code-with-chatgpt/)\n",
        "\n",
        "[11 ways you can use ChatGPT to write code](https://typefully.com/svpino/11-ways-you-can-use-chatgpt-to-write-code-YnkOEF4)\n",
        "\n",
        "[ChatGPT as a Python Programming Assistant](https://www.kdnuggets.com/2023/01/chatgpt-python-programming-assistant.html)\n"
      ],
      "metadata": {
        "id": "H6oe1j-av65H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## ChatGPT\n",
        "\n",
        "[Documentación con ChatGPT](https://chat.openai.com/share/2539693e-3ce5-4fd2-9d37-0ef50f4d3ca5)"
      ],
      "metadata": {
        "id": "xePQEJqjxw95"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Gemini\n",
        "\n",
        "[Documentación con Gemini](https://g.co/gemini/share/c4d42b385da1)"
      ],
      "metadata": {
        "id": "b_a4g0WYx02K"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Páginas para ajustar el código al estilo PEP8\n",
        "\n",
        "En los siguientes sitios puede revisar si el código se ajusta al estilo PEP8:\n",
        "\n",
        "*[Python formatter](https://extendsclass.com/python-formatter.html)\n",
        "\n",
        "*[Code Beautify Python formatter](https://codebeautify.org/python-formatter-beautifier)\n",
        "\n",
        "*[ONLINE PYTHON FORMATTER](https://www.tutorialspoint.com/online_python_formatter.htm)"
      ],
      "metadata": {
        "id": "qOMgHzhlDSTb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Ejercicios**.\n"
      ],
      "metadata": {
        "id": "pTHPw9Z8biXx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 00.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "-a8z0qMIoQIM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('one'); print('two')\n",
        "x=2\n",
        "if x == 1: print('one')"
      ],
      "metadata": {
        "id": "_c3OMX8dM3CL",
        "outputId": "36fc2681-3ef0-4e05-c209-31ddc6007f3e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "one\n",
            "two\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "print('one')\n",
        "print('two')\n",
        "\n",
        "numero = 2\n",
        "\n",
        "if numero == 1:\n",
        "  print('one')\n"
      ],
      "metadata": {
        "id": "BE5ya0RhM2re",
        "outputId": "28845c5e-996a-4742-be28-51c22e98a62e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "one\n",
            "two\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 01.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "VmKoBAsFbu-u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def multiplicacion_escalar(escalar,       matriz):\n",
        "    c = []\n",
        "    for i in range(    0, len(matriz)     ):\n",
        "        c.append([])\n",
        "        for j in range(     0, len(matriz[0])):\n",
        "            c[i].append(matriz[i][j] * escalar)\n",
        "    return c\n",
        "\n",
        "\n",
        "B = [     [ 6, 3, 2 ] ,     [ 1, 1, 1] ]\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "print(multiplicacion_escalar(2, B))"
      ],
      "metadata": {
        "id": "25c2_lhvclvY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "def multiplicacion_escalar(escalar, matriz):\n",
        "    c = []\n",
        "    for i in range(0, len(matriz)):\n",
        "        c.append([])\n",
        "        for j in range(0, len(matriz[0])):\n",
        "            c[i].append(matriz[i][j] * escalar)\n",
        "    return c\n",
        "\n",
        "B = [[6, 3, 2], [1, 1, 1]]\n",
        "\n",
        "print(multiplicacion_escalar(2, B))\n"
      ],
      "metadata": {
        "id": "CgltiU1nelCr",
        "outputId": "d9dba710-7898-471f-eebe-7602e69c987a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[12, 6, 4], [2, 2, 2]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 02.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. AAAAAAAAAAAgregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "Arqn5zD3gqti"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "MATRIZ_1 = np.array([    [2,6,2, 5],              [8, 3, 7, 3],            [5, 8, 1, 2]])\n",
        "\n",
        "print (MATRIZ_1)"
      ],
      "metadata": {
        "id": "NXZjE4dggyZW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "MATRIZ_1 = np.array([[2, 6, 2, 5], [8, 3, 7, 3], [5, 8, 1, 2]])\n",
        "\n",
        "print(MATRIZ_1)\n"
      ],
      "metadata": {
        "id": "X9wVvlGRhw6L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 03.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran.\n"
      ],
      "metadata": {
        "id": "lB5c5h2DlBLm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "p=12 #Pa\n",
        "r=997 #kg/m^3\n",
        "v=15 #m/s\n",
        "g=9,8 #m/s^2\n",
        "h=1 #m\n",
        "z=1,12 #m\n",
        "b= ((r*v)+h+(p*v))\n",
        "print (b)"
      ],
      "metadata": {
        "id": "elks-TshlBMM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "# Pa\n",
        "pressure = 12\n",
        "\n",
        "# kg/m^3\n",
        "density = 997\n",
        "\n",
        "# m/s\n",
        "velocity = 15\n",
        "\n",
        "# m/s^2\n",
        "g = 9, 8\n",
        "\n",
        "# m\n",
        "height = 1\n",
        "\n",
        "\n",
        "b = ((density * velocity) + height + (pressure * velocity))\n",
        "\n",
        "print(b)\n",
        "\n",
        "pep8(_ih)\n"
      ],
      "metadata": {
        "id": "wj_zaGrllBMP",
        "outputId": "1363cfbd-d6ea-4089-b6f3-f1a73213cd9c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15136\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 04.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "-SzuAehUsrtm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lista1 = [1, 3, 5]\n",
        "lista2 = [2, 4, 6]\n",
        "lista3 = lista1 + lista2\n",
        "print(lista3)"
      ],
      "metadata": {
        "id": "PXayYrVMs1UD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "lista1 = [1, 3, 5]\n",
        "lista2 = [2, 4, 6]\n",
        "lista3 = lista1 + lista2\n",
        "print(lista3)\n",
        "\n",
        "pep8(_ih)\n"
      ],
      "metadata": {
        "id": "9Ub63ukquc_q",
        "outputId": "92702892-5d22-4e7c-c139-77e086e3b2cf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 3, 5, 2, 4, 6]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 05.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "l6pPhHIOvueL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def area_rectangulo():\n",
        "\n",
        "\n",
        "    x = float(input(\"Ingrese la base del rectángulo: \"))\n",
        "\n",
        "\n",
        "    y= float (input(\"Ingrese la altura del rectángulo: \"))\n",
        "\n",
        "\n",
        "    AREA = x*y\n",
        "\n",
        "    return AREA\n",
        "\n",
        "Area_Rec = area_rectangulo()\n",
        "\n",
        "\n",
        "\n",
        "print(Area_Rec)\n",
        "print(area_rectangulo.__doc__)"
      ],
      "metadata": {
        "id": "tqRl9wypwDNQ",
        "outputId": "6c184c47-eb6c-447d-9d56-37220445079b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese la base del rectángulo: 2\n",
            "Ingrese la altura del rectángulo: 3\n",
            "6.0\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "\n",
        "def area_rectangulo():\n",
        "\n",
        "    \"\"\"\n",
        "    Function to calculate the area of rectangle\n",
        "    with user inputh parameters of height and length\n",
        "    \"\"\"\n",
        "\n",
        "    x = float(input(\"Ingrese la base del rectángulo: \"))\n",
        "    y = float(input(\"Ingrese la altura del rectángulo: \"))\n",
        "\n",
        "    AREA = x*y\n",
        "\n",
        "    return AREA\n",
        "\n",
        "\n",
        "Area_Rec = area_rectangulo()\n",
        "\n",
        "print(Area_Rec)\n",
        "print(area_rectangulo.__doc__)\n",
        "\n",
        "\n",
        "pep8(_ih)\n"
      ],
      "metadata": {
        "id": "do_vEyGxwwWX",
        "outputId": "5130d65b-217e-4fef-fbc5-d0574c5bfe4a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese la base del rectángulo: 3\n",
            "Ingrese la altura del rectángulo: 2\n",
            "6.0\n",
            "\n",
            "    Function to calculate the area of rectangle\n",
            "    with user inputh parameters of height and length\n",
            "    \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 06.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "WxbOkxkPyHOl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def mostrar(  num_rows,      char):\n",
        "\tfor i in range(    num_rows    ):\n",
        "\t\tfor num_cols in range(num_rows-i):\n",
        "\t\t\tprint(char,     end=\"\")\n",
        "\t\tprint()\n",
        "\n",
        "mostrar(7, \"B\")"
      ],
      "metadata": {
        "id": "esiaXoBDyHO8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "def mostrar(num_rows, char):\n",
        "    for i in range(num_rows):\n",
        "        for num_cols in range(num_rows-i):\n",
        "              print(char, end=\"\")\n",
        "              print()\n",
        "\n",
        "\n",
        "mostrar(7, \"B\")\n",
        "\n",
        "pep8(_ih)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "w_NhIqrKyHO9",
        "outputId": "9a5414c0-87c0-4731-b361-a35e37842f67",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "B\n",
            "cell_content.py:6:15: E111 indentation is not a multiple of 4\n",
            "cell_content.py:6:15: E117 over-indented\n",
            "cell_content.py:7:15: E111 indentation is not a multiple of 4\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 07.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "becLbSY7z17G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def PrimerPar(seq):\n",
        "    for elem in seq:\n",
        "        if elem % 2 == 0:\n",
        "            return elem\n",
        "    else:\n",
        "        return None\n",
        "\n",
        "PrimerPar(   [1, 9, 47  , 30]  )"
      ],
      "metadata": {
        "id": "_vlefugoFetG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "def primer_par(seq):\n",
        "    for elem in seq:\n",
        "        if elem % 2 == 0:\n",
        "            return elem\n",
        "    else:\n",
        "        return Non\n",
        "\n",
        "\n",
        "primer_par([1, 9, 47, 30])\n",
        "\n",
        "pep8(_ih)\n"
      ],
      "metadata": {
        "id": "PpP0muOYFd6n",
        "outputId": "eae4b705-3e4c-4dec-b38a-e4fbce748959",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 08\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "0Yebe97Z0vXs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import google.colab.files as fl\n",
        "import numpy as np\n",
        "\n",
        "\n",
        "\n",
        "with open(\"racionales.txt\", \"w\") as numeros:\n",
        "  for i in range (50000):\n",
        "    numeros.write(str(np.random.normal(1000, 500))+\"\\n\")\n",
        "\n",
        "\n",
        "fl.download(\"racionales.txt\")\n"
      ],
      "metadata": {
        "id": "2MiPy6c1z17L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "import google.colab.files as fl\n",
        "import numpy as np\n",
        "\n",
        "\n",
        "with open(\"racionales.txt\", \"w\") as numeros:\n",
        "    for i in range(50000):\n",
        "        numeros.write(str(np.random.normal(1000, 500))+\"\\n\")\n",
        "\n",
        "\n",
        "fl.download(\"racionales.txt\")\n",
        "\n",
        "pep8(_ih)\n",
        "\n"
      ],
      "metadata": {
        "id": "FCCRfXpBz17P",
        "outputId": "8c05e18b-c7c4-40e2-ea6d-fb95476575dc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_b2130446-069d-44d8-82bd-cf94d719dc96\", \"racionales.txt\", 921221)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 09.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "70Y91RxspX8D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def x(l):\n",
        "    size = len(l)\n",
        "\n",
        "\n",
        "    temp = l[0]\n",
        "    l[0] = l[size - 1]\n",
        "    l[size - 1] = temp\n",
        "\n",
        "    return l\n",
        "\n",
        "\n",
        "a = [12, 35, 9, 56, 24]\n",
        "\n",
        "print(x(a))"
      ],
      "metadata": {
        "id": "q_Ui9LHkpbjs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "def reverse_list(list_to_reverse):\n",
        "    size = len(list_to_reverse)\n",
        "\n",
        "    temp = list_to_reverse[0]\n",
        "    list_to_reverse[0] = list_to_reverse[size - 1]\n",
        "    list_to_reverse[size - 1] = temp\n",
        "\n",
        "    return list_to_reverse\n",
        "\n",
        "\n",
        "list_to_reverse = [12, 35, 9, 56, 24]\n",
        "\n",
        "print(reverse_list(list_to_reverse))\n",
        "\n",
        "pep8(_ih)\n",
        "\n"
      ],
      "metadata": {
        "id": "Jr58KMDGoI16",
        "outputId": "7f556aac-9d0c-44b5-cb56-5ce681a263dd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[24, 35, 9, 56, 12]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 10.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "npt9SGPNpdWQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def DuPLiCaDoS(string):\n",
        "\n",
        "    chars = {}\n",
        "\n",
        "\n",
        "    for char in string:\n",
        "\n",
        "        if char not in chars:\n",
        "            chars[char] = 1\n",
        "        else:\n",
        "\n",
        "            chars[char] += 1\n",
        "\n",
        "\n",
        "    d = []\n",
        "\n",
        "\n",
        "    for char, count in chars.items():\n",
        "        if count > 1:\n",
        "            d.append(char)\n",
        "\n",
        "    return d\n",
        "\n",
        "\n",
        "print(DuPLiCaDoS(\"mi mama me mima\"))"
      ],
      "metadata": {
        "id": "4CLR6GxNpf93"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "def duplicados(string):\n",
        "\n",
        "    chars = {}\n",
        "\n",
        "    for char in string:\n",
        "\n",
        "        if char not in chars:\n",
        "            chars[char] = 1\n",
        "        else:\n",
        "            chars[char] += 1\n",
        "\n",
        "    d = []\n",
        "\n",
        "    for char, count in chars.items():\n",
        "        if count > 1:\n",
        "            d.append(char)\n",
        "\n",
        "    return d\n",
        "\n",
        "\n",
        "print(duplicados(\"mi mama me mima\"))\n",
        "\n",
        "pep8(_ih)\n",
        "\n"
      ],
      "metadata": {
        "id": "MGbvLw1qoMfJ",
        "outputId": "34778ec8-75ab-4bac-c7da-07f00aa8b13a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['m', 'i', ' ', 'a']\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 11.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "m_ijhclUphps"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "TestList = [[\"Gfg\", \"good\"], [\"is\", \"for\"], [\"Best\"]]\n",
        "\n",
        "\n",
        "print(\"La lista original es : \" + str(TestList))\n",
        "\n",
        "\n",
        "res = []\n",
        "N = 0\n",
        "while N != len(TestList):\n",
        "    temp = ''\n",
        "    for idx in TestList:\n",
        "\n",
        "\n",
        "        try: temp = temp + idx[N]\n",
        "        except IndexError: pass\n",
        "    res.append(temp)\n",
        "    N = N + 1\n",
        "\n",
        "res = [ele for ele in res if ele]\n",
        "\n",
        "\n",
        "print(\"La nueva lista es : \" + str(res))"
      ],
      "metadata": {
        "id": "To2n_MWXpj0U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "TEST_LIST = [[\"Gfg\", \"good\"], [\"is\", \"for\"], [\"Best\"]]\n",
        "\n",
        "\n",
        "print(\"La lista original es : \" + str(TEST_LIST))\n",
        "\n",
        "\n",
        "res = []\n",
        "N = 0\n",
        "while N != len(TEST_LIST):\n",
        "    temp = ''\n",
        "    for idx in TEST_LIST:\n",
        "        try:\n",
        "            temp = temp + idx[N]\n",
        "        except IndexError:\n",
        "            pass\n",
        "    res.append(temp)\n",
        "    N = N + 1\n",
        "\n",
        "res = [ele for ele in res if ele]\n",
        "\n",
        "\n",
        "print(\"La nueva lista es : \" + str(res))\n",
        "\n",
        "pep8(_ih)\n"
      ],
      "metadata": {
        "id": "VNY2qrtMoL3P",
        "outputId": "e0aca84c-3f06-4c6f-8bca-3529ebdde038",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "La lista original es : [['Gfg', 'good'], ['is', 'for'], ['Best']]\n",
            "La nueva lista es : ['GfgisBest', 'goodfor']\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 12.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "02CUs83DplVE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "def AcUmUlAdO(h):\n",
        "    cu_list = []\n",
        "    length = len(h)\n",
        "    cu_list = [sum(h[0:x:1]) for x in range(0, length+1)]\n",
        "    return cu_list[1:]\n",
        "\n",
        "\n",
        "LiSTA = [10, 20, 30, 40, 50]\n",
        "print (AcUmUlAdO(LiSTA))"
      ],
      "metadata": {
        "id": "FwiwpcpBpnoK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "\n",
        "def acumulado(h):\n",
        "    cu_list = []\n",
        "    length = len(h)\n",
        "    cu_list = [sum(h[0:x:1]) for x in range(0, length+1)]\n",
        "    return cu_list[1:]\n",
        "\n",
        "\n",
        "LISTA = [10, 20, 30, 40, 50]\n",
        "print(acumulado(LISTA))\n",
        "\n",
        "\n",
        "pep8(_ih)\n"
      ],
      "metadata": {
        "id": "s-Fa7IaGoLTI",
        "outputId": "dbb6d035-7b8d-4133-b0cc-144473ae5108",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 30, 60, 100, 150]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 13.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "nhND6WYJppVU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "\n",
        "def squaresum(n) :\n",
        "\n",
        "\n",
        "    sm = 0\n",
        "    for i in    range(1,       n+1) :\n",
        "        sm =     sm + (i * i)\n",
        "\n",
        "    return    sm\n",
        "\n",
        "\n",
        "n = 40\n",
        "print(squaresum(n))\n"
      ],
      "metadata": {
        "id": "U9rz42L-pr6B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "\n",
        "def squaresum(n):\n",
        "    sm = 0\n",
        "    for i in range(1, n+1):\n",
        "        sm = sm + (i * i)\n",
        "\n",
        "    return sm\n",
        "\n",
        "\n",
        "n = 40\n",
        "print(squaresum(n))\n",
        "\n",
        "pep8(_ih)\n",
        "\n"
      ],
      "metadata": {
        "id": "M9o7pEAnoKqn",
        "outputId": "d5901f6e-5dd9-48cb-fff3-ad0834a1d622",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "22140\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 14.\n",
        "Modifique el siguiente código para que se ajuste a las recomendaciones del PEP 8. Asigne nombres significativos a los elementos. Agregue comentarios y documentación en los casos que se requieran."
      ],
      "metadata": {
        "id": "_cen1BtjptHk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def make_complex(*args):\n",
        "    x, y = args\n",
        "    return dict(**locals())\n",
        "\n",
        "print(make_complex(1,2))"
      ],
      "metadata": {
        "id": "XwNWj8_xpw8t"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modifique en esta casilla el código anterior para que se ajuste al PEP8\n",
        "\n",
        "def make_complex(*args):\n",
        "    x, y = args\n",
        "    return dict(**locals())\n",
        "\n",
        "\n",
        "print(make_complex(1, 2))\n",
        "\n",
        "pep8(_ih)\n",
        "\n"
      ],
      "metadata": {
        "id": "lmbfpCv3oKBA",
        "outputId": "3554eae6-19bd-437d-f3b9-9338de34056f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'args': (1, 2), 'x': 1, 'y': 2}\n",
            "\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}