SI00_Guía_de_estilo_de_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "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-1s/blob/main/SI00_Gu%C3%ADa_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 pasado es un cadáver que debes sepultar*».\n",
        "###[Omar Khayyam](https://en.wikipedia.org/wiki/Omar_Khayyam)\n"
      ],
      "metadata": {
        "id": "vw4vyHJgIWfA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SI00 Guía de estilo de Python\n",
        "\n",
        "Modifique los códigos en las casillas indicadas para que el código funcione de forma correcta y se adapte al PEP8.\n",
        "\n",
        "Recuerde incluir los comentarios en el código y documentar las funciones con docstrings al estilo de Google."
      ],
      "metadata": {
        "id": "dgqyju__IQ2K"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 00\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "4kpeP548VfWv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def contador_palabras(cadena_texto):\n",
        "    contador=0\n",
        "    palabras=cadena_texto.split()\n",
        "    para palabra in palabras:\n",
        "        contador+=1\n",
        "    imprime(\"El número de palabras es:\",contador)\n",
        "\n",
        "cadena_texto=input(\"Ingrese una cadena de texto: \")\n",
        "contador_palabras(cadena_texto)"
      ],
      "metadata": {
        "id": "n2v2uvLkZD0s"
      },
      "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 contador_palabras(cadena_texto):\n",
        "    \"\"\"Contador de palabras\n",
        "\n",
        "    Esta función cuenta palabras en una cadena de texto\n",
        "\n",
        "    Args:\n",
        "        cadena_texto (string): cadena de texto.\n",
        "\n",
        "    Returns:\n",
        "        type: None.\n",
        "\n",
        "    \"\"\"\n",
        "    contador = 0\n",
        "    palabras = cadena_texto.split()\n",
        "    for palabra in palabras:\n",
        "        contador += 1\n",
        "    print(\"El número de palabras es:\", contador)\n",
        "\n",
        "\n",
        "cadena_texto = input(\"Ingrese una cadena de texto: \")\n",
        "contador_palabras(cadena_texto)\n"
      ],
      "metadata": {
        "id": "SMQWLfFhKsaO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f5306e77-9a84-4928-c00b-b7294f30139c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese una cadena de texto: hola\n",
            "El número de palabras es: 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 01\n",
        "\n"
      ],
      "metadata": {
        "id": "AWpJFnkfZE8X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def generar_primos(N):\n",
        "    primos=[2]\n",
        "    para num en rango(3,N+1):\n",
        "        para i en rango(2,num):\n",
        "            si(num%i)==0:\n",
        "                romper\n",
        "        demás:\n",
        "            primos.append(num)\n",
        "    imprime(\"Los primeros\", N, \"números primos son:\")\n",
        "    imprime(primos)\n",
        "\n",
        "N=int(input(\"Ingrese el número de primos a generar: \"))\n",
        "generar_primos(N)"
      ],
      "metadata": {
        "id": "nEHnjFNraLvf"
      },
      "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 generar_primos(N):\n",
        "    \"\"\"Generador de primos\n",
        "\n",
        "    Esta función genera primos hasta un número N\n",
        "\n",
        "    Args:\n",
        "        N (int): Número hasta el que desa generar primos.\n",
        "\n",
        "    Returns:\n",
        "        type: None.\n",
        "\n",
        "    \"\"\"\n",
        "    primos = [2]\n",
        "    for num in range(3, N+1):\n",
        "        for i in range(2, num):\n",
        "            if num % i == 0:\n",
        "                break\n",
        "        else:\n",
        "            primos.append(num)\n",
        "\n",
        "    print(\"Los números primos hasta\", N, \"son:\")\n",
        "    print(primos)\n",
        "\n",
        "\n",
        "N = int(input(\"Ingrese número hasta el cual desea generar primos: \"))\n",
        "generar_primos(N)\n"
      ],
      "metadata": {
        "id": "CN9EHSJKK1Sn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "20e43843-4747-4983-b7fd-d32c84729ba6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese número hasta el cual desea generar primos: 100\n",
            "Los números primos hasta 100 son:\n",
            "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 02"
      ],
      "metadata": {
        "id": "0hEyKcvlaM1p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def calcular_promedio():\n",
        "    entrada=input(\"Ingrese los números separados por comas: \")\n",
        "    números=[int(x) para x en entrada.split(\",\")]\n",
        "    suma=sum(números)\n",
        "    promedio=suma/len(números)\n",
        "    imprime(\"El promedio es: \",promedio)\n",
        "\n",
        "calcular_promedio()"
      ],
      "metadata": {
        "id": "yN0MvrQ4ao7v"
      },
      "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 calcular_promedio():\n",
        "    \"\"\"Calculadora de promedio\n",
        "\n",
        "    Esta función calcula el promedio de numeros separados por coma\n",
        "\n",
        "    Args:\n",
        "        No args\n",
        "\n",
        "    Returns:\n",
        "        type: None.\n",
        "\n",
        "    \"\"\"\n",
        "    entrada = input(\"Ingrese los números separados por comas: \")\n",
        "    numeros = [float(x) for x in entrada.split(\",\")]\n",
        "    suma = sum(numeros)\n",
        "    promedio = suma/len(numeros)\n",
        "    print(\"El promedio es: \", promedio)\n",
        "\n",
        "\n",
        "calcular_promedio()\n",
        "\n"
      ],
      "metadata": {
        "id": "FifgJ7-EK2xH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "99af5697-f177-4c46-f08a-16d8edd34553"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese los números separados por comas: 1.345,5\n",
            "El promedio es:  3.1725\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 03"
      ],
      "metadata": {
        "id": "qj50yF_aP_yM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def convertir_temperatura():\n",
        "    temp=input(\"Ingrese la temperatura (ej. 32C o 90F): \")\n",
        "    escala=temp[-1]\n",
        "    temperatura=int(temp[:-1])\n",
        "    si escala=='C':\n",
        "        resultado=(temperatura*9/5)+32\n",
        "        imprime(\"La temperatura en Fahrenheit es: \", resultado)\n",
        "    demás si escala=='F':\n",
        "        resultado=(temperatura-32)*5/9\n",
        "        imprime(\"La temperatura en Celsius es: \", resultado)\n",
        "    demás:\n",
        "        imprime(\"Por favor, ingrese una temperatura válida.\")\n",
        "\n",
        "convertir_temperatura()"
      ],
      "metadata": {
        "id": "YDbBS606QSxx"
      },
      "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 convertir_temperatura():\n",
        "    \"\"\"Convetidor de temperatura\n",
        "\n",
        "    Esta funcion es capaz de convertir de Farenheit a Celsius y viceversa\n",
        "    Args:\n",
        "        No args\n",
        "\n",
        "    Returns:\n",
        "        type: None\n",
        "\n",
        "    \"\"\"\n",
        "    temp = input(\"Ingrese la temperatura (ej. 32C o 90F): \")\n",
        "    escala = temp[-1]\n",
        "    temperatura = int(temp[:-1])\n",
        "    if escala == 'C':\n",
        "        resultado = (temperatura*9/5)+32\n",
        "        print(\"La temperatura en Fahrenheit es: \", resultado)\n",
        "    elif escala == 'F':\n",
        "        resultado = (temperatura-32)*5/9\n",
        "        print(\"La temperatura en Celsius es: \", resultado)\n",
        "    else:\n",
        "        print(\"Por favor, ingrese una temperatura válida.\")\n",
        "\n",
        "\n",
        "convertir_temperatura()\n",
        "\n"
      ],
      "metadata": {
        "id": "bdS-Re69K4Gr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "96894873-b6c0-4574-82cf-dfb36fd92bb6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese la temperatura (ej. 32C o 90F): 32C\n",
            "La temperatura en Fahrenheit es:  89.6\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 04"
      ],
      "metadata": {
        "id": "4852xGV9QBaQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "def adivina_el_numero():\n",
        "    numero_aleatorio=random.randint(1,100)\n",
        "    adivinado=False\n",
        "    intentos=0\n",
        "    mientras no adivinado:\n",
        "        intento=int(input(\"Adivina el número: \"))\n",
        "        si intento<numero_aleatorio:\n",
        "            imprime(\"El número es más grande.\")\n",
        "        si no, si intento>numero_aleatorio:\n",
        "            imprime(\"El número es más pequeño.\")\n",
        "        demás:\n",
        "            imprime(\"¡Felicidades! Adivinaste el número en\", intentos, \"intentos.\")\n",
        "            adivinado=True\n",
        "        intentos+=1\n",
        "\n",
        "adivina_el_numero()"
      ],
      "metadata": {
        "id": "xNrof7kmQUED"
      },
      "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 random\n",
        "\n",
        "\n",
        "def adivina_el_numero():\n",
        "    \"\"\"Adivina el número.\n",
        "\n",
        "    Esta función permite hacer itnentos por adivinar un número entre 1 y 100.\n",
        "\n",
        "    Args:\n",
        "        No args.\n",
        "\n",
        "    Returns:\n",
        "        type: None\n",
        "\n",
        "    \"\"\"\n",
        "    numero_aleatorio = random.randint(1, 100)\n",
        "    adivinado = False\n",
        "    intentos = 0\n",
        "    while not adivinado:\n",
        "        intento = int(input(\"Adivina el número: \"))\n",
        "        if intento < numero_aleatorio:\n",
        "            print(\"El número es más grande.\")\n",
        "        elif intento > numero_aleatorio:\n",
        "            print(\"El número es más pequeño.\")\n",
        "        else:\n",
        "            print(\"¡Felicidades! Adivinaste en\", intentos, \"intentos.\")\n",
        "            adivinado = True\n",
        "        intentos += 1\n",
        "\n",
        "\n",
        "adivina_el_numero()\n"
      ],
      "metadata": {
        "id": "IUhNlDkgK5l_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5975ecaf-52a3-4465-9bb6-be349054a2da"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Adivina el número: 50\n",
            "El número es más pequeño.\n",
            "Adivina el número: 25\n",
            "El número es más grande.\n",
            "Adivina el número: 40\n",
            "El número es más grande.\n",
            "Adivina el número: 45\n",
            "El número es más pequeño.\n",
            "Adivina el número: 43\n",
            "El número es más pequeño.\n",
            "Adivina el número: 42\n",
            "El número es más pequeño.\n",
            "Adivina el número: 41\n",
            "¡Felicidades! Adivinaste en 6 intentos.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 05"
      ],
      "metadata": {
        "id": "ztj4sS1hQDtc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "import string\n",
        "\n",
        "def generar_contraseña(longitud):\n",
        "    caracteres=string.ascii_letters+string.digits+string.punctuation\n",
        "    contraseña=''.join(random.choice(caracteres) para i en rango(longitud))\n",
        "    imprime(\"La contraseña generada es: \", contraseña)\n",
        "\n",
        "longitud=int(input(\"Ingrese la longitud de la contraseña: \"))\n",
        "generar_contraseña(longitud)"
      ],
      "metadata": {
        "id": "jg0TczRIQVsk"
      },
      "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 random\n",
        "import string\n",
        "\n",
        "\n",
        "def generar_contrasena(longitud):\n",
        "    \"\"\"Generador de contraeñas.\n",
        "\n",
        "    Esta función permite hacer generar contraseñas del largo especificado.\n",
        "\n",
        "    Args:\n",
        "        No args.\n",
        "\n",
        "    Returns:\n",
        "        type: None\n",
        "\n",
        "    \"\"\"\n",
        "    caracteres = string.ascii_letters + string.digits + string.punctuation\n",
        "    contrasena = ''.join(random.choice(caracteres) for i in range(longitud))\n",
        "    print(\"La contraseña generada es: \", contrasena)\n",
        "\n",
        "\n",
        "longitud = int(input(\"Ingrese la longitud de la contraseña: \"))\n",
        "generar_contrasena(longitud)\n",
        "\n"
      ],
      "metadata": {
        "id": "GA_5dcsnK7Hr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "da724345-bc8f-4a5f-e767-4a1c7c30d4cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese la longitud de la contraseña: 100\n",
            "La contraseña generada es:  f*$Bz/yesO_t22jSL{O8A|j~YbpU;{d{Z'DZP-hf#k*Fd+j0D&+(N67Hhn:7vS]C;c6Hg{ZnxM\"l:e.05MM[%A<[m%}iej@q.d~^\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 06"
      ],
      "metadata": {
        "id": "hATd-LMUQGP_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def calcular_interes_compuesto():\n",
        "    principal=float(input(\"Ingrese el monto principal: \"))\n",
        "    tasa=float(input(\"Ingrese la tasa de interés anual (en porcentaje): \"))\n",
        "    años=int(input(\"Ingrese el número de años: \"))\n",
        "    resultado=principal*(1+tasa/100)**años\n",
        "    imprime(\"El valor futuro de la inversión es: \", resultado)\n",
        "\n",
        "calcular_interes_compuesto()"
      ],
      "metadata": {
        "id": "KWFwRqE7QX0H"
      },
      "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 calcular_interes_compuesto():\n",
        "    \"\"\"Calculadora de interés compuesto\n",
        "\n",
        "    Esta función calcula valor de la inversión a un plazo con interés compuesto\n",
        "\n",
        "    Args:\n",
        "        No args.\n",
        "\n",
        "    Returns:\n",
        "        type: None\n",
        "\n",
        "    \"\"\"\n",
        "    principal = float(input(\"Ingrese el monto principal: \"))\n",
        "    tasa = float(input(\"Ingrese la tasa de interés anual (en porcentaje): \"))\n",
        "    anos = int(input(\"Ingrese el número de años: \"))\n",
        "    resultado = principal * (1 + tasa / 100) ** anos\n",
        "    print(\"El valor futuro de la inversión es: \", resultado)\n",
        "\n",
        "\n",
        "calcular_interes_compuesto()\n",
        "\n"
      ],
      "metadata": {
        "id": "2JuhtZdmK8tO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fa9d099d-39be-4e5a-c9b6-3bf6b4ef95d4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese el monto principal: 100\n",
            "Ingrese la tasa de interés anual (en porcentaje): 12\n",
            "Ingrese el número de años: 10\n",
            "El valor futuro de la inversión es:  310.5848208344212\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 07"
      ],
      "metadata": {
        "id": "ZNOMGOKfQHkc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def ordenar_lista():\n",
        "    lista=[int(x) para x en input(\"Ingrese los números separados por comas: \").split(\",\")]\n",
        "    orden=input(\"¿Ordenar en orden ascendente (a) o descendente (d)? \")\n",
        "    si orden=='a':\n",
        "        lista.sort()\n",
        "    demás si orden=='d':\n",
        "        lista.sort(reverse=Verdadero)\n",
        "    imprime(\"La lista ordenada es: \", lista)\n",
        "\n",
        "ordenar_lista()"
      ],
      "metadata": {
        "id": "EFyBSu0OQZ5X"
      },
      "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 ordenar_lista():\n",
        "    \"\"\"Ordenadora de listas\n",
        "\n",
        "    Esta función ordena listas de numeros de forma ascendente o descendente\n",
        "\n",
        "    Args:\n",
        "        No args.\n",
        "\n",
        "    Returns:\n",
        "        type: None\n",
        "\n",
        "    \"\"\"\n",
        "    lista = [int(x) for x in input(\"Ingrese los números separados por comas: \")\n",
        "             .split(\",\")]\n",
        "    orden = input(\"¿Ordenar en orden ascendente (a) o descendente (d)? \")\n",
        "    if orden == 'a':\n",
        "        lista.sort()\n",
        "    elif orden == 'd':\n",
        "        lista.sort(reverse=True)\n",
        "    print(\"La lista ordenada es: \", lista)\n",
        "\n",
        "\n",
        "ordenar_lista()\n",
        "\n"
      ],
      "metadata": {
        "id": "RXmZuoc_K-Uw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ab6ea24f-a44d-4006-eb55-ddd22c186eff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese los números separados por comas: 1,2,3\n",
            "¿Ordenar en orden ascendente (a) o descendente (d)? a\n",
            "La lista ordenada es:  [1, 2, 3]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 08"
      ],
      "metadata": {
        "id": "k1SR_Y-RQJC1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def calcular_imc():\n",
        "    peso=float(input(\"Ingrese su peso en kilogramos: \"))\n",
        "    altura=float(input(\"Ingrese su altura en metros: \"))\n",
        "    imc=peso/(altura**2)\n",
        "    imprime(\"Su IMC es: \", imc)\n",
        "    si imc<18.5:\n",
        "        imprime(\"Usted está bajo peso.\")\n",
        "    demás si 18.5<=imc<25:\n",
        "        imprime(\"Usted tiene un peso normal.\")\n",
        "    demás si 25<=imc<30:\n",
        "        imprime(\"Usted tiene sobrepeso.\")\n",
        "    demás:\n",
        "        imprime(\"Usted tiene obesidad.\")\n",
        "\n",
        "calcular_imc()"
      ],
      "metadata": {
        "id": "1Wky-Hp7Qa1P"
      },
      "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 calcular_imc():\n",
        "    \"\"\"Calculadora de IMC\n",
        "\n",
        "    Esta función le solicita el peso y estatura para calcular su IMC\n",
        "\n",
        "    Args:\n",
        "        No args.\n",
        "\n",
        "    Returns:\n",
        "        type: None\n",
        "\n",
        "    \"\"\"\n",
        "    peso = float(input(\"Ingrese su peso en kilogramos: \"))\n",
        "    altura = float(input(\"Ingrese su altura en metros: \"))\n",
        "    imc = peso / (altura ** 2)\n",
        "    print(\"Su IMC es: \", imc)\n",
        "    if imc < 18.5:\n",
        "        print(\"Usted está bajo peso.\")\n",
        "    elif 18.5 <= imc < 25:\n",
        "        print(\"Usted tiene un peso normal.\")\n",
        "    elif 25 <= imc < 30:\n",
        "        print(\"Usted tiene sobrepeso.\")\n",
        "    else:\n",
        "        print(\"Usted tiene obesidad.\")\n",
        "\n",
        "\n",
        "calcular_imc()\n"
      ],
      "metadata": {
        "id": "-yFIOR5mLAal",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "25c69b77-0868-4289-fe26-d57e3d54062c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese su peso en kilogramos: 95\n",
            "Ingrese su altura en metros: 1.95\n",
            "Su IMC es:  24.983563445101908\n",
            "Usted tiene un peso normal.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 09"
      ],
      "metadata": {
        "id": "VlxrpT47QKdX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def generar_patron(filas):\n",
        "    para i en rango(1,filas+1):\n",
        "        imprime(\"*\"*i)\n",
        "\n",
        "filas=int(input(\"Ingrese el número de filas del patrón: \"))\n",
        "generar_patron(filas)"
      ],
      "metadata": {
        "id": "lwx5c9ecQeTD"
      },
      "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 generar_patron(filas):\n",
        "    \"\"\"Generador de patrones\n",
        "\n",
        "    Esta función genera un patrón cn númro de filas especificadas\n",
        "\n",
        "    Args:\n",
        "        No args.\n",
        "\n",
        "    Returns:\n",
        "        type: None\n",
        "\n",
        "    \"\"\"\n",
        "    for i in range(1, filas+1):\n",
        "        print(\"*\" * i)\n",
        "\n",
        "\n",
        "filas = int(input(\"Ingrese el número de filas del patrón: \"))\n",
        "generar_patron(filas)\n"
      ],
      "metadata": {
        "id": "3tJqbO68LB5C",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d90d7cff-efb8-4fed-cc45-b0c9a1c2fdd8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ingrese el número de filas del patrón: 5\n",
            "*\n",
            "**\n",
            "***\n",
            "****\n",
            "*****\n",
            "\n"
          ]
        }
      ]
    }
  ]
}