Basicos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Básico de Python\n",
    "\n",
    "Esta sección, esta pensada para ser una breve introducción al lenguaje de programación *Python* con la intención de conocer los comandos básicos para hacer uso de sus estructuras de datos y las herramientas necesarias que se utilizaran durante el curso. No concideramos que sea un curso formal de programación, pues se pensó para que todos los comando de *Python* puedan ser ejecutados dentro de un notebook utilizando *Jupyter-lab* para tener una familiaridad con el lenguaje y así tener el conocimiento necesario para generar código que sea de utilidad en el análisis de datos. Para iniciar una sesión dentro de *jupyter-lab* es necesario tenerlo instalado (se describe en [Instalación](faltalink)) y ejecutar `jupyter-lab` dentro del ambiente donde se realizó la instalación. \n",
    "\n",
    "## Cadenas de símbolos (*String*)\n",
    "\n",
    "En todo curso que involucra algún lenguaje de programación empiezan con *Hello world*,  **este no es un curso de progeamación** pero vamos hacer muchas cosas similares por lo que vamos ha intentarlo. Es decir lo primero que deseamos es poder imprimir cosas, para tal proposito *Python* tiene la función `print()` esta función nos permite imprimir dentro de la terminal lo que deseamos. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!!\n"
     ]
    }
   ],
   "source": [
    "print('Hello world!!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hemos impreso nuestra primera línea usando *Python*, se puede ver que la función print no imprime las comillas, ¿que pasa si las quitamos?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-8-8dc91ed1efd9>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-8-8dc91ed1efd9>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    print(! Hola mundo !)\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "print(! Hola mundo !)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De aquí podemos hacer un par de observaciones, la función `print` acepta *strings* que son cadenas de símbolos. Para declarar que se empieza una cadena de símbolos, se hace utilizando `'` o bien `\"`, para declarar que hemos terminado la cadena la próxima `'` o `\"` (respectivamente) determina el fin. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!Hola mundo !\n"
     ]
    }
   ],
   "source": [
    "print('!Hola mundo !')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos hacer varias cosas con un *string* como es \"multiplicarlo\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola mundo Hola mundo \n"
     ]
    }
   ],
   "source": [
    "print('Hola mundo '*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola mundo Hola mundo Hola mundo Hola mundo \n"
     ]
    }
   ],
   "source": [
    "print('Hola mundo '*4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"sumarlo\" (juntarlo )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola mundojunto mal\n"
     ]
    }
   ],
   "source": [
    "print('Hola mundo' + 'junto mal')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola mundo junto mal\n"
     ]
    }
   ],
   "source": [
    "print('Hola mundo' + ' ' + 'junto mal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y otras operaciones, durante el curso veremos más operaciones que se puden hacer con las cadenas de símbolos.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "Dentro de los lenguajes de programación es necesario dar nombres a las cosas, en *pyhton* esta asignación se hace usando el símbolo de =.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a= 2\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La línea anterior asignó el valor 2 a la variable `a`. Como estamos dentro de un notebook dentro de *jupyter-lab* al llamar a la variable `a` imprime lo que se encuentra dentro de la variable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b= 5\n",
    "a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden realizar operaciones con las variables, si se tienen definidas estas operaciones entre tipos los tipos definidos. Como es el caso de las *strings* y los enteros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola mundoJupiter'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'Hola mundo'\n",
    "b = 'Jupiter'\n",
    "a+b\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola Jupiter'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0:5]+b\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A diferencia de otros lenguajes de programación como son *C++* o *Java*, en *Python* no es necesario declarar la variable ni determinar el tipo de variable. Usando la función `type` es posible ver que tipo de variable es. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "a= 5\n",
    "b= 'Hola'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es importante observar que las operaciones son de tipo específico. Por ejemplo el operando `+` aplicado a las variables de tipo *int* o *float* se aplica la función la suma, mientras que el caso de variables *string* funciona como la unión de las cadenas.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-162-ca730b97bf8a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como  se observa, el operando `+` no esta definido para usarse con *int* y *str*(*string*).\n",
    "\n",
    "Existen distintos tipos de variables como son:\n",
    "\n",
    "| Tipo | Descripción |\n",
    "|:-------|:-----------:|\n",
    "| *int*| Para guardar enteros ($\\mathbb{Z}$).|\n",
    "| *float*| Números de doble presición (ejemplo $2.34$).| \n",
    "|  *bool*| Valores verdadero(`True`) o falso (`False`). |\n",
    "| *str* | Cadenas de símbolos con codificación (UTF-8).|\n",
    "| *bytes*| Código ASCII en bytes.|\n",
    "| *None* | Valor de *Python* para nulo.|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los elementos en *Python* se pueden comparar, para saber si un elemento es igual a otro o si cumple con alguna condición específica. Las comparaciones entre los elementos de *Python* tienen que ser del mismo tipo, en algunos casos se permite hacer comparaciones entre tipos como *float* e *int*, sin embargo, lo que sucede en el fondo *Pyhton* cambia el tipo y se hace la comparacion.\n",
    "\n",
    "Las comparaciones se hacen usando `==` (iguales), `>` (mayor que), `<`(menor que),  `>= ` (mayor o igual que), `<=` (menor o igual que). El resultado de las comparaciones es siempre un *booleano* (tipo `bool`).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4==5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4>=5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'b' < 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'acs'=='acs'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4.5>4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'>' not supported between instances of 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-140-358f4a753f95>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m4\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;34m'a'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: '>' not supported between instances of 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "4 > 'a'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizando estas comparaciones es posible hacer algebra booleana utilizando los operadores lógicos implementados para ello, \n",
    "\n",
    "\n",
    "|Operador| Descripción |Ejemplo|\n",
    "|---------|-----------|-------|\n",
    "|`and`    | Si los dos operandos son `True` entonces la condición se vuelve `True`| `a and b`|\n",
    "| `or`    | Si alguno de los operandos es `True` entonces la condición se vuelve `True`| `a or b`|\n",
    "| `not`   | Se regresa el estado inverso del operando| `not a`|\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4== 4 and 5<4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4== 4 or 5<4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not 4==4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listas\n",
    "\n",
    "Las listas en python son especialmente útiles, pues nos permiten tener una estructura para el manejo de los datos y estructuras, para declarar una lista se utilizan `[ ]` y separando por `,` sus elementos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista= [1, 2, 3,4]\n",
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se le pueden añadir elementos a las listas utilizando el método `append` implementado detro de las lista, de la siguiente forma  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista.append(5)\n",
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se pueden remover elementos de la lista usando el método `pop`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = mi_lista.pop()\n",
    "print(a)\n",
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se observa el método `pop` remueve el último elemento en la lista y lo asigna a la variable `a`, no es necesario asignar el valor a una variable para remover el último elemento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista.pop()\n",
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acceder a los elementos de una lista en python se hace a través de `[]`, python enumera los elementos de las listas a partir de 0 para el primer elemento y de forma asendente, también es posible acceder a los elementos usando enteros negativos. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible cambiar el valor de los elementos "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 2, 3]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista[0]= 5\n",
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero para aumentar el tamaño de las listas es necesario usar el método `append` u otro. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list assignment index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-29-9d516150eccf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmi_lista\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mmi_lista\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mIndexError\u001b[0m: list assignment index out of range"
     ]
    }
   ],
   "source": [
    "mi_lista[3]= 5\n",
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para remover un elemento especifico utilizamos el método `remove`, el cual elimina la primera aparición de elemento que se desea remover."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 2]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista = [1,2,3, 4,2]\n",
    "mi_lista.remove(2)\n",
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible unir dos o más listas "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista = [1,2,3, 4]\n",
    "mi_lista_2= [3,4,5,6]\n",
    "mi_lista+mi_lista_2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los elementos de las listas pueden ser de distintos tipos\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 'Hola', 2.34, '4.56']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista = [1,2,4,'Hola', 2.34, str(4.56)]\n",
    "mi_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la lista generada en la linea anterior se hace notar la función *str()*, esta convierte lo que se encuentre dentro de los paréntesis a tipo  *string*, siempre y cuando la conversión sea posible. Como ejemplo se transforma el número flotante a un *string*. Este tipo de funciones también existen para *int* , *bool* o *float*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(2.75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partir de las listas podemos tomar \"rebanadas\" de estas. Para tal propósito, en las listas utilizamos `:` para indicar los rangos que se desean, como se ve en los ejemplos a continuación\n",
    "\n",
    "Tomemos los elementos de la posición 2 a la posición 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5]"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista= [1,2,3,4,5,6]\n",
    "mi_lista[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De la posición 0 a la posición antes que 4 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De la posición  3 hasta el último elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_lista[3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diccionarios \n",
    "\n",
    "Los diccionarios en *Python* nos ofrecen la posibilidad de hacer funciones entre conjuntos de forma directa, para la construcción de los diccionarios usamos `{ }` y `:`para determinar la regla de la relación entre los conjuntos. Veamos el siguiente ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_dict= {'a': 'Hola', 'b': 'jupyter', 'c':'mundo'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_dict['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'jupyter'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_dict['b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola mundo\n"
     ]
    }
   ],
   "source": [
    "print(mi_dict['a'], mi_dict['c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'d'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-50-b7e56094b7a8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmi_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'd'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'd'"
     ]
    }
   ],
   "source": [
    "mi_dict['d']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función de los diccionarios es regresar los valores que se le asignan a cada elemento, a los elementos antes de `:` se les denomina *keys* (llave) y a los que se encuentran después se les denomina *values* (valor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['a', 'b', 'c'])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['Hola', 'jupyter', 'mundo'])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_dict.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se desea añadir una pareja llave-valor al diccionario, se puede hacer directamente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_dict[3]= 'luna'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'luna'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_dict[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'Hola', 'b': 'jupyter', 'c': 'mundo', 3: 'luna'}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para eliminar una pareja llave-valor utilizamos el método `pop`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'Hola', 'c': 'mundo', 3: 'luna'}"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_dict.pop('b')\n",
    "mi_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se desea añadir más de un elemento al diccionario o añadir todo un diccionario a uno ya exixtente esto se puede hacer usando el método `update` y otro diciionario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_dict.update({'e': 'marte', 3:'casa', 2:'Hola'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'Hola', 'c': 'mundo', 3: 'casa', 'e': 'marte', 2: 'Hola'}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es importante recalcar que en los diccionarios puede haber llaves que tengan el mismo valor pero no llaves iguales "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'jupyter', 'b': 'mundo'}"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_dic_2= {'a': 'Hola', 'b': 'mundo', 'a': 'jupyter'}\n",
    "mi_dic_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso el diccionario asigna a la llave el último valor asignado.  Aunque Python nos permite tener como llaves (*keys*) cualquier tipo de objeto es preferible utilizar elementos que sean *hashables* como lo son *int*, *float* o *strings*, hay ciertas estructuras o valor en python que nos son de esta clase de elementos. La idea es que este tipos de estructuras se les puede dar un cierto \"nombre\" para identificar a los elementos, una explicación más detallada de lo que son los elemenntos *hashable* esta fuera del alcance de este curso.\n",
    "\n",
    "\n",
    "### Tuplas \n",
    "\n",
    "Otra estructura importante en *Python* son las \"tuplas\", estos objetos nos permiten almacenar valores como *int*, *float*  o *strings* de forma similar a una notación vectorial (como coordenadas). Para declarar a una tupla se hace con `()` y se separa a los elementos usando `,`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 'a')"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tu= (1,2,3,'a') \n",
    "tu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una de las propiedades importante que distingue a las *tuplas* de las listas, es que las tuplas son objetos inmutables. Es decir, éstas no pueden ser modificadas una vez que fueron declaradas, manteniendo la integridad de los datos que contienen. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tu[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-64-4192deae61b8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtu\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "tu[0]= 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen ciertas operaciones que se pueden realizar con las tuplas, si sumamos (`+`) tuplas el resultado es concatenar las tuplas, si multiplicamos por un entero $n$  el resultado es la tupla concatenada $n$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "tu_2= (4,5,6,'b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 'a', 4, 5, 6, 'b')"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tu+tu_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 'a', 1, 2, 3, 'a')"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tu*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conjuntos\n",
    "\n",
    "Los conjunto en *python* nos permiten almacenar conjuntos de distintos elementos, como su palabra lo dice, los conjuntos son conjunto en el sentido matemático, es decir, podemos hacer las operaciones usuales de conjuntos como son unión, intersección, diferencia (resta), diferencia simétrica, añadir elementos etc. Para declarar un conjunto se utiliza `{}` separando sus elementos por `,` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(2, 4), 1, 2, 3, 4, 5, '5', 6, 7, 8}"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conjunto_1= {1,2,3,4,5,6,7,8,7,6,5, '5', (2,4)}\n",
    "conjunto_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para añadir elementos al conjunto se puede hacer usando el método `add`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(2, 4), 1, 2, 3, 4, 5, '5', 6, 7, 8, 'li'}"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conjunto_1.add('li')\n",
    "conjunto_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si deseamos obtener el conjunto de una estructura que contiene datos como pueden ser listas, tuplas o diccionarios se puede hacer a través de la función `set`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "con_lista= set(mi_lista)\n",
    "con_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las operaciones entre conjuntos se hacen a través de los métodos implementados en el objeto, utilizando como argumento otro conjunto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "conjunto_2= {'a', 'b', 'c', '2', 6,8, 15}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(2, 4), 1, 15, 2, '2', 3, 4, 5, '5', 6, 7, 8, 'a', 'b', 'c', 'li'}"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conjunto_1.union(conjunto_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(2, 4), 1, 2, 3, 4, 5, '5', 7, 'li'}"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conjunto_1.difference(conjunto_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{6, 8}"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conjunto_1.intersection( conjunto_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Condicionales y ciclos\n",
    "\n",
    "Ya hemos visto que se pueden comparar elementos en *Python*, esto nos permite diferenciar entre los distintos elementos, en cierta estructura como pueden ser diccionarios, listas o tuplas.\n",
    "\n",
    "Las estructuras de control son una de las principales herramientas en lenguajes de programación, estas nos permiten estableces condiciones para poder tomar desiciones. Las estructuras de control que usaremos  con mayor frecuencia son `if` `else`, `for` , `while`. Estas estructuras se declaran usando la palabra seguida de una condición logica que se debe de cumplir y `:`, en la siguiente linea se indenta (con un número fijo de espacios o con *tab* ) y se escribe la linea de código a ejecutar. \n",
    "\n",
    "`if x == 4:\n",
    "    print('Es cuatro')`\n",
    "    \n",
    "#### if \n",
    "\n",
    "La estructura más utilizada es la estructura `if else` en esta se da una condición lógica, si la condición se cumple entonces se ejecuta el código que se encuentra indentado, si no se cumple la condición puede continuar la ejecución del código donde no esta indentado. La estructura `if` permite dos condicionales más, `elif` y `else`. `elif` permite añadir un condicional más a la estructura y `else` se ejecuta si ninguna de las condiciones se cumple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "x= 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Es cuatro\n"
     ]
    }
   ],
   "source": [
    "if x == 4:\n",
    "    print('Es cuatro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "x= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Se termino la estructura\n"
     ]
    }
   ],
   "source": [
    "if x == 4:\n",
    "    print('Es cuatro')\n",
    "print('Se termino la estructura')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No es cuatro\n",
      "Se termino la estructura de control\n"
     ]
    }
   ],
   "source": [
    "if x == 4:\n",
    "    print('Es cuatro')\n",
    "else:\n",
    "    print('No es cuatro')\n",
    "print('Se termino la estructura de control')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No es cuatro y es mayor que 10\n",
      "Se termino la estructura de control\n"
     ]
    }
   ],
   "source": [
    "x= 12\n",
    "if x == 4:\n",
    "    print('Es cuatro')\n",
    "elif x>4 and x < 10:\n",
    "    print('Es mayor que 4')\n",
    "else:\n",
    "    print('No es cuatro y es mayor que 10')\n",
    "print('Se termino la estructura de control')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For \n",
    "\n",
    "La estructura de control `for` se utiliza para hacer cíclos sobre los elementos dentro de una estructura de datos. En el caso de python lo usual es aplicar cierto código a los elementos.\n",
    "\n",
    "Para declarar los ciclos `for ` se utiliza la la palabra `for` el nombre de una variable, que nos servirá para referirnos al elemento dentro del ciclo, seguido por la palabra `in` y la estructura sobre la cual deseamos que se haga el ciclo terminado la línea con `:`. Al igual que con `if`, el código que se desea ejecutar dentro del ciclo debe estar en una nueva línea indentada con un cierto número de espacios o bien con un número fijo de tabulados (\"tabs\"). El ciclo se termina cuando la línea del código a ejecutar esta en la misma línea que la palabra `for`.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numero  2\n",
      "Numero  4\n",
      "Numero  6\n",
      "Numero  8\n",
      "Numero  10\n",
      "Se acabo el ciclo\n"
     ]
    }
   ],
   "source": [
    "lista= [1,2,3,4,5]\n",
    "for i in lista:\n",
    "    print('Número ', i*2)\n",
    "print('Se acabo el ciclo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen otro tipos de estructuras implementadas dentro de *python* que podemos utilizar para crear ciclos o para utilizarlas en otros casos como `range`, se puede utilizar esta función para generar los cíclos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "for j in range(3, 15):\n",
    "    print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " #### while\n",
    " \n",
    "La estructura  `while` es similar a la estructura de control `for`, esta nos permite ejecutar el código deseado dentro de un ciclo mientras se cumpla una condición determinada. Cuando dicha condición ya no se cumple entonces se sale del ciclo. Para declarar la estructura de control se hace a través de la palabra `while`, una condición que se debe de cumplir (True) para entrar en el ciclo y `:` al igual que en las estructuras de control anteriores, en una nueva línea indentada por un número fijo de espacios o tabulaciones se escribe el código a ejecutar. El ciclo termina en donde la nueva línea de código se encuentra indentada a la par de la palabra `while`. \n",
    "`\n",
    "while x <= 3: \n",
    "    print(x , 'es menor o igual que 3')\n",
    "    x += 1\n",
    "`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 es menor o igual que 3\n",
      "1 es menor o igual que 3\n",
      "2 es menor o igual que 3\n",
      "3 es menor o igual que 3\n",
      "termino el ciclo\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x <= 3: \n",
    "    print(x , 'es menor o igual que 3')\n",
    "    x += 1\n",
    "print('termino el ciclo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La diferencia entre el `for`y `while` radica en que en `for` se sabe que el número de veces que se ejecutara el ciclo, mientras que en `while` el ciclo se seguirá ejecutando mientras se cumpla la condición. Por esta razón no se recomienda usar esta estructura de control cuando se emnpieza a programar, debido a que se pueden cometer errores con facilidad y generar ciclos infinitos. Cuando se use esta estructura, se recomienda estar seguro de la condición del ciclo no sea infinita al menos que así se desee.   \n",
    "\n",
    "## Funciones\n",
    "\n",
    "Las funciones son bloques de código para reutilizar, adicionalmente esto nos ayuda a dividir el código en distintos bloques lo cual ayuda a la lectura, comprensión, y limpieza  del código. Para declarar una función se hace usando la palabra `def` seguida del nombre de la función con `()` encerrando los parámetros de la función terminando con `:`. En una nueva línea, y al igual que con las estructuras de control, para definir el código que se ejecuta dentro de la función este se encuentra indentado usando un número fijo de espacios o un número fijo de tabulares la función termina usando la palabra `return` o cuando el indentado se encuentra a la par de la palabra `def`.\n",
    "\n",
    "`\n",
    "def imprime_saludo():\n",
    "    print('Que bueno que estoy aprendiendo Python')\n",
    "    return \n",
    "`\n",
    "El código que contiene la función sólo se ejecuta cuando se hace un llamado a la funcíon, esto se hace simplemente escribiendo el nombre de la función y poniendo entre parentesis los párametros que se le pasan a ésta.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [],
   "source": [
    "def imprime_saludo():\n",
    "    print('Que bueno que estoy aprendiendo Python')\n",
    "    return \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Que bueno que estoy aprendiendo Python\n"
     ]
    }
   ],
   "source": [
    "imprime_saludo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para que la función utilice argumentos, estos se declaran entre los paréntesis cuando se define la función. Para hacer referencia en el código a ejecutar dentro de la función, se hace con el nombre declarado entre los paréntesis. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hola_tu( nombre):\n",
    "    print('Hola ', nombre, ' que bueno  estas aprendiendo Python')\n",
    "    return \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola  Miguel  que bueno  estas aprendiendo Python\n"
     ]
    }
   ],
   "source": [
    "hola_tu( 'Miguel')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las funciones pueden (o no) regresar objetos, los cuales muchas veces son *strings*, números o cosas mucho más complejas. Para que la función regrese un objeto es necesario escribir la variable que contiene dicho objeto despues de la palabra `return`. El objeto que se regresa de la función tiene que ser asignado a una variable esta asignación se hace utilizando la asignación normal en ptython `=`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hola_tu_2(nombre):\n",
    "    print('Hola ', nombre, ' que bueno  estas aprendiendo Python')\n",
    "    ret = 'Te va ayudar mucho'\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola  Miguel  que bueno  estas aprendiendo Python\n",
      "Te va ayudar mucho\n"
     ]
    }
   ],
   "source": [
    "mi_nom= 'Miguel'\n",
    "que= hola_tu_2(mi_nom) ### Se llama a la función \n",
    "print(que) ## Ver que hay en la variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es recomendable y una buena práctica escribir un pequeño texto que nos ayude a describir para que sirve la función, esto se hace usando `\"\"\"` o `'''` y se cierra el texto con `\"\"\"` o `'''` respectivamente. Lo que se escribe ayuda a la reutilización del código tanto para la persona que desarrollando la función y como documentación del código desarrollado.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hola_tu_2(nombre):\n",
    "    \"\"\"Imprime el nombre con una frase y regresa un agradecimiento  que es un string\"\"\"\n",
    "    print('Hola ', nombre, ' que bueno  estas aprendiendo Python')\n",
    "    ret = 'Te va ayudar mucho'\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones implementadas en Python\n",
    "\n",
    "Existen muchas funciones implentadas en *Python* que nos ayudan a resolver tareas comunes necesarias a la hora de programar, el conocer estas funciones nos ayuda a que desarrollar de forma más rápida y que la ejecución sea más eficiente y veloz pues la funciones en la mayoria de los casos se encuentran optimizadas. \n",
    "\n",
    "El enlistar todas las funciones que se encuentran implementadas dentro de *pyhton* se encuentran fuera del alcance de este curso, pero se considera enlistar las que se consideraron de mayor útilidad para el curso, a continuacion se dan ejemplos de algunas de estas funciones. \n",
    "\n",
    "#### Range\n",
    "\n",
    "La función  `range` nos permite definir un intervalo de números enteros con un mínimo, un máximo y el tamaño de incremento entre uno y otro. Se puede omitir el mínimo y el incremento, el comportamiento por defecto es tomar el mínimo como 0 y el incremento como 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "8\n",
      "11\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "for i in range(5, 15, 3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### enumerate\n",
    "La función `enumerate` enumera sobre un objeto iterable y regresa una tupla, donde la primera entrada es el entero la posición en el objeto iterable y la segunda es el elemento iterable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'diez')\n",
      "(1, 'nueve')\n",
      "(2, 'ocho')\n",
      "(3, 'siete')\n",
      "(4, 'seis')\n",
      "(5, 'cinco')\n",
      "(6, 'cuatro')\n",
      "(7, 'tres')\n",
      "(8, 'dos')\n",
      "(9, 'uno')\n"
     ]
    }
   ],
   "source": [
    "lista_1= ['diez', 'nueve', 'ocho', 'siete', 'seis', 'cinco', 'cuatro', 'tres', 'dos', 'uno']\n",
    "for i in enumerate(lista_1):\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Zip\n",
    "La función `zip` nos permite fusionar dos objetos iterables en un conjunto de tuplas donde cada entrada de la tupla corresponde a un elemento de las listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'diez')\n",
      "('b', 'nueve')\n",
      "('c', 'ocho')\n",
      "('d', 'siete')\n",
      "('e', 'seis')\n",
      "('f', 'cinco')\n",
      "('g', 'cuatro')\n",
      "('h', 'tres')\n",
      "('i', 'dos')\n"
     ]
    }
   ],
   "source": [
    "lista_1= ['diez', 'nueve', 'ocho', 'siete', 'seis', 'cinco', 'cuatro', 'tres', 'dos']\n",
    "lista_2 = list('abcdefghij')\n",
    "res =zip(lista_2, lista_1)\n",
    "for j in res:\n",
    "    print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### list\n",
    "`list` nos permite crear listas sobre objetos iterables, si no se pasa ningún argumento entonces `list` regresa una lista vacía."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '2', '3', '4', '5', '6', '7']"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list('1234567')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### list \n",
    "Regresa la lontgitud del objeto "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lista_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(conjunto_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones cast\n",
    "\n",
    "Las funciones `int` , `float`, `str` y `bool` convierten a lo que se pasa como argumento en un entero, punto flotante, cadena de símbolos o un boleano respectivamente. \n",
    "\n",
    "\n",
    "### max, min\n",
    "De un objeto iterable regresa el máximo o el mínimo respectivamente.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max([1,4,6,7,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min({1,3,4,3,5,6,5,7})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'k'"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(list('abcdefghijk'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### set\n",
    "De un objeto iterable regresa el conjunto, si no se pasa ningun argumento regresa un conjunto vacío."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'c', 'd', 'e', 'f', 'r', 's', 't'}"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(list('abcdesftredfredfre'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### abs\n",
    "Regresa el valor absoluto del argumento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.8"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-5.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### any \n",
    "Regresa `True`de un objeto iterable si al aplicar `bool` alguno de elementos regresa `True`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "any([0, None, False ])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "any([0, None, False, 'a' ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### all \n",
    "Regresa `True` si todos los elementos de un objeto iterable regresan `True` al aplicar `bool`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all([0, None, False, 'a' ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all([1,2,3,4,5,6])"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}