repetitiva_mientras.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# <center>Estructura Repetitiva Mientras (while)</center>"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Al ejecutarse la instrucción mientras (while), se evaluará la expresión condicional suministrada, si su valor es verdadero se realizará el ciclo. La condición se vuelve a evaluar de manera automática y se procede de la misma forma mientras la expresión sea verdadera."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <center>Patrón</center>\n",
        "\n",
        "```\n",
        "while <condición>:\n",
        "    <instrucciones>\n",
        "[else : <instrucciones>]\n",
        "\n",
        "*Reemplazar todo lo encerrado entre < y > omitiendo esos símbolos. La parte else es opcional.\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <center>Características</center>\n",
        "\n",
        "* La condición se evelúa antes del bloque de instrucciones.\n",
        "* Mientras la condición sea verdadera, el bloque de instrucciones se ejecutará indefinidamente a menos que exista por lo menos una instrucción que modifique el valor de un elemento de la condición."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <center>Ejemplos</center>"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Comencemos con un script sencillo que muestre los números del 0 al 13 usando un ciclo mientras."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "script en Python que muestre los números del 0 al 13 usando un ciclo \"mientras\"\n",
        "'''\n",
        "#contador con valor inicial de 0\n",
        "contador = 0\n",
        "\n",
        "while contador < 14:\n",
        "    print(contador)\n",
        "    contador = contador + 1 #instricción que modifica un elemento de la condición."
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2020-10-09T01:52:02.589Z",
          "iopub.execute_input": "2020-10-09T01:52:02.623Z",
          "iopub.status.idle": "2020-10-09T01:52:02.714Z",
          "shell.execute_reply": "2020-10-09T01:52:02.979Z"
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A continuación realizaremos un script en el cual se utilicen acumuladores, uno que acumule valores sumados y otro que acumule valores multiplicados."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "script en Python que sume y acumule los valores pares y multiplique\n",
        "y acumule los valores impares. Deberá haber un acumulador para\n",
        "la suma y otro para la multiplicación y el programa terminará cuando\n",
        "el usuario ingrese un 0. Al final de la ejecución se deberá\n",
        "mostrar el valor de ambos acumuladores.\n",
        "'''\n",
        "\n",
        "#acumulador para sumas suele iniciarse en 0\n",
        "suma = 0\n",
        "#acumulador para multiplicaciones suele iniciarse en 1\n",
        "multiplicacion = 1\n",
        "numero = -1\n",
        "\n",
        "while numero != 0:\n",
        "    numero = int(input('Escribe un número (0 para terminar): '))\n",
        "\n",
        "    if numero % 2 == 0:\n",
        "        suma = suma + numero\n",
        "    else:\n",
        "        multiplicacion = multiplicacion * numero\n",
        "#else que se ejecute cuando termine el ciclo\n",
        "else:\n",
        "    print(f'Suma = {suma}')\n",
        "    print(f'Multiplicación = {multiplicacion}')"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2020-10-09T02:13:58.719Z",
          "iopub.execute_input": "2020-10-09T02:13:58.751Z",
          "iopub.status.idle": "2020-10-09T02:14:18.121Z",
          "shell.execute_reply": "2020-10-09T02:14:18.172Z"
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Como siguiente ejemplo realizaremos la validación de datos de ingreso a una plataforma digital. Dentro del programa existirán constantes para el nombre y contraseña de un usuario y se le solicitarán dichos datos al usuario mientras no los haya escrito de forma correcta."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "script en Python que simule el sistema de validación de datos\n",
        "de una plataforma digital. Se le solicitará al usuario su\n",
        "nombre y contraseña mientras la información proporcionada no\n",
        "coincida con la información previamente registrada.\n",
        "'''\n",
        "#constantes para los datos del usuario\n",
        "USER = 'pepe_nava'\n",
        "PASS = 'v1dr10'\n",
        "#variables para los datos que debe ingresar el usuario\n",
        "user = ''\n",
        "password = ''\n",
        "#mientras el nombre de usuario no sea el registrado o la contraseña sea incorrecta\n",
        "while user != USER or password != PASS:\n",
        "    print('                     insta [°]')\n",
        "    user = input('usuario: ')\n",
        "    password = input('contraseña: ')\n",
        "\n",
        "    if user != USER or password != PASS:\n",
        "        print('Usuario o contraseña incorrectos')\n",
        "else:\n",
        "    print(f'Bienvenidx {user}')"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ahora intentemos algo un poco más divertido, hagamos un script para intentar adivinar un número secreto generado por la computadora. La computadora nos ayudará un poco indicando si el número que proponemos es mayor o menor que le número secreto."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "script en Python que implemente el juego de adivinar un número. El\n",
        "programa deberá generar un número de forma aleatoria y solicitará\n",
        "al usuario que intente adivinarlo. En caso de adivinarlo le mostrará\n",
        "la cantidad de intentos que utilizó y en caso de que falle le\n",
        "volverá a pedir que intente adivinar el número.\n",
        "'''\n",
        "import random\n",
        "\n",
        "secreto = random.randint(1, 100)\n",
        "numero = 0\n",
        "contador_intentos = 0\n",
        "\n",
        "while numero != secreto:\n",
        "    print('Intenta adivinar mi número >:v')\n",
        "    numero = int(input('Número: '))\n",
        "    if numero < secreto:\n",
        "        print('Mi número es mayor >:V')\n",
        "    elif numero > secreto:\n",
        "        print('Mi número es menor >:V')\n",
        "    else:\n",
        "        print('¿Qué comes que adivinas? >:V')\n",
        "    contador_intentos += 1\n",
        "else:\n",
        "    print(f'Adivinaste en {contador_intentos} intentos')"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2020-10-09T02:26:32.904Z",
          "iopub.execute_input": "2020-10-09T02:26:32.933Z",
          "iopub.status.idle": "2020-10-09T02:26:59.786Z",
          "shell.execute_reply": "2020-10-09T02:27:00.067Z"
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Un uso bastante común de la estructura repetitiva mientras es para crear menús repetitivos. La idea es presentarle al usuario el menú de opciones mientras no decida salir de nuestro programa, de esa forma puede utilizar varias opciones de nuestro programa todo en una misma ejecución.\n",
        "\n",
        "En este ejemplo haremos uso de una variable bandera que será la ancargada de controlar si el ciclo se seguirá repitiendo o no."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "script en Python que muestre el menú para las siguientes operaciones\n",
        "aritméticas:\n",
        "\n",
        "1) Suma\n",
        "2) Resta\n",
        "3) Multiplicación\n",
        "4) División\n",
        "5) Salir\n",
        "\n",
        "El programa deberá solicitar dos números y posteriormente mostrar\n",
        "el menú. En caso que el usuario seleccione una opción válida se le\n",
        "mostrará el resultado.\n",
        "'''\n",
        "\n",
        "SUMA = 1\n",
        "RESTA = 2\n",
        "MULTIPLICACION = 3\n",
        "DIVISION = 4\n",
        "SALIR = 0\n",
        "\n",
        "#variable bandera\n",
        "continuar = True\n",
        "\n",
        "#solicitamos los datos con los que trabajará el script\n",
        "n1 = int(input('Ingresa el primer operando: '))\n",
        "n2 = int(input('Ingresa el segundo operando: '))\n",
        "\n",
        "#mientras se decida continuar\n",
        "while continuar == True:\n",
        "    #mostramos el menú utilizando las constantes para las opciones\n",
        "    print(f'''                               Kalkuladora\n",
        "{SUMA}) Suma\n",
        "{RESTA}) Resta\n",
        "{MULTIPLICACION}) Multiplicación\n",
        "{DIVISION}) División\n",
        "{SALIR}) Salir''')\n",
        "    opcion = int(input('Selecciona una opción: '))\n",
        "    #estructura selectiva múltiple para las opciones del menú\n",
        "    if opcion == SUMA:\n",
        "        resultado = n1 + n2\n",
        "        print(f'{n1} + {n2} = {resultado}')\n",
        "    elif opcion == RESTA:\n",
        "        resultado = n1 - n2\n",
        "        print(f'{n1} - {n2} = {resultado}')\n",
        "    elif opcion == MULTIPLICACION:\n",
        "        resultado = n1 * n2\n",
        "        print(f'{n1} * {n2} = {resultado}')\n",
        "    elif opcion == DIVISION:\n",
        "        if n2 == 0:\n",
        "            print('Operación no definida')\n",
        "        else:\n",
        "            resultado = n1 / n2\n",
        "            print(f'{n1} / {n2} = {resultado}')\n",
        "    elif opcion == SALIR:\n",
        "        #Si el usuario decide salir la bandera cambia a falso\n",
        "        continuar = False\n",
        "    else:\n",
        "        print('Opción no válida...')"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2020-10-09T02:46:56.317Z",
          "iopub.execute_input": "2020-10-09T02:46:56.350Z",
          "iopub.status.idle": "2020-10-09T02:47:00.968Z",
          "shell.execute_reply": "2020-10-09T02:47:01.003Z"
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**La estructura repetitiva mientras es de especial utilidad cuando no sabemos cuántas veces sucederá el ciclo**. Generalmente la continuidad del ciclo está determinada por el resultado de alguna de las instrucciones contenidas dentro del mismo."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Aquí tienes el <a href=\"https://drive.google.com/file/d/1l56htFF9_oDz_HVgA7eKSWcResa3xSN7/view?usp=sharing\">enlace </a> con los scripts correspondientes a este cuaderno. Puede abrirlos en tu editor y tratar de correrlos ahí también."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "venv"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.3",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "kernelspec": {
      "argv": [
        "/home/fel/Documents/Profesor/nteract/venv/bin/python",
        "-m",
        "ipykernel_launcher",
        "-f",
        "{connection_file}"
      ],
      "display_name": "venv",
      "language": "python",
      "name": "venv"
    },
    "nteract": {
      "version": "0.25.1"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}