1_Introducción_a_la_programación_en_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iIq_zGATE5V6"
   },
   "source": [
    "<center>\n",
    "    \n",
    "    \n",
    "# Curso de Python básico\n",
    "## Instituto Mexicano del Petróleo\n",
    "\n",
    "### Dra. Gabriela Berenice Díaz Cortés (gbdiaz@imp.mx)\n",
    "\n",
    "### Dr. Luis Antonio López Peña (llopezp@imp.mx) \n",
    "\n",
    "#### Dirección de Investigación en Exploración y Producción\n",
    "#### Gerencia de Ingeniería de Yacimientos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O2L-JDpkE7Kk"
   },
   "source": [
    "## **Introducción a Python**\n",
    "\n",
    "* **Python**\n",
    "    - Instalación de Python\n",
    "    - Formas de ejecutar un código (desde consola o IDE)\n",
    "    - IDE más comunes\n",
    "    - Colaboratory\n",
    "\n",
    "* **Definición de variables**\n",
    "    - Palabras restringidas\n",
    "    - Números enteros y reales\n",
    "    - Carácteres\n",
    "    - Leer datos de terminal\n",
    "    - Conversiones de datos\n",
    "\n",
    "* **Tipos de objetos en Python**\n",
    "    - Tuplas\n",
    "    - Listas\n",
    "    - Diccionarios\n",
    "    - Conjuntos\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dY3SBe6gccSy"
   },
   "source": [
    "# Python\n",
    "Python es un lenguaje de programación libre orientado a objetos, desarrollado a finales de los 80's. Desde su creación se sigue desarrollando y refinando. \n",
    "Algunas referencias son:\n",
    "* Sitio web con manuales y más información: https://www.python.org/about/, http://docs.python.org/py3k/tutorial.\n",
    "* Introduction to Python for Computational Science and Engineering, Hans Fangohr\n",
    "* Python, Chris Fehly (Peachpit Press, CA, 2nd ed.)\n",
    "* Python Essential Reference, David M. Beazley (Addison-Wesley, 4th ed.)\n",
    "* Primer on Scientific Programming with Python, Hans P. Langtangen (Springer-Verlag, 2009)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_w-YkmfWK_FM"
   },
   "source": [
    "## Instalación\n",
    "Para ejecutar un código escrito en Python se recomienda usar un IDE (integrated development environment), es un paquete de software que tiene las herramientas básicas necesarias para escribir y probar software. Los IDE's incluyen un editor de código, un compilador, un depurador y un entorno gráfico. \n",
    "\n",
    "En este curso usaremos la distribución gratuita [Anaconda][], que contiene el IDE Spyder y el block de notas [Jupyter][], que es un ambiente computacional interactivo, en donde se combina texto, se ejecuta codigo, y se obtienen graficas. \n",
    "\n",
    "\n",
    "Los pasos del instalador se encuentran en este sitio https://www.anaconda.com/distribution/\n",
    "\n",
    "Para utilizar el block de notas [Jupyter][], se pueden consultar los siguientes manuales: [Jupyter_manual] y [Jupyter-notebook].\n",
    "\n",
    "[Spyder]:   https://www.spyder-ide.org/\n",
    "[Anaconda]: https://www.anaconda.com/\n",
    "[Jupyter]:  https://jupyter.org/\n",
    "[Python 3.7]: https://repo.anaconda.com/archive/Anaconda3-2019.03-MacOSX-x86_64.pkg\n",
    "[Jupyter_manual]: https://jupyter.brynmawr.edu/services/public/dblank/Jupyter%20Notebook%20Users%20Manual.ipynb\n",
    "[Jupyter-notebook]:https://buildmedia.readthedocs.org/media/pdf/jupyter-notebook/latest/jupyter-notebook.pdf\n",
    "[IBM_Jupyter]: https://www.ibm.com/support/knowledgecenter/en/SSGNPV_1.1.3/dsx/markd-jupyter.html\n",
    "[Other]: https://sourceforge.net/p/jupiter/wiki/markdown_syntax/\n",
    "\n",
    "\n",
    "### Formas de ejecutar el código \n",
    "\n",
    "## Creación de entornos virtuales\n",
    "\n",
    "Para instalar librerías se recomienda crear un **entorno virtual** e instalar las librerías requeridas para cada proyecto en el entorno correspondiente al proyecto en cuestión.\n",
    "\n",
    "\n",
    "### Entorno virtual en terminal\n",
    "Para crear un entorno virual en linux o en la terminal de windows se abre la terminal, en el caso de windows la terminal se encuentra en *Anaconda Prompt*, una vez abeierta la terminal, los pasos a seguir son los siguientes:\n",
    "\n",
    "<img src=\"https://github.com/gbdiazc/Images/blob/f2031a840a330db98a65ac392e85a34acd040904/anaconda_promt.png?raw=1\" width=\"600\">\n",
    "\n",
    "1.   Crear entorno virtual: \n",
    "\n",
    "`\\$conda create -n my_env`\n",
    "\n",
    "\n",
    "2.   Activar entorno virtual:\n",
    "\n",
    "`\\$conda activate my_env`\n",
    "\n",
    "\n",
    "### Entorno virtual en Anaconda navigator\n",
    "\n",
    "Se crea un entorno virtual con python\n",
    "\n",
    "<img src=\"https://github.com/gbdiazc/Images/blob/da07a190294b9890e4fb4490980932bbec822524/new_env.png?raw=1\" width=\"600\">\n",
    "\n",
    "#### IDEs\n",
    "\n",
    "##### Spyder \n",
    "\n",
    "<img src=\"https://github.com/gbdiazc/Images/blob/da07a190294b9890e4fb4490980932bbec822524/spyder.png?raw=1\" width=\"600\">\n",
    "\n",
    "    \n",
    "    Se guarda el archivo exemplo.py\n",
    "\n",
    "    Boton de correr \n",
    "\n",
    "<img src=\"https://github.com/gbdiazc/Images/blob/da07a190294b9890e4fb4490980932bbec822524/spyder1.png?raw=1\" width=\"600\">\n",
    "\n",
    "Jupyter Notebook (Colaboratory)\n",
    "    \n",
    "    Se crea el archivo file.ipynb\n",
    "    \n",
    "    Se crea una nueva celda de código\n",
    "\n",
    "    Boton de correr \n",
    "\n",
    "\n",
    "#### Desde consola (linux) con archivos .py\n",
    "\n",
    "    Se crea el archivo file.py\n",
    "\n",
    "    Se carga el ambiente virtual que contiene python\n",
    "\n",
    "    Se escribe en terminal \n",
    "        \n",
    "        python file.py\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SrRglGUcK_FO"
   },
   "source": [
    "# Palabras restringidas\n",
    "\n",
    "Los lenguajes de programación reservan ciertas palabras que tienen un significado especial. Estas palabras se llaman palabras clave \"keywords\".\n",
    "Con estas palabras el programador puede emitir comandos para el compilador o intérprete, estas palabras clave son palabras reservadas que no sepueden usar como nombres de variables.\n",
    "Las palabras clave más importantes de Python son las siguientes:\n",
    "\n",
    "\\begin{array}{c c c c} \n",
    "False & True& and & or   \\\\ \n",
    "not & break & continue & class\\\\\n",
    "def & if & elif & else \\\\ \n",
    "for & while & in & is\\\\ \n",
    "None & lambda& return& len\\\\\n",
    "del & type & str & float\\\\\n",
    "int &  &  & \\\\\n",
    "\\end{array}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kVyH35k7K_FP"
   },
   "outputs": [],
   "source": [
    "1 > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qx1lviAhK_FQ"
   },
   "outputs": [],
   "source": [
    "2 > 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "x5eMTgGfK_FR"
   },
   "outputs": [],
   "source": [
    "x, y = True , False\n",
    "(x or y) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PIo0vYW7K_FS"
   },
   "outputs": [],
   "source": [
    "(x and y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "IYG6k4MuK_FT"
   },
   "outputs": [],
   "source": [
    "( not y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JfIH6MMfK_FU"
   },
   "outputs": [],
   "source": [
    "42 in [ 2 , 39 , 42 ] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YcV6xn0LK_FW"
   },
   "outputs": [],
   "source": [
    "y = x = 3\n",
    "x is y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-NyFJAPLK_FW"
   },
   "outputs": [],
   "source": [
    "[3] is [3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6STsPSAu6Dh4"
   },
   "outputs": [],
   "source": [
    "[3] == [3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NCxjRd9kK_FX"
   },
   "outputs": [],
   "source": [
    "[1] in [[3],[2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "eOvAzMzwK_FY"
   },
   "outputs": [],
   "source": [
    "3 in [3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "iOqjMTyVK_FY"
   },
   "outputs": [],
   "source": [
    "len([ 2 , 39 , 42 ] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Kg_xz6dXK_FZ"
   },
   "source": [
    "## Definición de variables\n",
    "En python se pueden usar variables tipo entero, flotantes, caractéres, etc. Para definir una variable como flotante se usa un punto (__numero.0__ ), y para caractéres se usan comillas (**'carácter'** o **''carácter''**). Para ver que tipo de variable es, se utiliza la funcyón **type**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RX8cuhtgK_FZ"
   },
   "outputs": [],
   "source": [
    "b = 2        # b entero\n",
    "print(b, type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Br0Gj9e_K_FZ"
   },
   "outputs": [],
   "source": [
    "b = 2.0      # b flotante \n",
    "print(b, type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4-xsTxtjK_Fa"
   },
   "outputs": [],
   "source": [
    "b = 'Hola 2.0'  # b es un caracter \n",
    "print(b, type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rdMHZViUK_Fb"
   },
   "source": [
    "## Challenge break\n",
    "### 1\n",
    "Asignar el valor 2 a la variable x y el valor 3 a la variable y e imprimirlas\n",
    "\n",
    "Sumar ambas variables en z e imprimirla\n",
    "\n",
    "Borrar la variable x e imprimir todas las variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xDtfSAXIHZl9"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xJNWAh5FK_Fb"
   },
   "source": [
    "### 2\n",
    "Dados x = 10 and y = 3, calcular las siguientes operaciones e imprimir los resultados\n",
    "\n",
    "```\n",
    "u = x + y\n",
    "v = xy\n",
    "w = x/y\n",
    "z = x - y\n",
    "r = x**9\n",
    "s = y*3\n",
    "p = x**y\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JK2eYCIuK_Fc"
   },
   "outputs": [],
   "source": [
    "# Respuesta\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L_xFNoOwK_Fc"
   },
   "source": [
    "### 3\n",
    "Contar el número de letras que tiene la siguiente oración e imprimir la oración, seguida del número de letras que tiene, \n",
    "\n",
    "    x = \"Instituto Mexicano del Petróleo\" \n",
    "    \n",
    "    y = \"Tu nombre completo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3Dnqg_XbK_Fd"
   },
   "outputs": [],
   "source": [
    "# Respuesta\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bwoMUqF2K_Fd"
   },
   "source": [
    "### Caracteres (Strings)\n",
    "Los caracteres se pueden crear de las siguientes formas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "heRheAjFK_Fd"
   },
   "source": [
    "1. Comillas simples\n",
    "\n",
    "**s = 'caracter'**\n",
    "\n",
    "2. Comillas dobles\n",
    "\n",
    "**s =  \"caracter\"**\n",
    "\n",
    "3. Comillas triples (multi-linea)\n",
    "**s = \n",
    "\"\"\"caracter**\n",
    "\n",
    "**numero uno\"\"\"**\n",
    "\n",
    "4. Metodo de caracter\n",
    "\n",
    "**s = str(5 ) ==  '5'**\n",
    "\n",
    "5. Concatenacion\n",
    "\n",
    "**s =\"Nom\" +  \"bre\"**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QvR9hImxK_Fe"
   },
   "outputs": [],
   "source": [
    "#1. Comillas simples\n",
    "\n",
    "s = 'caracter'\n",
    "\n",
    "print(s,type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xxpQyEUyK_Fe"
   },
   "outputs": [],
   "source": [
    "#2. Comillas dobles\n",
    "\n",
    "s =  \"Caracter\"\n",
    "\n",
    "print(s,type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rzTFt7qpK_Fe"
   },
   "outputs": [],
   "source": [
    "#3. Comillas triples (multi-linea)\n",
    "\n",
    "s = \"\"\"Este es \n",
    "\n",
    "un caracter\n",
    "\n",
    "Para un \n",
    "\n",
    "texto mas \n",
    "\n",
    "largo\"\"\"\n",
    "\n",
    "print(s,type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SH6W8rd2K_Ff"
   },
   "outputs": [],
   "source": [
    "#4. Metodo de caracter\n",
    "n = 5\n",
    "print(n,type(n))\n",
    "s =  str(n)\n",
    "print(s,type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "fbFplDGfK_Ff"
   },
   "outputs": [],
   "source": [
    "# 5. Concatenacion\n",
    "\n",
    "s =\"Ma\" +  \"rio\"\n",
    "\n",
    "print(s,type(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q0WxSQIkK_Ff"
   },
   "source": [
    "# Espacios en blanco\n",
    "\n",
    "    * Línea Nueva línea \\n\n",
    "    * Tab \\t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZA8QMdCdK_Ff"
   },
   "outputs": [],
   "source": [
    "s =\"Nombre: Mario, Edad: 5\"\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vKuScZfUK_Fg"
   },
   "outputs": [],
   "source": [
    "s =\"Nombre: Mario,\\nEdad:\\t 5\"\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZypTQw9tK_Fg"
   },
   "outputs": [],
   "source": [
    "## Indexing & Slicing\n",
    "s = \"La persona más joven tiene 11 años\"\n",
    "print(s[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZRD1zc7GK_Fg"
   },
   "outputs": [],
   "source": [
    "print(s[0:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "saDaBfITK_Fh"
   },
   "outputs": [],
   "source": [
    "print(s[-3:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0NVezqkzK_Fh"
   },
   "outputs": [],
   "source": [
    "print(s[-3:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yKIt9NpGK_Fh"
   },
   "outputs": [],
   "source": [
    "x = s.split()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AnNAKs4SK_Fh"
   },
   "outputs": [],
   "source": [
    "print(x[-2] + \" \"+ x[-1] + \" \"+x[-3] + \"s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gv6N-yUAK_Fi"
   },
   "outputs": [],
   "source": [
    "import re # regular expressions\n",
    "m = re.split(r'\\W+', s)\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZKKuKn6MK_Fi"
   },
   "outputs": [],
   "source": [
    "m[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-K89FBQ_K_Fi"
   },
   "outputs": [],
   "source": [
    "m[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FA0hkm0dK_Fi"
   },
   "outputs": [],
   "source": [
    "m[-3:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "IccjGhNYK_Fj"
   },
   "outputs": [],
   "source": [
    "s[-3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xR2wgY2NK_Fj"
   },
   "outputs": [],
   "source": [
    "s = m[0]+m[1]\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nyQ4MjTfK_Fj"
   },
   "outputs": [],
   "source": [
    "s = m[0]+ m[1]\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ynzT9yTYK_Fj"
   },
   "outputs": [],
   "source": [
    "# Minusculas\n",
    "s = \"La persona más joven tiene 11 años\"\n",
    "print(s.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RfTCrzvkK_Fk"
   },
   "outputs": [],
   "source": [
    "# Mayusculas\n",
    "print(s.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "egY9d57_K_Fk"
   },
   "outputs": [],
   "source": [
    "s = \"smartphone\"\n",
    "print(s.startswith(\"smart\" ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "__IwJpAZK_Fk"
   },
   "outputs": [],
   "source": [
    "print(s.endswith(\"phone\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RJ1-hxFEK_Fm"
   },
   "outputs": [],
   "source": [
    "s = \"another\"\n",
    "print(s.find(\"other\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NgFvwbpEK_Fm"
   },
   "outputs": [],
   "source": [
    "print(s[2:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tTm4RDz3K_Fm"
   },
   "outputs": [],
   "source": [
    "s = \"cheat\"\n",
    "print(s.replace(\"ch\", \"m\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HA_xZZMaK_Fm"
   },
   "outputs": [],
   "source": [
    "print(','.join([\"F\", \"B\", \"I\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Mw9bjxc1K_Fn"
   },
   "outputs": [],
   "source": [
    "print(len(\"earth\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tucS3cPPK_Fn"
   },
   "outputs": [],
   "source": [
    "print(\"ear\"in\"earth\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nw8HJYF1K_Fn"
   },
   "source": [
    "## Challenge break\n",
    "### 4\n",
    "\n",
    "Asigne la cadena 'HOLA' a la variable s1 y la cadena 'hola' a la variable s2. Usa el operador *==* para mostrar que no son iguales. \n",
    "\n",
    "Mostrar que s1 y s2 son iguales si se usa el método *s1.lower()* en s1. \n",
    "\n",
    "Mostrar que s1 y s2 son iguales si se usa el método *s2.upper()* en s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1boNYXDTK_Ft"
   },
   "outputs": [],
   "source": [
    "# Respuesta\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tvSDm0NRK_Ft"
   },
   "source": [
    "## Leer datos de terminal\n",
    "En python se pueden leer datos de teclado con la función **input()**. \n",
    "Esta funcion lee todo como cadenas de texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PMfU7YmHK_Fu"
   },
   "outputs": [],
   "source": [
    "# Leer texto\n",
    "texto = input()\n",
    "print(\"Se leyo el siguiente texto: \",texto)\n",
    "print(\"De tipo \",type(texto))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "J7kmC30yK_Fu"
   },
   "outputs": [],
   "source": [
    "# Además, la función input puede tener un parámetro indicando al usuario que debe ingresar\n",
    "mes = input(\"Ingrese mes: \")\n",
    "print(\"Se leyo el siguiente mes: \",mes)\n",
    "print(\"De tipo \",type(mes))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Hx-E-N-EK_Fv"
   },
   "source": [
    "# CASTING (Conversiones de tipo de dato)\n",
    "Si la función **input()** lee un texto y queremos que lo convierta en entero, se hace una conversion con la funcion **int()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ppH_Kf8WK_Fv"
   },
   "outputs": [],
   "source": [
    "numero = input()\n",
    "print(\"Se leyo: \",numero)\n",
    "print(\"De tipo \",type(numero))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zu1Q4rpFK_Fv"
   },
   "outputs": [],
   "source": [
    "# Se convierte en entero\n",
    "entero = int(numero)\n",
    "print(\"El numero leido : \",entero)\n",
    "print(\"Se convirtio en tipo \",type(entero))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pUgAYPuVK_Fw"
   },
   "outputs": [],
   "source": [
    "# Version simplificada\n",
    "entero = int(input())\n",
    "print(\"El numero leido : \",entero)\n",
    "print(\"Se convirtio en tipo \",type(entero))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ohZOhzbWK_Fw"
   },
   "source": [
    "Si queremos que lo convierta en decimales, se hace una conversion con la funcion **float()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "usB_wB3mK_Fw"
   },
   "outputs": [],
   "source": [
    "numero = input()\n",
    "print(\"El numero leido : \",numero)\n",
    "print(\"Es de tipo \",type(numero))\n",
    "\n",
    "decimal = float(numero)\n",
    "print(\"El numero leido en decimal: \",decimal)\n",
    "print(\"Se convirtio en tipo \",type(decimal))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "A83ph5WvK_Fw"
   },
   "outputs": [],
   "source": [
    "# Version simplificada\n",
    "decimal = float( input())\n",
    "print(\"Numero leido : \",decimal)\n",
    "print(\"Se convirtio en tipo \",type(decimal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IkLbS7O1FKdJ"
   },
   "source": [
    "## Challenge break \n",
    "### 5\n",
    "Realiza un código que tome 2 numeros dados por un usuario y verifique si la suma es menor, mayor o igual que 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oL4LaLcBFJOI"
   },
   "outputs": [],
   "source": [
    "# Respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6Oy800-FK_Fw"
   },
   "source": [
    "\n",
    "Realizar un código que lea dos números de terminal y una operacion, y que imprima la operación que se está realizando, asi como los resultados, elegir una de las siguientes operaciones:\n",
    "\n",
    "    \"+\"\n",
    "\n",
    "    \"-\"\n",
    "\n",
    "    \"*\"\n",
    "    \n",
    "    \"/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "M4ZALMmHK_Fx"
   },
   "outputs": [],
   "source": [
    "# Respuesta\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "je5F_bu5K_Fx"
   },
   "source": [
    "# Objetos en Python\n",
    "Python tiene dos tipos de objetos para manejar varios números o secuencias de caractéres.\n",
    "* **Listas: b = [0, 1, 2, 3, 'cuatro', 'cinco']**\n",
    "* **Tuplas (Tuples): b = (0, 1, 2, 3, 4, 5)**\n",
    "\n",
    "En Python, el primer elemento es el cero **(0)**, si la lista o el carácter contiene **(N)** elementos, el último elemento es el __N-1__. Un elemento de una lista o un carácter se obtiene usando parentesis cuadrados **(variable[numero de elemento])**. La principal diferencia entre una tupla y una lista, es que las tuplas son inmutables, es decir nos e pueden modificar.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "v2jcjl9KK_Fx"
   },
   "outputs": [],
   "source": [
    "# Listas\n",
    "List  = ['string', 1, 2]               # Crear una lista\n",
    "print(List)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qCt6L0zNK_Fx"
   },
   "outputs": [],
   "source": [
    "print(List[0],type(List[0]))           # Selecciona el primer elemento de la lista\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2ABse8cIK_Fx"
   },
   "outputs": [],
   "source": [
    "print(List[2],type(List[2]))           # Selecciona el último elemento de la lista\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JSKrNsXzK_Fy"
   },
   "outputs": [],
   "source": [
    "print(List[0:2])                       # Selecciona los primeros dos elementos con posición 0 y 2 sin el último elemento (2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "r9rdmlVOK_Fy"
   },
   "outputs": [],
   "source": [
    "List2 = [[3, 4],List]                  # Hacer una lista de listas\n",
    "print(List2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "G0SRFHwjK_Fy"
   },
   "outputs": [],
   "source": [
    "List2.append(1)                        # Agregar el valor de 1 a la lista\n",
    "print(List2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ah7qSXdmK_Fy"
   },
   "outputs": [],
   "source": [
    "List2.append(\"a\")                      # Agregar el string \"a\" a la lista\n",
    "print(List2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Si_2-UEhK_Fy"
   },
   "outputs": [],
   "source": [
    "List2.insert( 2 , \"b\" )               # Agregar el string \"b\" en la posicion 2 de la lista\n",
    "print(List2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yfPVTmDSK_Fz"
   },
   "outputs": [],
   "source": [
    "List2.insert( 4 , 10 )                # Agregar el valor de 10 en la posicion 4 de la lista\n",
    "print(List2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RRU26NyUK_F0"
   },
   "outputs": [],
   "source": [
    "List2.remove(10)                      # Quitar el valor de 1 de la lista\n",
    "print(List2 ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BQrbjI1BK_F0"
   },
   "outputs": [],
   "source": [
    "List2.reverse()                       # Invertir el orden de la lista\n",
    "print(List2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nWY2vNvQK_F0"
   },
   "outputs": [],
   "source": [
    "List = [10,130,14,1,16]\n",
    "List.sort()                           # Ordenar la lista\n",
    "print(List)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RtS_II0EK_F0"
   },
   "outputs": [],
   "source": [
    "idx = List.index(10)                  # Encontrar el indice del elemento que tiene valor 10 en la lista \n",
    "print(idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OAjbS1nJK_F1"
   },
   "outputs": [],
   "source": [
    "List = [10,130,14,1,10,16,19,10]\n",
    "idx =List.index(10,2)               # Encontrar el indice del elemento que tiene valor 10 en la lista \n",
    "print(idx)                          # despues de la posicion 2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nImsHRuHK_F1"
   },
   "source": [
    "## Challenge break\n",
    "### 6\n",
    "Crear una lista *lista_a* con los números  [1, 2, 3, 4, 20, 6, 7, 8, 9, 10], imprir y agregar el número 5 y quitar el 20, imprimir la lista\n",
    "\n",
    "Ordenar la lista *lista_a* de forma ascendente e imprimirla\n",
    "\n",
    "Encontrar el indice del elemento que tiene valor 1 en la lista "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "X1abA-WuK_F1"
   },
   "outputs": [],
   "source": [
    "# Respuesta\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vE2UUnYDK_F1"
   },
   "source": [
    "### 7\n",
    "Escribe tu nombre completo y separalo en una lista que contenga todos los elementos de tu nombre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "P1XkCxJmK_F1"
   },
   "outputs": [],
   "source": [
    "# Respuesta\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d1MH61i0K_F2"
   },
   "source": [
    "# Conjuntos: \n",
    "Coleccion desordenada de elementos unicos\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jgT2avOMK_F2"
   },
   "outputs": [],
   "source": [
    "basket = {'apple', 'eggs','banana', 'orange'}\n",
    "print(basket)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "--HLu8lHK_F3"
   },
   "outputs": [],
   "source": [
    "same = set(['apple', 'eggs','banana', 'orange' ])\n",
    "print(basket == same)\n",
    "print(type(same))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "T5fdfvLGK_F3"
   },
   "outputs": [],
   "source": [
    "same = set([ 'banana', 'eggs','apple','orange' ])\n",
    "print(basket == same)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bnuCHkHLK_F4"
   },
   "source": [
    "## Challenge break \n",
    "### 8\n",
    "Crear un conjunto \"C\" con todas las letras del diccionario en español, imprimir el conjunto \"C\"\n",
    "\n",
    "Contar los elementos de \"C\" e imprimir el tamaño de este conjunto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nN4gkxNYK_F4"
   },
   "outputs": [],
   "source": [
    "# Respuesta\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "j1XdhytcK_F4"
   },
   "source": [
    "## Diccionarios: \n",
    "Estructura de datos útil para guardar parejas ordenadas\n",
    "\n",
    "**(key, value)**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PJQYt4l4K_F5"
   },
   "outputs": [],
   "source": [
    "calories = {'apple': 52, 'banana': 89,'choco': 546}\n",
    "print(calories,type(calories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jJCoA6TbK_F5"
   },
   "outputs": [],
   "source": [
    "calories.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vTx4S7SJ604J"
   },
   "outputs": [],
   "source": [
    "calories[\"apple\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "d6KNOJU5K_F5",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for k, v  in calories.items():\n",
    "    print(k)\n",
    "    print(v)\n",
    "    if v < 80: \n",
    "        print(k,v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "i66sFPJRK_F5"
   },
   "outputs": [],
   "source": [
    "for k, v  in calories.items():\n",
    "    print(k)  if v >  500  else  None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "F8xBmd4SK_F5"
   },
   "outputs": [],
   "source": [
    "# Tuplas\n",
    "c = (0, 1, 2, 3, 'cuatro', 'cinco')\n",
    "print(c, type(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wGimi4EmK_F5"
   },
   "outputs": [],
   "source": [
    "print(c[0])      # Selecciona el primer elemento de la tupla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "He3QQffgK_F6"
   },
   "outputs": [],
   "source": [
    "print(c[5])      # Selecciona el último elemento de la tupla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ovHz-RsVK_F6"
   },
   "outputs": [],
   "source": [
    "c.append(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "e0St-Ac0K_F6"
   },
   "outputs": [],
   "source": [
    "# Operaciones básicas\n",
    "n_1 = 2\n",
    "n_2 = 3\n",
    "print('n_1 = {}, n_2 = {},\\nn_1 + n_2 = {}'.format(n_1,n_2,n_1 + n_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yBoHKTVbK_F6"
   },
   "outputs": [],
   "source": [
    "n_1 += n_2\n",
    "print('n_1 += n_2\\n=> n_1 = {}'.format(n_1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DZalXAIMK_F6"
   },
   "outputs": [],
   "source": [
    "n_1 = 2\n",
    "n_2 = 3\n",
    "print('n_1 = {}, n_2 = {}'.format(n_1, n_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Anjjp4aHK_F7"
   },
   "outputs": [],
   "source": [
    "print('n_2 / n_1 = {}'.format(n_2 / n_1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "K_WRBg5rK_F7"
   },
   "outputs": [],
   "source": [
    "print('n_2 // n_1 = {}'.format(n_2 // n_1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "iQdBxn0UK_F7"
   },
   "outputs": [],
   "source": [
    "print('n_1 ** n_2 = {}'.format(n_1 ** n_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Fly21bHyK_F7"
   },
   "outputs": [],
   "source": [
    "print('n_1 % n_2 = {} \\n'.format(n_2 // n_1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PRcG0v7AK_F7",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "s_1  = 'uno'\n",
    "s_2 = 'dos'\n",
    "print('s_1 = {}, s_2 = {},\\ns1 + s_2 = {}'.format(s_1,s_2,s_1 + s_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "igq8k77uK_F8"
   },
   "outputs": [],
   "source": [
    "s_1  = 1\n",
    "s_2 = 2.345\n",
    "print('s_1 = {}, s_2 = {},\\ns1 + s_2 = {}'.format(s_1,s_2,s_1 + s_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UTTR3fAKK_F8"
   },
   "source": [
    "## Challenge break\n",
    "### 9\n",
    "Crear un diccionario con nombre my_data que contenga:\n",
    "    \n",
    "    1. Nombres \n",
    "    2. Apellidos\n",
    "    3. E-mail\n",
    "    4. Edad\n",
    "    5. Grado de estudios\n",
    "    6. Formación\n",
    "    7. Gerencia\n",
    "    8. Antigüedad\n",
    "    9. Lenguajes de programación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_o7QuZ67K_F8"
   },
   "outputs": [],
   "source": [
    "# Respuesta\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2qbYMqGwK_F8"
   },
   "source": [
    "Crear un diccionaro \"D\" con todas las letras del diccionario en español y asignarles el número de letras, e.g. A tiene valor 1, B valor 2, etc\n",
    "\n",
    "Imprimir cada letra con su respectivo valor\n",
    "\n",
    "Seleccionar las letras de tu nombre y sumar los valores correspondientes a cada letra, imprimir tu nombre y el total de la suma\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tPHzeRm4K_F8"
   },
   "outputs": [],
   "source": [
    "# Respuesta\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7CuHKjh8K_F9"
   },
   "source": [
    "### Formatos de salida\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uCYOQjk5K_F9"
   },
   "outputs": [],
   "source": [
    "print('Flotante con 2 decimales: %.2f'%321.23576589)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xxjTQGj4K_F9"
   },
   "outputs": [],
   "source": [
    "print('Flotante con 2 decimales: {0:.2f} '.format(321.23576589))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VQx1rha9K_F9"
   },
   "outputs": [],
   "source": [
    "print('Flotante en notación exponencial con un decimal: {0:.1e}'.format(321.23576589))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dc2VkIihK_F-"
   },
   "source": [
    "## Challenge break\n",
    "### 10.1\n",
    "Crea una lista que se llame lista_vieja con los siguientes elementos [[1,1,1], [2,2,2],[3,3,3]] y busca su id de referencia en la memoria (usa el comando id()).\n",
    "\n",
    "Iguala la lista_vieja con otra lista que se llame lista_nueva y busca el lugar de referencia de la nueva lista\n",
    "\n",
    "Adiciona la lista [4] a la vieja lista e imprime ambas listas\n",
    "\n",
    "Prueba los comandos siguientes:\n",
    "\n",
    "    lista_vieja is lista_nueva\n",
    "\n",
    "    lista_vieja == lista_nueva\n",
    "\n",
    "¿Qué puedes concluir?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FIpcVKUEK_F-"
   },
   "outputs": [],
   "source": [
    "# Respuesta\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RSQo2Gu1K_F-"
   },
   "source": [
    "###  10.2\n",
    "Copia la vieja lista utilizando deep copy y nombrala lista_nueva_2 (importar librería copy, para copiar lista usar comando lista.copy())\n",
    "\n",
    "Imprime los id's de referencia de la vieja_lista y de la lista_nueva_2\n",
    "\n",
    "Adiciona la lista [5] en la lista_vieja e imprime lista_vieja y lista_nueva_2\n",
    "\n",
    "Prueba los comandos siguientes:\n",
    "\n",
    "    lista_vieja is lista_nueva_2\n",
    "\n",
    "    lista_vieja == lista_nueva_2\n",
    "\n",
    "¿Qué puedes concluir?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "v1R94zPUK_F-"
   },
   "outputs": [],
   "source": [
    "# Respuesta\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}