{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables de Python\n",
    "\n",
    "Variable es un nombre que se usa para referirse a la ubicación de la memoria. La variable de Python también se conoce como un identificador y se usa para mantener el valor.\n",
    "\n",
    "En Python, no necesitamos especificar el tipo de variable porque Python es un lenguaje de inferir y lo suficientemente inteligente como para obtener el tipo de variable.\n",
    "\n",
    "Los nombres de las variables pueden ser un grupo de letras y dígitos, pero deben comenzar con una letra o un guión bajo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Declaración de variable y asignación de valores\n",
    "\n",
    "Python no nos obliga a declarar una variable antes de usarla en la aplicación. Nos permite crear una variable en el momento requerido.\n",
    "\n",
    "No necesitamos declarar explícitamente variables en Python. Cuando asignamos cualquier valor a la variable, esa variable se declara automáticamente.\n",
    "\n",
    "El operador igual (=) se utiliza para asignar valor a una variable.\n",
    "\n",
    "En Python, las variables son un nombre simbólico que es una referencia o puntero a un objeto. Las variables se utilizan para denotar objetos con ese nombre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1 = 1.20\n",
    "print(var1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo de arriba, la variable var1 se refiere a un objeto float (decimal) que tiene el valor de 1.20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1=int(var1)\n",
    "print(var1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La variable var1 fue forzada a tomar el valor de un entero"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suponga que asignamos el valor entero 120 a una nueva variable var2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1 = 120\n",
    "\n",
    "var2 = var1\n",
    "\n",
    "print(var2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La variable var2 se refiere al mismo objeto al que apunta a porque Python no crea otro objeto. Python administra la memoria de manera eficiente si asignamos la misma variable a dos valores diferentes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Asignemos nuevos valores. Ahora ambas variables se referirán a los diferentes objetos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1 = 120\n",
    "var2 = 200\n",
    "\n",
    "print(var1)\n",
    "print(var2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Errores al declarar una variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var 1 = 120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@var1 = 120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1var = 120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var-1 = 120"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Asignación múltiple\n",
    "\n",
    "Python nos permite asignar un valor a múltiples variables en una sola declaración, lo que también se conoce como asignaciones múltiples.\n",
    "\n",
    "Podemos aplicar múltiples asignaciones de dos maneras, ya sea asignando un solo valor a múltiples variables o asignando múltiples valores a múltiples variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Asignación de un solo valor a varias variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1 = var2 = var3 = 200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(var1)\n",
    "print(var2)\n",
    "print(var3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Asignar varios valores a varias variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1, var2, var3 = 10 , 20 , 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(var1)\n",
    "print(var2)\n",
    "print(var3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tipos de datos integrados \n",
    "Python tiene varios tipos de datos integrados , como números (enteros, flotantes, números complejos), cadenas, listas, tuplas y diccionarios.\n",
    "\n",
    "Hoy veremos **entero** y **flotantes (decimales)**.\n",
    "\n",
    "Python soporta dos tipos de números - enteros y números de punto flotante (decimales). \n",
    "\n",
    "- Los números enteros son: - 1, 2, 22, 476,-99999\n",
    "- Los *float* o decimales son: - 1.0, 2.22, 22.098, 476.1,-99999.9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para definir un entero, usa la siguiente sintaxis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "mientero = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type( mientero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mientero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para definir un float (decimal), se usa la siguiente sintaxis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "mifloat = 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(mifloat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(mifloat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "mifloat2 = float(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(mifloat2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manipular números\n",
    "\n",
    "\n",
    "## Operadores Aritméticos\n",
    "Tal como cualquier otro lenguaje de programacion, los operadores de sumas, restas, multiplicaciones y divisiones pueden ser usadas con números.\n",
    "\n",
    "Con los números se pueden realizar los siguientes tipos de operaciones:\n",
    "\n",
    "| Operación | Resultado       |\n",
    "| --------- | --------------- |\n",
    "|    +      | Suma            |\n",
    "|    -      | Resta           |\n",
    "|    *      | Multiplicación  |\n",
    "|    /      | División        |\n",
    "|    //     | División entera |\n",
    "|    \\*\\*   | Potencia        |\n",
    "\n",
    "Algunos sencillos ejemplos son:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 + 3   # Suma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19.990000000000002\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#esta suma retornada un float\n",
    "\n",
    "numero1 = 10\n",
    "numero2 = 9.99\n",
    "numero3 = numero1 + numero2\n",
    "print(numero3)\n",
    "type(numero3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19.990000000000002\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#esta suma retorara un float\n",
    "\n",
    "numero1 = 10.0\n",
    "numero2 = 9.99\n",
    "numero3 = numero1 + numero2\n",
    "print(numero3)\n",
    "type(numero3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#esta suma retornada un entero\n",
    "\n",
    "numero1 = 10\n",
    "numero2 = 10\n",
    "numero3 = numero1 + numero2\n",
    "print(numero3)\n",
    "type(numero3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "8 - 5   # Resta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 * 6   # Multiplicacion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "12 / 3  # Division "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "12 // 3 #Division entera"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 % 3   # Modulo (retorna el remanente de la división)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cuadrado = 7 ** 2 #potencia al cuadrado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cubico = 2 ** 3 #potencia al cubo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 15 + 18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sqrt = x**(1/2) # raiz cuadrada"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Orden en las operaciones\n",
    "\n",
    "Cuando en una expresión aparece más de un operador, el orden de evaluación depende de las reglas de precedencia. Para los operadores matemáticos, Python sigue la convención matemática. El acrónimo **PEMDAS** es una forma útil de recordar las reglas: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paréntesis (P)\n",
    "Los paréntesis tienen la mayor precedencia y pueden ser usados para forzar una expresión a evaluar en el orden que se desee. Como las expresiones entre paréntesis se evalúan primero "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "por ejemplo 2 * (3-1) es 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*(3-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y (1+1)**(5-2) es 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1+1)**(5-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También puede usar paréntesis para hacer una expresión más fácil de leer, como en (minuto * 100) / 60, incluso si no cambia el resultado. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "minuto = 10\n",
    "\n",
    "(minuto * 100 )/ 60 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "minuto*100/60"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exponenciación (E)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La exponenciación tiene la siguiente precedencia más alta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así que 2**1+1 es 3, no 4,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2**1+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y 3\\*1**3 es 3, no 27."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3*1**3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiplicación (M), División (D), Suma (A), Resta (S)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La multiplicación y la división tienen la misma precedencia, que es mayor que\n",
    "Suma y resta, que también tienen la misma precedencia. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así que 2*3-1 es 5, no 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2*3-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y 6+4/2 es 8, no 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "6+4/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Misma precendencia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los operadores con la misma precedencia se evalúan de izquierda a derecha. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así que la expresión 5-3-1 es 1, no 3, porque el 5-3 ocurre primero y luego el 1 es\n",
    "restado de 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5-3-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicios rápidos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1) ¿Que imprime el siguiente programa ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 43 \n",
    "x = x +1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) Calcule el promedio de las siguientes variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1 = 10\n",
    "var2 = 4\n",
    "var3 = 5.5\n",
    "var4 = 67"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"El promedio de esos numeros es \"+str(promedio))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3) Calcule el área y perímetro de un cuadrado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=https://i.ytimg.com/vi/cRt7OHEOAVE/maxresdefault.jpg>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}