Created on Skills Network Labs

PY0101ES-1-1-Types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "    <a href=\"https://cocl.us/PY0101EN_edx_add_top\">\n",
    "         <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/TopAd.png\" width=\"750\" align=\"center\">\n",
    "    </a>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://cognitiveclass.ai/\">\n",
    "    <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/CCLog.png\" width=\"200\" align=\"center\">\n",
    "</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Python - ¡Escribiendo Tu Primer Código en Python!</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p><strong>¡Bienvenido!</strong> Este cuaderno te va a mostrar lo esencial del lenguaje de programación Python. Aunque la información que presentamos aquí es bastante elemental, es una base importante que te ayudará a leer y escribir código Python. Al finalizar este cuaderno habrás aprendido los fundamentos de Python, incluyendo cómo escribir comandos sencillos, comprendiendo algunos tipos básicos y sabiendo cómo realizar operaciones simples sobre ellos.</p> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Índice de Contenidos</h2>\n",
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "    <ul>\n",
    "        <li>\n",
    "            <a href=\"#hello\">Dile \"Hola\" al mundo en Python</a>\n",
    "            <ul>\n",
    "                <li><a href=\"version\">¿Qué versión de Python estamos usando?</a></li>\n",
    "                <li><a href=\"comments\">Escribir comentarios en Python</a></li>\n",
    "                <li><a href=\"errors\">Errores en Python</a></li>\n",
    "                <li><a href=\"python_error\">¿Ve Python tu error antes de ejecutar el código?</a></li>\n",
    "                <li><a href=\"exercise\">Ejercicio: Tu Primer Programa</a></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "        <li>\n",
    "            <a href=\"#types_objects\">Tipos de objetos en Python</a>\n",
    "            <ul>\n",
    "                <li><a href=\"int\">Enteros</a></li>\n",
    "                <li><a href=\"float\">Punto Flotante</a></li>\n",
    "                <li><a href=\"convert\">Convertir de un tipo de objeto a otro tipo de objeto diferente</a></li>\n",
    "                <li><a href=\"bool\">Tipo de dato booleano</a></li>\n",
    "                <li><a href=\"exer_type\">Ejercicio: Tipos</a></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "        <li>\n",
    "            <a href=\"#expressions\">Expresiones y Variables</a>\n",
    "            <ul>\n",
    "                <li><a href=\"exp\">Expresiones</a></li>\n",
    "                <li><a href=\"exer_exp\">Ejercicio: Expresiones</a></li>\n",
    "                <li><a href=\"var\">Variables</a></li>\n",
    "                <li><a href=\"exer_exp_var\">Ejercicio: Expresión y Variables en Python</a></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "    </ul>\n",
    "    <p>\n",
    "        Tiempo estimado requerido: <strong>25 min</strong>\n",
    "    </p>\n",
    "</div>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"hello\">Dile \"Hola\" al mundo en Python</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando se aprende un nuevo lenguaje de programación, se acostumbra a empezar con un ejemplo de \"hola mundo\". A pesar de lo simple que es, esta línea de código asegurará que sepamos cómo escribir una cadena de texto en la salida y cómo ejecutar el código de las celdas de un cuaderno."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr/>\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 20px\">\n",
    "[Idea]: Para ejecutar el código Python de la celda de código de debajo, haz clic en la celda para seleccionarla y pulsa <kbd>Mayúsculas</kbd> + <kbd>Enter</kbd>.\n",
    "</div>\n",
    "<hr/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Intenta tu primer mensaje en Python\n",
    "\n",
    "print('¡Hola Python!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tras ejecutar la celda de arriba, deberías ver que Python imprime <code>¡Hola Python!</code>. ¡Enhorabuena por ejecutar tu primer código en Python!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr/>\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 20px\">\n",
    "    [Idea:] <code>print()</code> es una función. Pasaste la cadena <code>'¡Hola Python!'</code> como argumento para indicar a Python lo que debía imprimir.\n",
    "</div>\n",
    "<hr/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"version\">¿Qué versión de Python estamos utilizando?</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "    Hoy en día existen dos versiones comunes en uso del lenguaje de programación Python: Python 2 y Python 3. La comunidad de Python ha decidido pasar de Python 2 a Python 3, y muchas bibliotecas populares han anunciado que ya no ofrecerán soporte para Python 2.\n",
    "</p>\n",
    "<p>\n",
    "    Como Python 3 es el futuro, en este curso lo vamos a utilizar de forma exclusiva. ¿Cómo sabemos que nuestro cuaderno se ejecuta bajo un tiempo de ejecución (runtime) de Python 3? Podemos mirar en la esquina superior derecha de este cuaderno y ver \"Python 3\".\n",
    "</p>\n",
    "<p>\n",
    "    También podemos preguntar directamente a Python y obtener una respuesta detallada. Intenta ejecutar el siguiente código:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comprobar la Versión de Python\n",
    "\n",
    "import sys\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr/>\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 20px\">\n",
    "    [Idea:] <code>sys</code> es un módulo integrado que contiene muchos parámetros y funciones específicas del sistema, incluyendo la versión de Python en uso. Antes de utilizarlo, debemos importarlo (<code>import</code>) explícitamente.\n",
    "</div>\n",
    "<hr/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"comments\">Escribir comentarios en Python</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "    Además de escribir código, ten en cuenta que siempre es una buena idea incluir comentarios en el. Ayudará a que los demás entiendan lo que intentabas lograr (la razón por la que escribiste un determinado fragmento de código). Esto no sólo sirve para que <strong>otras personas</strong> entiendan tu código, sino que también puede servir de recordatorio <strong>para ti</strong> cuando vuelvas a él semanas o meses después.</p>\n",
    "\n",
    "<p>\n",
    "    Para escribir comentarios en Python, usa el símbolo de almohadilla <code>#</code> antes de escribir el comentario. Cuando ejecutes el código, Python ignorará todo lo que vaya detrás de <code>#</code> en una determinada línea.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Práctica de escritura de comentarios\n",
    "\n",
    "print('¡Hola Python!') # Esta línea imprime una cadena de texto\n",
    "# print('Hola')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "    Tras ejecutar la celda de arriba, deberías observar que <code>Esta línea imprime una cadena de texto</code> no apareció en el resultado, porque era un comentario (y por lo tanto, ignorado por Python).\n",
    "</p>\n",
    "<p>\n",
    "    La segunda línea tampoco se ejecutó porque <code>print('Hola')</code> ¡también estaba precedida por el símbolo de almohadilla (<code>#</code>)! Como esto no es un comentario aclaratorio del programador, sino una línea de código real, podríamos decir que el programador <em>comentó</em> esa segunda línea de código.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"errors\">Errores en Python</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Todo el mundo comete errores. Para muchos tipos de errores, Python te dirá que has cometido una equivocación dándote un mensaje de error. Es importante leer los mensajes de error con cuidado para entender realmente dónde has cometido el error y cómo puedes corregirlo.</p>\n",
    "<p>Por ejemplo, si escribes <code>print</code> como <code>frint</code>, Python mostrará un mensaje de error. Pruébalo:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imprimir cadena como mensaje de error\n",
    "\n",
    "frint(\"¡Hola Python!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>El mensaje de error te dice: \n",
    "<ol>\n",
    "    <li>dónde se produjo el error (más útil en celdas de cuadernos o scripts de gran tamaño), y</li> \n",
    "    <li>qué tipo de error era (NameError)</li> \n",
    "</ol>\n",
    "<p>Aquí, Python intentó ejecutar la función <code>frint</code>, pero no pudo determinar qué es <code>frint</code> ya que no es una función integrada y tampoco la hemos definido previamente nosotros.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "    Observarás que si cometemos un tipo de error diferente, olvidándonos de cerrar la cadena, obtendremos un error diferente (es decir, un <code>SyntaxError</code> (Error de Sintaxis)). Pruébalo aquí debajo:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prueba a ver el mensaje de error\n",
    "\n",
    "print(\"¡Hola Python!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"python_error\">¿Ve Python tu error antes de ejecutar el código?</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python es lo que se llama un <em>lenguaje interpretado</em>. Los lenguajes compilados examinan todo el programa en tiempo de compilación, y son capaces de advertirte sobre todo un conjunto de errores antes de la ejecución. Por contra, Python interpreta el script línea por línea mientras lo ejecuta. Python dejará de ejecutar el programa entero en cuanto encuentre un error (a menos que el error sea esperado y lo gestione el programador, un tema más avanzado que cubriremos más adelante en este curso)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prueba a ejecutar el código de la celda de debajo y mira lo que pasa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Impresión de cadena y error para ver el orden de ejecución\n",
    "\n",
    "print(\"Esto se imprimirá\")\n",
    "frint(\"Esto provocará un error\")\n",
    "print(\"Esto NO se imprimirá\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"exercise\">Ejercicio: Tu Primer Programa</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Generaciones de programadores han comenzado sus carreras en la programación simplemente imprimiendo \"¡Hola mundo!\". Tú también seguirás sus pasos.</p>\n",
    "<p>En la celda de código de debajo, usa la función <code>print()</code> para imprimir la frase: <code>¡Hola mundo!</code></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe tu código a continuación y presiona Mayúsculas+Intro para ejecutar "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Haz doble clic en __aquí__ para ver la solución.\n",
    "\n",
    "<!-- Tu respuesta está a continuación:\n",
    "\n",
    "print(\"¡Hola mundo!\")\n",
    "\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Ahora, vamos a mejorar el código con un comentario. En la celda de código de debajo, imprime la frase: <code>¡Hola mundo!</code> y coméntala con la frase <code>Imprime el tradicional hola mundo</code> todo en una línea de código.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe tu código a continuación y presiona Mayúsculas+Intro para ejecutar "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Haz doble clic en __aquí__ para ver la solución.\n",
    "\n",
    "<!-- Tu respuesta está a continuación:\n",
    "\n",
    "print(\"¡Hola mundo!\") # Imprime el tradicional hola mundo\n",
    "\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"types_objects\" align=\"center\">Tipos de objetos en Python</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Python es un lenguaje orientado a objetos. Hay muchos tipos diferentes de objetos en Python. Comencemos con los tipos de objetos más comunes: <i>cadenas</i>, <i>enteros</i> y <i>punto flotante</i>. Cada vez que escribes palabras (texto) en Python, estás usando <i>cadenas de caracteres</i> (cadenas para abreviar). Los números más comunes, por otra parte, son los <i>enteros</i> (por ejemplo -1, 0, 100) y los de <i>punto flotante</i>, que representan números reales (por ejemplo 3.14, -42.0).</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a align=\"center\">\n",
    "    <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%201/Images/TypesObjects.png\" width=\"600\">\n",
    "</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Las siguientes celdas de código presentan algunos ejemplos.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Entero\n",
    "\n",
    "11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Punto flotante\n",
    "\n",
    "2.14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cadena\n",
    "\n",
    "\"¡Hola, Python 101!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Puedes hacer que Python te diga el tipo de una expresión mediante la función integrada <code>type()</code>. Observarás que Python se refiere a los enteros como <code>int</code>, a los números de punto flotante como <code>float</code>, y a las cadenas de caracteres como <code>str</code>.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tipo de 12\n",
    "\n",
    "type(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tipo de 2.14\n",
    "\n",
    "type(2.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tipo de \"¡Hola, Python 101!\"\n",
    "\n",
    "type(\"¡Hola, Python 101!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>En la celda de código de debajo, utiliza la función <code>type()</code> para comprobar el tipo de objeto de <code>12.0</code>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Introduce el código a continuación. No te olvides de pulsar Mayúsculas+Intro para ejecutar la celda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Haz doble clic en __aquí__ para ver la solución.\n",
    "\n",
    "<!-- Tu respuesta está a continuación:\n",
    "\n",
    "type(12.0)\n",
    "\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"int\">Enteros</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Aquí hay algunos ejemplos de números enteros. Los números enteros pueden ser números negativos o positivos:</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a align=\"center\">\n",
    "    <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%201/Images/TypesInt.png\" width=\"600\">\n",
    "</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Podemos verificar que este es el caso mediante el uso, lo has adivinado, de la función <code>type()</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imprime el tipo de -1\n",
    "\n",
    "type(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imprime el tipo de 4\n",
    "\n",
    "type(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imprime el tipo de 0\n",
    "\n",
    "type(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"float\">Punto Flotante</h3> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Los números de punto flotante representan números reales; son un superconjunto de números enteros pero también incluyen \"números con decimales\". Existen algunas limitaciones cuando se trata de que las máquinas representen números reales, pero los números de punto flotante son una buena representación para la mayoría de los casos. Puedes obtener más información sobre las características específicas de los números de punto flotante en tu entorno de ejecución, comprobando el valor de <code>sys.float_info</code>. Esto también te dirá cuál es el número más grande y más pequeño que se puede representar con ellos.</p>\n",
    "\n",
    "<p>Una vez más, puedes probar algunos ejemplos con la función  <code>type()</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imprime el tipo de 1.0\n",
    "\n",
    "type(1.0) # Observa que 1 es un int, y 1.0 es un float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imprime el tipo de 0.5\n",
    "\n",
    "type(0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imprime el tipo de 0.56\n",
    "\n",
    "type(0.56)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ajustes del sistema para el tipo float\n",
    "\n",
    "sys.float_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"convert\">Convertir de un tipo de objeto a otro tipo de objeto diferente</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Puedes cambiar el tipo del objeto en Python; esto se llama conversión de tipos, o typecasting. Por ejemplo, puedes convertir un <i>entero</i> en un <i>punto flotante</i> (por ejemplo 2 a 2.0).</p>\n",
    "<p>Vamos a probarlo:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Verifica que esto es un entero\n",
    "\n",
    "type(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4>Convertir enteros en punto flotante</h4>\n",
    "<p>Vamos a convertir el entero 2 en punto flotante:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convierte 2 a punto flotante\n",
    "\n",
    "float(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convierte el entero 2 a punto flotante y comprobar su tipo\n",
    "\n",
    "type(float(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Cuando convertimos un entero en un punto flotante, no cambiamos realmente el valor (es decir, el significante) del número. Sin embargo, si convertimos un punto flotante en un entero, potencialmente podríamos perder algo de información. Por ejemplo, si convertimos el punto flotante 1.1 en un entero, obtenemos 1 y perdemos la información decimal (es decir, 0.1):</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convertir 1.1 a entero resultará en una pérdida de información\n",
    "\n",
    "int(1.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4>Convertir cadenas a enteros o punto flotante</h4>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>A veces, podemos tener una cadena que contiene un número dentro de ella. Si este es el caso, podemos convertir esa cadena que representa un número en un número entero mediante <code>int()</code>:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convierte una cadena en un entero\n",
    "\n",
    "int('1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Pero si intentas hacerlo con una cadena que no coincide perfectamente con un número, recibirás un error. Prueba lo siguiente:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convierte una cadena en un entero con error\n",
    "\n",
    "int('1 o 2 personas')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>También puedes convertir cadenas que contienen números de punto flotante en objetos de <i>punto flotante</i>:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convierte la cadena \"1.2\" en un punto flotante\n",
    "\n",
    "float('1.2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr/>\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 20px\">\n",
    "    [Idea:] Observa que las cadenas pueden representarse con comillas simples (<code>'1.2'</code>) o dobles (<code>\"1.2\"</code>), pero no puedes mezclar ambas (por ejemplo, <code>\"1.2'</code>).\n",
    "</div>\n",
    "<hr/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4>Convertir números en cadenas</h4>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Si podemos convertir las cadenas en números, es lógico suponer que podemos convertir los números en cadenas, ¿verdad?  </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convierte un entero en una cadena\n",
    "\n",
    "str(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Y no hay razón por la que no podamos convertir los números de punto flotante también en cadenas:</p> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convierte un punto flotante en una cadena\n",
    "\n",
    "str(1.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"bool\">Tipo de datos booleano</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>El <i>Booleano</i> es otro tipo importante en Python. Un objeto de tipo <i>Booleano</i> puede tener uno de entre dos valores: <code>True</code> (verdadero) o <code>False</code> (falso):</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Valor verdadero\n",
    "\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Observa que el valor <code>True</code> tiene una \"T\" mayúscula. Lo mismo ocurre con <code>False</code> (es decir, debes usar una \"F\" mayúscula).</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Valor falso\n",
    "\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Cuando le pides a Python que muestre el tipo de un objeto booleano, mostrará <code>bool</code> que significa <i>booleano</i>:</p> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tipo de True\n",
    "\n",
    "type(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tipo de False\n",
    "\n",
    "type(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Podemos convertir objetos booleanos en otros tipos de datos. Si convertimos un booleano con un valor de <code>True</code> a un entero o punto flotante obtendremos un uno. Si convertimos un booleano con un valor de <code>False</code> en un entero o en un punto flotante, obtendremos un cero. Del mismo modo, si convertimos un 1 en Booleano, obtendremos <code>True</code>. Y si convertimos un 0 a Booleano, obtendremos <code>False</code>. Vamos a probarlo:</p> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convierte True a int\n",
    "\n",
    "int(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convierte 1 a booleano\n",
    "\n",
    "bool(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convierte 0 a booleano\n",
    "\n",
    "bool(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convierte True a punto flotante\n",
    "\n",
    "float(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"exer_type\">Ejercicio: Tipos</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>¿Cuál es el tipo de dato del resultado de: <code>6 / 2</code>?</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(6/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Haz doble clic en __aquí__ para ver la solución.\n",
    "\n",
    "<!-- Tu respuesta está a continuación:\n",
    "type(6/2) # float\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>¿Cuál es el tipo del resultado de: <code>6 // 2</code>? (Observa la doble barra inclinada <code>//</code>.)</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(6 // 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Haz doble clic en __aquí__ para ver la solución.\n",
    "\n",
    "<!-- Tu respuesta está a continuación:\n",
    "type(6//2) # int, ya que las barras dobles representan la división entera \n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"expressions\">Expresiones y Variables</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"exp\">Expresiones</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Las expresiones en Python pueden incluir operaciones entre tipos compatibles (por ejemplo, números enteros y de punto flotante). Por ejemplo, operaciones aritméticas básicas como sumar varios números:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Expresión de operación de suma\n",
    "\n",
    "43 + 60 + 16 + 41"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Podemos realizar operaciones de resta utilizando el operador menos. En este caso el resultado es un número negativo:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Expresión de operación de resta\n",
    "\n",
    "50 - 60"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Podemos multiplicar utilizando un asterisco:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Expresión de operación de multiplicación\n",
    "\n",
    "5 * 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>También podemos realizar la división con la barra inclinada:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Expresión de operación de división\n",
    "\n",
    "25 / 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Expresión de operación de división\n",
    "\n",
    "25 / 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Como se ve en el cuestionario anterior, podemos usar la doble barra inclinada para la división entera, donde el resultado se redondea al entero más cercano:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Expresión de operación de división entera\n",
    "\n",
    "25 // 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Expresión de operación de división entera\n",
    "\n",
    "25 // 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"exer_exp\">Ejercicio: Expresión</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Escribamos una expresión que calcule cuántas horas hay en 160 minutos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.6666666666666665"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "horas = 160 / 60\n",
    "horas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Haz doble clic en __aquí__ para ver la solución.\n",
    "\n",
    "<!-- Tu respuesta está a continuación:\n",
    "160/60 \n",
    "# O \n",
    "160//60\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Python sigue las convenciones matemáticas ampliamente aceptadas al evaluar las expresiones matemáticas. En el siguiente ejemplo, Python suma 30 al resultado de la multiplicación (es decir, 120)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Expresión matemática\n",
    "\n",
    "30 + 2 * 60"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Y al igual que en las matemáticas, las expresiones entre paréntesis tienen prioridad. Así que lo siguiente multiplica 32 por 60."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Expresión matemática\n",
    "\n",
    "(30 + 2) * 60"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"var\">Variables</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Como con la mayoría de los lenguajes de programación, podemos almacenar valores en <i>variables</i>para poder usarlos más tarde. Por ejemplo:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Almacena el valor en una variable\n",
    "\n",
    "x = 43 + 60 + 16 + 41"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Para ver el valor de <code>x</code> en un Cuaderno, podemos simplemente colocarlo en la última línea de una celda:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imprime el valor de la variable\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>También podemos realizar operaciones sobre <code>x</code> y guardar el resultado en una nueva variable:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utiliza otra variable para almacenar el resultado de la operación entre variable y valor\n",
    "\n",
    "y = x / 60\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Si guardamos un valor en una variable ya existente, el nuevo valor sobrescribirá el valor anterior:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sobrescribe la variable con un nuevo valor\n",
    "\n",
    "x = x / 60\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Es una buena práctica utilizar nombres de variables con significado, para que tanto tú como los demás puedan leer el código y entenderlo más fácilmente:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Da un nombre a las variables que tenga un significado\n",
    "\n",
    "total_min = 43 + 42 + 57 # Duración total de los álbumes en minutos\n",
    "total_min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Da un nombre a las variables que tenga un significado\n",
    "\n",
    "total_horas = total_min / 60 # Duración total de los álbumes en horas \n",
    "total_horas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>En las celdas de arriba hemos sumado la duración de tres álbumes en minutos y lo hemos almacenado en <code>total_min</code>. Luego lo dividimos entre 60 para calcular la duración total <code>total_horas</code> en horas. También puedes hacerlo todo de una vez en una sola expresión, siempre y cuando uses paréntesis para sumar la duración de los álbumes antes de dividir, como se muestra a continuación.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Expresión compleja\n",
    "\n",
    "total_horas = (43 + 42 + 57) / 60  # Total de horas en una sola expresión\n",
    "total_horas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Si prefieres tener el total de horas como un número entero, puedes, por supuesto, reemplazar la división en punto flotante por la división entera (es decir, <code>//</code>).</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"exer_exp_var\">Ejercicio: Expresión y Variables en Python</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>¿Cuál es el valor de <code>x</code>, donde <code>x = 3 + 2 * 2</code>?</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3 + 2 * 2\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Haz doble clic en __aquí__ para ver la solución.\n",
    "\n",
    "<!-- Tu respuesta está a continuación:\n",
    "7\n",
    "-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>¿Cuál es el valor de <code>y</code>, donde <code>y = (3 + 2) * 2</code>?</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = (3 + 2) * 2\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Haz doble clic en __aquí__ para ver la solución.\n",
    "\n",
    "<!-- Tu respuesta está a continuación:\n",
    "10\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>¿Cuál es el valor de <code>z</code>, donde <code>z = x + y</code>?</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = x + y\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Haz doble clic en __aquí__ para ver la solución.\n",
    "\n",
    "<!-- Tu respuesta está a continuación:\n",
    "17\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<h2>¡El último ejercicio!</h2>\n",
    "<p>Enhorabuena, has completado la primera lección y el laboratorio práctico de Python. Sin embargo, hay una cosa más que debes hacer. La comunidad de Ciencias de los Datos anima a compartir los trabajos. La mejor manera de compartir y mostrar tu trabajo es compartirlo en GitHub. Compartiendo tu cuaderno en GitHub no sólo estarás forjando una reputación entre tus colegas que son científicos de datos, sino que también podrás mostrarlo cuando busques empleo. Aunque este haya sido tu primer trabajo, nunca es demasiado pronto para empezar a crear buenos hábitos. Así que, por favor, lee y sigue <a href=\"https://cognitiveclass.ai/blog/data-scientists-stand-out-by-sharing-your-notebooks/\" target=\"_blank\">este artículo</a> para aprender cómo compartir tu trabajo.\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "<h2>¡Consigue IBM Watson Studio gratis!</h2>\n",
    "    <p><a href=\"https://cocl.us/PY0101EN_edx_add_bbottom\"><img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/BottomAd.png\" width=\"750\" align=\"center\"></a></p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Sobre los autores:</h3>  \n",
    "<p><a href=\"https://www.linkedin.com/in/joseph-s-50398b136/\" target=\"_blank\">Joseph Santarcangelo</a> es un Científico de Datos en IBM, y tiene un doctorado en Ingeniería Eléctrica. Su investigación se centró en el uso de Machine Learning, Procesamiento de Señal y Visión Artificial para determinar cómo los videos impactan en la cognición humana. Joseph ha estado trabajando para IBM desde que concluyó su doctorado.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otros colaboradores: <a href=\"www.linkedin.com/in/jiahui-mavis-zhou-a4537814a\">Mavis Zhou</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<p>Copyright &copy; 2018 IBM Developer Skills Network. Este cuaderno y su código fuente se encuentran publicados bajo los términos de la <a href=\"https://cognitiveclass.ai/mit-license/\">Licencia del MIT</a>.</p>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python",
   "language": "python",
   "name": "conda-env-python-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}