JN01_VariablesExpresiones.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducción a Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Valores y Tipos de datos\n",
    "\n",
    "Los valores o literales son los elementos más simple con los que trabajan los programas. Un valor puede ser un número, como 2, 42.5, una palabra como \"hola\" o un valor de verdad como Falso o Verdadero. \n",
    "\n",
    "Decimos que estos valores son de diferentes tipos de datos. Los tipos de datos le indican al intérprete de Python cómo debe almacenar los valores y qué tipos de operaciones puede aplicarle a los mismos.\n",
    "\n",
    "Por ejemplo no podemos sumar una palabra con un número entero. No tiene sentido.\n",
    "\n",
    "Los tipos de datos principales son: \n",
    "- int para los números enteros\n",
    "- float para los números decimales\n",
    "- str (o string) para las cadenas de caracteres (palabras o frases)\n",
    "- bool (o booleano) para los valores como Verdadero y Falso\n",
    "\n",
    "Python tiene una función, llamada type() que nos puede indicar el tipo de dato de un valor o variable\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Por ejemplo, para saber el tipo de dato del número 52\n",
    "type(52)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Para saber el tipo de datos del número 52.25 colocamos\n",
    "type(52.25)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Los valores True (verdadero) y False (falso) tienen el tipo de dato bool\n",
    "type(True)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Para saber el tipo de dato de la palabra \"hola\"\n",
    "type(\"hola\")\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Las comillas indican que se trata de un tipo de dato string, o cadena de caracteres\n",
    "# Mira lo que pasa si pedimos el tipo de datos de \"52\"\n",
    "type(\"52\")\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todo lo que esté dentro de dos comillas es tomado como string por el intérprete de Python, incluso si nosotros sabemos que se trata de un número entero. Hay que tener cuidado con esto al realizar nuestras operaciones en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluación de operadores aritméticos\n",
    "\n",
    "El intérprete de Python es capaz de evaluar expresiones aritméticas. Igual que este notebook. \n",
    "Para comprobarlo selecciona la siguiente casilla gris y presione las teclas Ctrl + Enter\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5+2\n",
    "\n",
    "#Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#El operador + se utiliza para hacer sumas\n",
    "3+4\n",
    "\n",
    "#Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#El operador - se utiliza para hacer restas\n",
    "50 - 23\n",
    "\n",
    "#Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#El operador * se utiliza para multiplicar\n",
    "3*24\n",
    "\n",
    "#Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#El operador / se utiliza para dividir\n",
    "29/3\n",
    "\n",
    "#Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#El operador // se utiliza para obtener la división entera\n",
    "29//3\n",
    "\n",
    "#Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Si queremos obtener el residuo de una división utilizamos el operador módulo %\n",
    "29%3\n",
    "\n",
    "#Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#El operador ** se utiliza para elevar a una potencia\n",
    "2**5\n",
    "\n",
    "#Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora intenta realizar estas mismas operaciones en la consola de tu intérprete de Python. Si utilizas Thonny, será en la ventana etiquetada como \"Shell\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operadores aritméticos y tipos de dato string\n",
    "\n",
    "¿Qué pasa si tratamos de sumar una palabra y un número?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Esto pasa al tratar de sumar una palabra y un número\n",
    "\"hola\"+3\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla\n",
    "# No te asustes si el programa muestra un error. Esto es lo que queremos que pase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que viste anteriormente es un error de semántica, específicamente un error de tipo de datos. No podemos sumar una palabra con un número, pero ¿podemos sumar dos palabras?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Esto pasa al tratar de sumar dos palabras\n",
    "\"hola \"+\"mundo\"\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aplicar el operador de suma a dos palabras, en Python, significa juntarlas o lo que se llama concatenarlas. Mira lo que pasa al multiplicar una palabra por un número"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Esto pasa al multiplicar una palabra por un número entero\n",
    "\"hola \" * 3\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si sumar significa juntar o concatenar, tiene sentido que multiplicar signifique hacer varias sumas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Esto pasa al multiplicar una palabra por un número decimal\n",
    "\n",
    "\"hola \" * 3.14\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vemos entonces que solo se puede multiplicar un string (palabra) por un número entero. ¿Qué pasa si multiplicamos dos palabras?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Esto pasa al multiplicar dos palabras\n",
    "\n",
    "\"hola \" * \"mundo\"\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El mismo tipo de error. Si te fijas la flecha indica la línea de código donde el error se produjo y al final del error se muestra la causa que lo provocó. Trata de entender esta explicación y compararla con el error anterior, provocado por tratar de multiplicar por un número decimal.\n",
    "\n",
    "Si tienes curiosidad de ver qué otras cosas se pueden hacer con los strings o aplicando diferentes tipos de operadores puedes realizar más pruebas en tu consola de Python. Si utilizas Thonny será la ventana etiquetada como \"Shell\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "Las variables son segmentos de la memoria de nuestra computadora a los que les asignamos un nombre y un valor. Funcionan como cajas donde podemos guardar datos. Lo interesante es que luego podemos referirnos a esos datos utilizando el nombre de la caja o variable.\n",
    "\n",
    "Al igual que en álgebra, podemos utilizar las variables como símbolos para datos que pueden ser reemplazados en el futuro. Los datos de las variables pueden ser calculados por nuestro programa o ingresados por el usuario.\n",
    "\n",
    "El operador = es el operador de asignación. Crea una variable y le asigna un valor.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Por ejemplo, podemos definir la variable masa = 18\n",
    "masa = 18\n",
    "\n",
    "# Después podemos utlilzar la expresión \n",
    "\n",
    "masa / 2\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como pudimos ver en el ejemplo anterior, podemos utilizar los operadores aritméticos combinando variables y literales "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Las variables tienen el tipo de dato del elemento que contienen\n",
    "type(masa)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si has programado antes, habrás notado que en Python no es necesario declarar el tipo de dato de la variable, sino el tipo se toma del valor literal que se le asigna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# El orden de los operandos en una asignación debe ser variable = valor\n",
    "# Si intentamos hacerlo de la forma valor = variable obtendremos un error \n",
    "\n",
    "18 = masa\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las variables pueden tener **casi** cualquier nombre, pero se aconseja que sean nombres significativos y relacionados al dato que almacenarán. Los nombres de las variables no pueden tener espacios enmedio. Si se necesita usar dos palabras se recomienda el uso de el guión bajo como separador entre palabras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo \n",
    "masa_objeto1 = 18"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los nombres de las variables no pueden empezar con un número. Existen algunas palabras llamadas **palabras reservadas** que no pueden utilizarse como nombres de variables. Esto es porque son palabras que el lenguaje de programación tiene ya predeterminadas para otros usos. Algunos ejemplos de estas palabras son: class, if, else, while, for, except, finally, global, import, not, return try, yield."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Podemos crear variables con los diferentes tipos de datos que conocemos\n",
    "nombre = \"Javier\"\n",
    "edad = 18\n",
    "promedio = 90.75\n",
    "aprobado = True\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como pudiste notar al ejecutar la casilla anterior no se desplegó ningún resultado. Esto es porque las asignaciones a diferencia de las operaciones matemáticas no producen ningún valor. Solamente guardan el valor en la casilla o caja indicada."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos realizar operaciones con variables, siempre y cuando sean del mismo tipo o de tipos compatibles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de operaciones con variables\n",
    "tiempo = 2.5\n",
    "velocidad = 12\n",
    "\n",
    "distancia = velocidad * tiempo\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imprimiendo a pantalla\n",
    "\n",
    "Podemos desplegar en pantalla el contenido de una variable utilizando la instrucción print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de instrucción print\n",
    "print(distancia)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si necesitamos imprimir en pantalla varios mensajes, o valores a la vez, podemos colocarlos dentro de los paréntesis de la instrucción print, separados por comas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de instrucción print para imprimir varios valores a la vez\n",
    "print(\"La distancia es: \", distancia)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pidiendo datos al usuario\n",
    "Podemos crear variables con datos ingresados por el usuario. Para hacer esto utilizamos la función input() de Python. La función input devuelve el dato ingresado por el usuario y pide el mensaje que se le mostrará en pantalla.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo función input\n",
    "nombre = input(\"Ingrese su nombre\")\n",
    "print(\"Hola \", nombre)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De esta manera creamos una variable llamada nombre, a la que se le asigna el dato proveído por el usuario. Debemos tener cuidado ya que los datos retornados por la función input son de tipo string. Si necesitamos realizar cálculos con ellos debemos primero cambiarles el tipo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de cálculos con input\n",
    "nacimiento = input(\"Ingrese el año en que nació: \")\n",
    "edad = 2019 - nacimiento\n",
    "print(\"Usted cumplirá \", edad, \"años en 2019\")\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al intentar ejecutar el código anterior nos dará un error. Esto es porque el tipo de dato de la variable **nacimiento** es string y no podemos restarle un string a un número entero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comprobación de que la variable nacimiento es de tipo string\n",
    "type(nacimiento)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para arreglar nuestro código podemos transformar el tipo de dato de nacimiento de string a int, o crear una nueva variable en donde almacenemos el valor entero correspondiente al dato ingresado por el usuario. Para esto utilizamos la función int()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de conversión de tipos de dato\n",
    "nacimiento = input(\"Ingrese el año en que nació: \")\n",
    "nacimiento_int = int(nacimiento)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Al verificar el tipo de dato de la nueva variable podemos comprobar que ahora es entero\n",
    "type(nacimiento_int)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora si ya podremos ejecutar nuestro código anterior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de cálculos con input y conversión de tipo\n",
    "nacimiento = input(\"Ingrese el año en que nació: \")\n",
    "nacimiento_int = int(nacimiento)\n",
    "edad = 2019 - nacimiento_int\n",
    "print(\"Usted cumplirá \", edad, \"años en 2019\")\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De la misma manera podemos convertir entre varios tipos de datos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de conversión de tipos de datos\n",
    "edad = 18\n",
    "edad_string = str(edad)\n",
    "edad_float = float(edad)\n",
    "\n",
    "print(\"El tipo de dato de edad es \", type(edad))\n",
    "print(\"El tipo de dato de edad_string es \", type(edad_string))\n",
    "print(\"El tipo de dato de edad_float es \", type(edad_float))\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Expresiones\n",
    "\n",
    "Una expresión es una combinación de valores, variables y operadores que puede ser evaluada y reducida a un solo valor.\n",
    "\n",
    "Ejemplos de expresiones son:\n",
    "- Un valor como **42**\n",
    "- Una variable como **edad**\n",
    "- Una combinación de operador y valores o variables como **edad + 42**\n",
    "- Una combinación de más de dos operadores y valores o variables como **edad*2+4**\n",
    "\n",
    "Lo importante de las expresiones es que pueden evaluarse y convertirse en un solo valor. Lo que hace posible que se puedan reemplazar expresiones por otras expresiones en cualquier lugar donde se espere un valor (número, string o booleano)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de expresiones\n",
    "# La función print recibe un valor o una serie de valores a imprimir, por ejemplo\n",
    "print(25)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Este valor que esta función espera puede ser reemplazado por cualquier expresión como\n",
    "edad = 25\n",
    "print(edad)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# O como\n",
    "print(5*5)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Incluso\n",
    "print(2**4+3*3)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No todas las instrucciones son expresiones. Solamente las que pueden reemplazarse o reducirse a un valor. Por ejemplo la instrucción *print(x)* no es una expresión. Las instrucciones de asignación como *x=5* tampoco son expresiones\n",
    "\n",
    "El conocimiento de instrucciones y expresiones te ayudará mucho más adelante en el curso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modificando variables\n",
    "\n",
    "Si hemos definido una variable, podemos modificar su valor en código. La variable tendrá el último valor que le fue asignado\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de modificación de variables\n",
    "\n",
    "precio = 24.50\n",
    "precio = 26.75\n",
    "\n",
    "print(precio)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos también modificar una variable con base en su valor actual, por ejemplo si queremos incrementar una variable, utilizamos el código siguiente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de modificación de variables con base en su valor actual\n",
    "\n",
    "precio = 24.50\n",
    "precio = precio + 3.25\n",
    "\n",
    "print(precio)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El ejemplo anterior puede ser un poco confuso. Para entenderlo debemos saber que en el caso de que una asignación a una variable contenga una expresión, como **precio + 3.25**. La evaluación de la expresión, es decir el cálculo, o reducción a un número, se hará antes de realizar la asignación. Entonces en este caso, se calcula **precio + 3.25**, lo que da como resultado **27.75**, que es lo que se le asigna a la variable precio. Al imprimir la variable precio mostrará el valor actualizado.\n",
    "\n",
    "Podemos hacer lo mismo decrementando la variable, o reemplazando el lado derecho de la asignación por cualquier expresión."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de modificación de variable en base a su valor actual\n",
    "\n",
    "precio = 24.50\n",
    "precio = precio * 0.75\n",
    "\n",
    "print(precio)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora probemos algo interesante como lo siguiente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "longitud_a = 2\n",
    "longitud_b = 3\n",
    "\n",
    "longitud_a = longitud_a + longitud_b\n",
    "longitud_b = longitud_a + longitud_b\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Cuál crees que será el resultado de longitud_a y longitud_b? Piensa por un momento y luego imprimámoslo para verlo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"La longitud a es: \", longitud_a)\n",
    "print(\"La longitud b es: \", longitud_b)\n",
    "\n",
    "# Presiona Ctrl + Enter después de seleccionar esta casilla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Acertaste? Si no fue así considera qué es lo que puede estar pasando.\n",
    "\n",
    "## Felicitaciones, has aprendido mucho. ¡Buen trabajo!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}