3_Hola_mundo_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "5 Hola mundo.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ApbovDK7W7uv"
      },
      "source": [
        "#Primer código de Python. \n",
        "Llamamos a la función incorporada print() y le pasamos una cadena de caracteres como argumento para que imprima en la pantalla. Se dice que es incorporada ya que es una herramienta que el lenguaje nos pone siempre a disposición en nuestros programas. Existen muchas otras que iremos conociendo más adelante y durante el proyecto de los drones.\n",
        "\n",
        "print('Esto es lo que se muestra')\n",
        "\n",
        "\n",
        "Para ejecutar el código escrito en la celda de código:\n",
        "\n",
        "Ctrl + Intro"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sske9a4aWEUv",
        "outputId": "24de7306-7074-443f-834f-114dcd7b9562"
      },
      "source": [
        "print(\"¡Hola, mundo!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "¡Hola, mundo!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "32KxvANnZtxo"
      },
      "source": [
        "##¡Felicidades! Has ejecutado tu primer código de Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o-nbQkn4XNp_"
      },
      "source": [
        "Para guardar nuestro código:\n",
        "Archivo -> Guardar una copia en Drive o Archivo -> Descargar para guardarlo en nuestro equipo.\n",
        "\n",
        "Se guarda con extensión\n",
        " \n",
        "*.ipynb  \n",
        "(originalmente significaba iPython Notebook (ipynb) de Jupyter Notebook)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2LLp7tsQaJMM"
      },
      "source": [
        "##Help()"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZfJjVU-EY_RJ"
      },
      "source": [
        "help()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L41_jaSAaYbs"
      },
      "source": [
        "#Tipos de datos\n",
        "Todos los lenguajes de programación más o menos convencionales nos permiten almacenar datos en la memoria del sistema, y ello es a través de unas variables en donde guardamos información. Pero una de las diferencias fundamentales entre un lenguaje u otro es el modo en que maneja esas variables. De algunos decimos que son estáticos, por cuanto una variable solamente puede almacenar datos de un tipo en particular; mientras que de otros se dice que son dinámicos, cuando una misma variable puede contener un número al comienzo del programa y luego albergar una cadena de caracteres, por ejemplo.\n",
        "\n",
        "Según esta clasificación, diremos que Python es un lenguaje dinámico. No obstante, la forma en la que entiende las \"variables\" es un tanto diferente respecto de otros lenguajes. En lugar de concebirlas como \"cajas\", las entiende como nombres o referencias. Por ello, en lugar de \"variable\" generalmente se emplea el término objeto.\n",
        "\n",
        "##Tipos básicos de datos\n",
        "Python no distingue la creación de la asignación. Un objeto es creado automáticamente cuando le asignamos un valor. Así, para crear el objeto a con el valor 1 simplemente haremos lo siguiente."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v1dUsBWkay7L"
      },
      "source": [
        "a = 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2gs0ra67aufc"
      },
      "source": [
        "\n",
        "La creación ocurre de forma implícita en la asignación, tampoco es necesario indicar el tipo de dato que contendrá el objeto pues es inferido por Python.\n",
        "\n",
        "Podemos escribir el nombre de un objeto para ver su valor.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-J_JKtdLZ9jy",
        "outputId": "51fa2eda-0e64-4f7d-cc55-d70cf63f3d22"
      },
      "source": [
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c9941nNmbVTP"
      },
      "source": [
        "\n",
        "Para conocer de qué tipo es un objeto, empleamos la función incorporada (recuerda, aquellas que están definidas por Python) type().\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1h-5vxHpbPqy",
        "outputId": "b444fde9-49b2-4641-e314-0a7c6abf446c"
      },
      "source": [
        "type(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gdk9JAJqbfbH"
      },
      "source": [
        "Como vemos, nuestro objeto es del tipo int: esto es, un número entero. Los otros tres tipos de dato básicos son los números de coma flotante (float), los booleanos (bool) y las cadenas de caracteres (str).\n",
        "\n",
        "Los nombres de las variables se escriben en letras minúsculas y, si es nombre compuesto, separadas por guiones bajos (Ej: variable_dependiente)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ryENIE-bbZNZ",
        "outputId": "faf964be-7cd2-46d5-a4a8-cc27b3d6588c"
      },
      "source": [
        "pi = 3.14\n",
        "type(pi)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "51Wlh7Mtbv83",
        "outputId": "7b5acf6e-6152-475d-cd81-e66926acffc8"
      },
      "source": [
        "impar = True\n",
        "type(impar)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "bool"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X6rd04_obq05",
        "outputId": "39621c23-16ab-4e5c-ee45-59d32ec4d516"
      },
      "source": [
        "saludo = \"¡Hola, mundo!\"\n",
        "type(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qLE_hoK-rkxo"
      },
      "source": [
        "##El tipo de dato «None»\n",
        "Python incorpora un quinto tipo de dato que estrictamente hablando se llama NoneType y cuyo único valor posible es None (pronunciado llanamente «nan»)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8CS345zRrxvU"
      },
      "source": [
        "a = None\n",
        "type(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yhOG4a89r02B"
      },
      "source": [
        "A menudo None es utilizado cuando se quiere crear una variable (puesto que Python no distingue la creación de la asignación: crear una variable es simplemente darle un valor) pero aún no se le quiere asignar ningún valor en particular; aunque, en definitiva, como dijimos, None es también un valor. No debe ser interpretado como el valor NULL de lenguajes como C y C++, que solo se aplica a punteros; antes bien, None puede ser asignado a cualquier objeto."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7z2kOYh1r_bc"
      },
      "source": [
        "Dado que se trata de un tipo de dato como cualquier otro, con la peculiaridad de que tiene un único valor posible, podemos realizar las comparaciones habituales."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1B8asV3NsD5f"
      },
      "source": [
        "a = None\n",
        "if a == None:\n",
        "  print(\"a es None.\")\n",
        "else:\n",
        "  print(\"a no es None.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1TFixKzosHxO"
      },
      "source": [
        "Si bien esto es válido, la forma recomendada de hacer comparaciones con este tipo de dato es utilizando la palabra reservada is"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uzDvfG-csKoL"
      },
      "source": [
        "a = None\n",
        "# Método recomendado de comparación.\n",
        "if a is None:\n",
        "  print(\"a es None.\")\n",
        "else:\n",
        "  print(\"a no es None.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IzIntOWZcuVm"
      },
      "source": [
        "##Operaciones aritméticas y de comparación\n",
        "Las operaciones aritméticas son la suma, la resta, la multiplicación y la división. Los operadores utilizados son similares a los de otros lenguajes de programación."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2TOZGnTGc0a4",
        "outputId": "06677241-0e89-4cc0-aa5d-778441472244"
      },
      "source": [
        "a = 5\n",
        "b = 7\n",
        "a + b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8f22NbghdBYn",
        "outputId": "1a84081f-9311-4c63-eac5-b5d9d3290290"
      },
      "source": [
        "a - b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-2"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g3_bRuHgdBQN",
        "outputId": "7c54f6cc-e5b8-47bc-915d-f4c0c63f03fb"
      },
      "source": [
        "a * b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "35"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WB9zC1XtdBF7",
        "outputId": "8df6b0f1-6623-4df8-e148-7a71fd5a78b6"
      },
      "source": [
        "a / b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7142857142857143"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wnx6eh-adUtz"
      },
      "source": [
        "Todas estas operaciones son expresiones, es decir, sentencias de código que devuelven un resultado. \n",
        "\n",
        "Cuando escribimos una expresión en la consola interactiva, lo que resulta de ello es impreso en la pantalla.\n",
        "\n",
        "A estas cuatro podemos añadir la división integral y el resto."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3YwNGPtmdKxi"
      },
      "source": [
        "# División integral: siempre retorna un número entero.\n",
        "10 // 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iGdSFE6hdfhx"
      },
      "source": [
        "# Resto o módulo: retorna el remanente de la división 16 / 5.\n",
        "16 % 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lj4Y_M50dmKl"
      },
      "source": [
        "Ahora bien, en cuanto a comparación de números se refiere, contamos con los operadores > (mayor), >= (mayor o igual), < (menor) y <= (menor o igual). Las operaciones de comparación siempre retornan un booleano."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "95BFCFqPdrf9"
      },
      "source": [
        "10 > 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FZPGnt7gdtpE"
      },
      "source": [
        "6 >= 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J8UqNcXSdtAW"
      },
      "source": [
        "10 < 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j5HChsY0dsz9"
      },
      "source": [
        "4 <= 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X8i9ZFUPd-tf"
      },
      "source": [
        "Para saber si el valor de dos objetos es igual o distinto, empleamos los operadores == y !=."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E9P1OngFd-W0",
        "outputId": "0720a7d9-cb1a-460f-ceab-0cb472fd64d9"
      },
      "source": [
        "5 == 2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OOtwrp8Gdsha",
        "outputId": "78f7d6f2-aae7-4e19-83ea-0e1e4366ce52"
      },
      "source": [
        "55 != 50 "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(True, False)"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Se_JBGCreY3q",
        "outputId": "3fb37789-9d5f-474a-948f-90682e8560b4"
      },
      "source": [
        "\"esto\" != \"esto\""
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G4uD9N4q5XpX"
      },
      "source": [
        "#La función range()\n",
        "La función range() genera una secuencia de números, empezando por 0 por defecto e increntando unidad a unidad por defecto hasta alcanzar el número anterior al final indicado\n",
        "\n",
        "range(start, stop, step)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h_L6toKS6BM6",
        "outputId": "8c3a40c7-13a8-4f01-ffdf-543e9d8617fa"
      },
      "source": [
        "x = range(6)\n",
        "for n in x:\n",
        "  print(n)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YcZvHV9J6PzT",
        "outputId": "b38a1a60-11b4-4e56-cb33-2770489f34c3"
      },
      "source": [
        "x = range(3, 6)\n",
        "for n in x:\n",
        "  print(n)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i3cDpRpt6V9f",
        "outputId": "3eb0bd6b-0926-4cc9-82c6-0df61d090eac"
      },
      "source": [
        "x = range(3, 20, 2)\n",
        "for n in x:\n",
        "  print(n)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "5\n",
            "7\n",
            "9\n",
            "11\n",
            "13\n",
            "15\n",
            "17\n",
            "19\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IXUhAPvZ6X9X",
        "outputId": "4b2532e9-2349-4bfe-efcf-b108d38c309e"
      },
      "source": [
        "x = range(20, 0, -2)\n",
        "for n in x:\n",
        "  print(n)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "20\n",
            "18\n",
            "16\n",
            "14\n",
            "12\n",
            "10\n",
            "8\n",
            "6\n",
            "4\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7e1mBnDqe8Xt"
      },
      "source": [
        "#Control de flujo\n",
        "Un programa o script de Python es un conjunto de instrucciones analizadas y ejecutadas por el intérprete de arriba hacia abajo y de izquierda a derecha. Cuando todas las instrucciones se han ejecutado, el programa termina. No obstante, contamos con herramientas para alterar el flujo natural del programa: hacer que se saltee una porción de código según se cumpla tal o cual condición, repetir un conjunto de instrucciones, etc.\n",
        "\n",
        "##Condicional\n",
        "Una de estas herramientas es el condicional. A partir de la palabra reservada if, le indicamos a Python que queremos ejecutar una porción de código solo si se cumple una determinada condición (es decir, si el resultado es True, como vimos anteriormente). Consideremos el siguiente ejemplo."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qAmqNpfAfFMn",
        "outputId": "a0ca7ecc-dcc4-4ca1-f53e-15913ba055dc"
      },
      "source": [
        "edad = 30\n",
        "\n",
        "if edad >= 18:\n",
        "    print(\"Eres un adulto.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Eres un adulto.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "74KMIWAvfKYP"
      },
      "source": [
        "Primero definimos una variable edad, cuyo valor es un entero, 18. Luego, a través el condicional, indicamos que queremos imprimir \"Eres un adulto.\" en pantalla si se cumple la condición de que el valor de edad sea mayor o igual a 18.\n",
        "\n",
        "En Python se emplea indentación en blanco para delimitar los bloques de código."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a0pRH9ySfJy3"
      },
      "source": [
        "if edad >= 18:\n",
        "    print(\"Eres un adulto.\")\n",
        "print(\"¡Hola, mundo!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o9gvcmo6fd3s"
      },
      "source": [
        "En este código, solamente la segunda línea está dentro del condicional, por cuanto está \"indentada\" con cuatro espacios. Por el contrario, la tercera línea se ejecuta siempre, independientemente del resultado de la comparación.\n",
        "\n",
        "Ahora bien, para ejecutar un bloque de código en caso que no se cumpla la condición, empleamos la palabra reservada else."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RCZAlJsAfhGA"
      },
      "source": [
        "if edad >= 18:\n",
        "    print(\"Eres un adulto.\")\n",
        "else:\n",
        "    print(\"Aún no eres un adulto.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qzemfgrqfnlW"
      },
      "source": [
        "Por último, podemos especificar otras condiciones en caso que la primera no se cumpla vía elif."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3w0IGNSkfnVM"
      },
      "source": [
        "if edad >= 18 and edad < 65:\n",
        "    print(\"Eres un adulto.\")\n",
        "elif edad >= 65:\n",
        "    print(\"Eres un adulto mayor.\")\n",
        "else:\n",
        "    print(\"Aún no eres un adulto.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Z7hQO9Qftn4"
      },
      "source": [
        "Aquí, además, hemos incluido una conjunción vía la palabra reservada and para indicar que, en el primer caso, para que se cumpla la condición, tanto edad >= 18 como edad < 65 deben ser verdaderos. Lo contrario de la conjunción es la disyunción, representada por la palabra reservada or."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "798N054pf01q"
      },
      "source": [
        "#Interacción con el usuario\n",
        "Python incluye una función llamada input(), similar a print(), pero que exhorta al usuario a escribir algo en la consola, que luego es retornado como una cadena."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6AHnZ7u3fs59",
        "outputId": "93923e7a-0711-4c66-fe63-c2fff99a573d"
      },
      "source": [
        "nombre = input(\"Escribe tu nombre: \")\n",
        "print(\"Hola\", nombre)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Escribe tu nombre: Alberto\n",
            "Hola Alberto\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R1vJGJGefsvI"
      },
      "source": [
        "(La función print() nos permite imprimir múltiples objetos en una misma línea separándolos por comas, que luego se traducen en la pantalla como espacios).\n",
        "\n",
        "Así, este código solicita al usuario que escriba su nombre y, una vez obtenido, imprime un saludo personalizado en la pantalla. Sabido esto, podemos adaptar nuestro código anterior para solicitar la edad del usuario y en consecuencia mostrar el mensaje correspondiente."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Da4p5xW4gKY4"
      },
      "source": [
        "edad = int(input(\"Escribe tu edad: \"))\n",
        "\n",
        "if edad >= 18 and edad < 65:\n",
        "    print(\"Eres un adulto.\")\n",
        "elif edad >= 65:\n",
        "    print(\"Eres un adulto mayor.\")\n",
        "else:\n",
        "    print(\"Aún no eres un adulto.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QL65mr_YgMq-"
      },
      "source": [
        "IMPORTANTE Dado que input() siempre retorna una cadena de caracteres, debemos primero convertirla a un entero vía la función incorporada int() para poder efectuar las comparaciones pertinentes."
      ]
    }
  ]
}