REPASO01-Tipos_Variables_y_Operadores.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Repaso de Python: tipos de variables y operadores\n",
    "\n",
    "A lo largo de todo el módulo vamos a usar Python (versión 3.x) y para empezar vamos a realizar un pequeño repaso de los tipos de datos básicos (`int`, `float`, `bool` y `str`) y sus operadores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.- Tipos de variables\n",
    "En Python existen distintos tipos de variables. Los tipos básicos son los siguientes:\n",
    "<ul>\n",
    "    <li>Integers (números enteros) - <b>int</b></li>\n",
    "    <li>Floating-Point Numbers (números reales) - <b>float</b></li>\n",
    "    <li>Boolean Type (booleano: verdadero o false) - <b>bool</b></li>\n",
    "    <li>Strings (cadenas de caracteres) - <b>str</b></li>\n",
    "</ul>\n",
    "\n",
    "### 1.1.- Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12121\n"
     ]
    }
   ],
   "source": [
    "# Declaración de una variable entera (número entero)\n",
    "num_int = 12121\n",
    "print(num_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-121"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Declaración de una variable que almacena un número entero negativo\n",
    "num_int = -121\n",
    "num_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# Tipo de la variable anterior\n",
    "print(type(num_int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.- Floating-Point Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.12\n"
     ]
    }
   ],
   "source": [
    "# Declaración de una variable decimal\n",
    "num_float = 25.12\n",
    "print(num_float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# También se puede usar esta notación cuando la parte entera es 0\n",
    ".9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4.567"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Por supuesto podemos crear números decimales negativos\n",
    "-4.567"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3.- Boolean\n",
    "\n",
    "Las variables de tipo `boolean` pueden tener 2 valores: `True` o `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4.- String\n",
    "\n",
    "Basicamente, un `string` es una secuencia __inmutable__ (en las secciones posteriores explicaremos la diferencia entre mutable e inmutable) de caracteres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Soy Alex\n"
     ]
    }
   ],
   "source": [
    "# Declaración de una variable que almacena la cadena de caracteres 'Soy Alex'\n",
    "txt_1 = 'Soy Alex'\n",
    "print(txt_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'soy Irene'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# También podemos declarar una cadena de caracteres con comillas dobles\n",
    "txt_2 = \"soy Irene\"\n",
    "txt_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos comprobar si `txt_1` y `txt_2` son equivalentes a pesar de que uno está escrito con doble comillas y otro con comillas simples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "txt_1 == txt_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A veces, necesitamos escribir comillas dentro del string (por lo que será recomendable usar comillas dobles en lugar de comillas simples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-12-544903f163df>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-12-544903f163df>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    txt_3 = 'I'm Alex'\u001b[0m\n\u001b[1;37m               ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "txt_3 = 'I'm Alex'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm Alex\n",
      "I'm Alex \n",
      "test\n"
     ]
    }
   ],
   "source": [
    "txt_7 = \"I'm Alex\"  # Comillas dobles\n",
    "print(txt_7)\n",
    "\n",
    "txt_8 = 'I\\'m Alex \\n'  # Comillas simples con una barra para la comilla interna\n",
    "print(txt_8 + \"test\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2- Operadores\n",
    "Podemos trabajar con los tipos básicos y llevar a cabo operaciones entre ellos. Con este fin, existen distintos tipos de operadores implementados en Python:\n",
    "- Operadores aritméticos\n",
    "- Operadores lógicos\n",
    "- Operadores de comparación\n",
    "- Operadores de asignación\n",
    "\n",
    "También existen los operadores de identidad (se utilizan para comprobar si dos variables son, o no, el mismo objeto); los operadores a nivel de bits, los cuales no estudiaremos ya que no vamos a utilizarlos en este módulo (si se quieren entender y conocer consúltese la [documentación](https://wiki.python.org/moin/BitwiseOperators)); y los operadores de pertenencia, en los que se profundiza en secciones posteriores. Comencemos con los operadores aritméticos:\n",
    "\n",
    "### 2.1.- Operadores aritméticos\n",
    "\n",
    "#### 2.1.1.- Operadores aritméticos básicos\n",
    "En Python, los operadores aritméticos básicos son: `+`, `-`, `/` y `*`. Con las variables numéricas (`int` y `float`) funcionan como estamos acostumbrados con el mismo orden de prioridad que en matemáticas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "41.666666666666664"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "44 + 11 - 20/3 * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se opera con números negativos como conocemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-223.3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-221.3 - 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.2.- Operadores de la división\n",
    "En el caso de la división, existen dos tipos de operadores:\n",
    "- La división real (o decimal): `/` (se trata de la divisón que obtiene el resultado con todos los decimales tal y como la conocemos)\n",
    "- La división entera: `//` (obtiene la parte entera de la división que se lleva a cabo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48.2"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "241/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "241//5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También es posible calcular el resto de una división utilizando el operador módulo `%`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9%2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>Ejercicio:</b> Calcula el resto de dividir 2348569 entre 49 - Sin usar el operador <b>%</b>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Obtenemos la división entera y luego le restamos el resultado de multiplicarlo por el divisor al dividendo\n",
    "resto = 2348569 - (2348569//49)*49\n",
    "resto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height: 2px; background-color: #858585;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.3.- Raíces y potencias\n",
    "Hay varias formas de elevar un número a otro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2 al cubo\n",
    "2**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Otra forma de poner dos al cubo\n",
    "pow(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 27 elevado a 1/3, o lo que es lo mismo, raíz cúbica de 27\n",
    "27**(1/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos generar potencias utilizando la notación científica tradicional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "600.0"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 6 por 10 al cuadrado\n",
    "6e2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`6e2` denota el valor: $6\\cdot 10^2$\n",
    "\n",
    "Por otro lado, podemos escribir las raíces (en lugar de como potencias) utilizando las librerías `numpy` y `sympy`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "numpy.float64"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "print(np.sqrt(9))\n",
    "type(np.sqrt(9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "sympy.core.numbers.Integer"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sympy\n",
    "print(sympy.sqrt(9))\n",
    "type(sympy.sqrt(9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1.4.- Operadores aritméticos sobre tipos no numéricos\n",
    "Algunos de estos operadores aritméticos pueden utilizarse con tipos no numéricos. Por ejemplo, la `+` con dos cadenas de caracteres será equivalente a la concatenación de las mismas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola Juan'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hola ' + 'Juan'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, el resto de operadores no están definidos para las variables de tipo `string`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'str' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-36-d67423e8ac56>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;34m'Hola '\u001b[0m \u001b[1;33m-\u001b[0m \u001b[1;34m'Juan'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'str' and 'str'"
     ]
    }
   ],
   "source": [
    "'Hola ' - 'Juan'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También es importante tener en cuenta que el operador `+` como concatenación solo funciona cuando ambos operandos son de tipo `string`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-37-4d4ac45d2a24>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;34m'El número '\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "'El número ' + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos concatenar una variable de otro tipo a un `string` primero debemos cambiar su tipo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'El número 3'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'El número ' + str(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En cuanto a la utilización de los operadores aritméticos con valores de tipo `bool`, observaremos que sí es posible realizar dicha operación e, incluso, se obtiene un valor numérico resultante. Esto se debe a que, internamente, Python le asignará un valor numérico a cada valor (1 a `True` y 0 a `False`) y después ejecutará la operación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "-1\n",
      "0.0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print(True + True)\n",
    "print(False - True)\n",
    "print(False/True)\n",
    "print(True**False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También es posible valores booleanos con valores numéricos en operaciones aritméticas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True + True * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>Ejercicio:</b> Calcula los minutos que hay en una semana\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10080\n"
     ]
    }
   ],
   "source": [
    "num_week = 1\n",
    "days_week = 7\n",
    "hours_day = 24\n",
    "minutes_hour = 60\n",
    "\n",
    "min_week = num_week * days_week * hours_day * minutes_hour\n",
    "print(min_week)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height: 2px; background-color: #858585;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.- Operadores lógicos\n",
    "Los operadores lógicos (o booleanos) son aquellos que nos permiten llevar a cabo operaciones entre los valores `True` y `False`. Estos son: `and`, `or` y `not`. Sean `x` e `y` variables de tipo `bool`, entonces los operadores lógicos se definen de la siguiente forma:\n",
    "- `x and y`: solo devuelve `True` cuando ambas variables son `True`.\n",
    "- `x or y`: devuelve `True` cuando alguna de las variables es `True`.\n",
    "- `not x`: devuelve `True` si `x` es `False` y viceversa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(True or False)\n",
    "print(False and True)\n",
    "print(not False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En realidad, los operadores lógicos vistos no devuelven `True` o `False`, sino que devuelven uno de los operandos. Supongamos que `a` y `b` son variables (esta vez no necesariamente variables lógicas), entonces pondemos definir el comportamiento de los operadores lógicos de la siguiente forma:\n",
    "- `a and b`: si `a` se evalúa como `False`, entonces devolverá `a`, de lo contrario devolverá `b`.\n",
    "- `a or b`: si `a` se evalúa como `False`, entonces devolverá `b`, de lo contrario devolverá `a`.\n",
    "- `not a`: si `a` se evalúa como `False`, entonces devolverá `True`, de lo contrario devolverá `False`.\n",
    "\n",
    "Veamos algunos ejemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "0\n",
      "-3\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Como 0 es el valor de False, el valor 0 se evalúa como False. El resto de valores se evalúan como True\n",
    "print(0 or 10)\n",
    "print(0 and 10)\n",
    "print(5 and -3)\n",
    "print(not 0)\n",
    "print(not 2.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola\n",
      "False\n",
      "5\n",
      "True\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "#También podemos usarlos mezclando tipos o con cadenas de caracteres\n",
    "print('Hola' or 3)\n",
    "print('False' or -2.3)\n",
    "#La cadena vacía se evalúa como False\n",
    "print('' or 5)\n",
    "print(not '')\n",
    "#El valor None se evalúa como falso\n",
    "print(None and 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.- Operadores de comparación\n",
    "Los operadores de comparación se utilizan, como su nombre indica, para comparar dos o más valores. El resultado de estos operadores siempre es `True` o `False`. La condición para utilizar estos operadores es que ambos valores sean del mismo tipo (a excepción de los valores lógicos, que recordemos que pueden ser evaluados como numéricos). Estos operadores son:\n",
    "- $>$ (mayor que): `True` si el operando de la izquierda es estrictamente mayor que el de la derecha, `False` en caso contrario.\n",
    "- $>=$ (mayor o igual que): `True` si el operando de la izquierda es mayor o igual que el de la derecha, `False` en caso contrario.\n",
    "- $<$ (menor que): `True` si el operando de la izquierda es estrictamente menor que el de la derecha, `False` en caso contrario.\n",
    "- $<=$ (menor o igual que): `True` si el operando de la izquierda es menor o igual que el de la derecha, `False` en caso contrario.\n",
    "- $==$ (igual que): `True` si el operando de la izquierda es igual que el de la derecha, `False` en caso contrario.\n",
    "- $!=$ (distinto): `True` los dos operandos son distintos, `False` en caso contrario.\n",
    "\n",
    "Veamos algunos ejemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(1 < 9)\n",
    "print(1 > 9)\n",
    "print(1 == 9)\n",
    "print(1 != False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se pueden comparar cadenas de caracteres entre sí:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('Hola' < 'Adiós')\n",
    "print('Hola' > 'Adiós')\n",
    "print('Hola' == 'hola')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para la comparación utiliza el código Unicode y los compara caracter a caracter (siendo distintas dos letras si una está en mayúscula y otra en minúscula). Si los primeros son iguales, entonces compara el código Unicode de los segundos caracteres de ambos operandos.\n",
    "\n",
    "<img src=\"./images/unicode.png\" width=400>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>Ejercicio:</b> Crea una expresión de tipo boolean para saber si la suma de 673 y 909 es divisible entre 3.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divisible_3 = ((673 + 909) % 3 == 0)\n",
    "divisible_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height: 2px; background-color: #858585;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.- Operadores de asignación\n",
    "Los operadores de asignación se utilizan para asignar un valor a una variable. Algunos de estos son:\n",
    "- `=`: es el operador de asignación básico. Asigna el valor a su derecha a la variable a su izquierda.\n",
    "- `+=`: lleva a cabo la operación `+` antes de la asignación tomando como operandos la propia variable y el valor a la derecha del signo igual. Por ejemplo: `x += 2` es equivalente a ejecutar `x = x + 2`.\n",
    "- `-=`: lleva a cabo la operación `-` antes de la asignación tomando como operandos la propia variable y el valor a la derecha del signo igual. Por ejemplo: `x -= 2` es equivalente a ejecutar `x = x - 2`.\n",
    "- `*=`: lleva a cabo la operación `*` antes de la asignación tomando como operandos la propia variable y el valor a la derecha del signo igual. Por ejemplo: `x *= 2` es equivalente a ejecutar `x = x * 2`.\n",
    "- `/=`: lleva a cabo la operación `/` antes de la asignación tomando como operandos la propia variable y el valor a la derecha del signo igual. Por ejemplo: `x /= 2` es equivalente a ejecutar `x = x / 2`.\n",
    "- `//=`: lleva a cabo la operación `//` antes de la asignación tomando como operandos la propia variable y el valor a la derecha del signo igual. Por ejemplo: `x //= 2` es equivalente a ejecutar `x = x //2`.\n",
    "- `%=`: lleva a cabo la operación `%` antes de la asignación tomando como operandos la propia variable y el valor a la derecha del signo igual. Por ejemplo: `x %= 2` es equivalente a ejecutar `x = x % 2`.\n",
    "- `**=`: lleva a cabo la operación `**` antes de la asignación tomando como operandos la propia variable y el valor a la derecha del signo igual. Por ejemplo: `x **= 2` es equivalente a ejecutar `x = x ** 2`.\n",
    "\n",
    "Es importante remarcar que a la izquierda de los operadores de asignación debe ir una variable, ya que no se trata de una comparación, sino de almacenar el valor de la derecha en la variable de la izquierda. Veamos algunos ejemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Le asignamos el valor 2 a la variable x\n",
    "x = 2\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Le sumamos 5 a la variable x que posee el valor 2\n",
    "x += 5\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "cannot assign to literal (<ipython-input-48-b6c4c16ad638>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-48-b6c4c16ad638>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    2 = x\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m cannot assign to literal\n"
     ]
    }
   ],
   "source": [
    "# El operando de la izquierda debe ser una variable\n",
    "2 = x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'variable_no_declarada' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-49-8c259f64d763>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Para usar un operador de asignación compuesto (cualquiera distinto del =), tiene que haber sido declarada la variable\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;31m# antes con el operador =\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mvariable_no_declarada\u001b[0m \u001b[1;33m*=\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'variable_no_declarada' is not defined"
     ]
    }
   ],
   "source": [
    "# Para usar un operador de asignación compuesto (cualquiera distinto del =), tiene que haber sido declarada la variable\n",
    "# antes con el operador =\n",
    "variable_no_declarada *= 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.- Resumen\n",
    "En Python existen distintos tipos de variables, entre los que se encuentran: `int` (enteros), `float` (reales), `bool` (lógicos) y `string` (cadenas de caracteres). Podemos trabajar con estos tipos con los siguientes operadores:\n",
    "- Operadores aritméticos: `+` (suma o concatenación de caracteres), `-` (resta), `*` (multiplicación), `/` (división), `//` (división entera), `%` (resto de la división) y `**` (potencia). También podemos calcular raíces utilizando la función `sqrt` de la librería `numpy` y escribir en notación científica usando `e` (ejemplo: `6e2` que es equivalente a $6\\cdot 10^2$).\n",
    "- Operador lógicos: `and`, `or` y `not`.\n",
    "- Operadores de comparación: $>$, $>=$, $<$, $<=$, $==$ y $!=$.\n",
    "- Operadores de asignación: `=`, `+=`, `-=`, `*=`, `/=`, `//=`, `%=` y `**=`."
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}