BasicosPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 style = 'text-align:center'>\n",
    "Bienvenidos al curso de básicos de python!\n",
    "</h1>\n",
    "<center>\n",
    "<img src = 'https://scontent.fmex10-2.fna.fbcdn.net/v/t1.0-9/118343119_113233783831611_9219337719937477698_o.png?_nc_cat=102&_nc_sid=09cbfe&_nc_ohc=R-1ZQ2HIIS8AX8BJJQ-&_nc_ht=scontent.fmex10-2.fna&oh=903d344ae760a69e7fa26e9803825550&oe=5F9AA7D4' alt = 'DSC' height = '350' width = '550'>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>¿Qué es Python?</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='https://upload.wikimedia.org/wikipedia/commons/thumb/0/0a/Python.svg/1200px-Python.svg.png' alt='python-logo' height='200' width='200'></img>\n",
    "<p style='text-align: justify'>Python es un lenguaje de programación interpretado, multiparadigma </p>\n",
    "<p style='text-align: justify'>Esto significa que los programadores pueden adoptar el estílo que más les convenga, el lenguaje no obliga el uso de algún paradigma en específico. Estos pueden ser los siguientes:\n",
    "</p>\n",
    "\n",
    "   - Programación orientada a objetos\n",
    "    \n",
    "   - Programación imperativa\n",
    "    \n",
    "   - Programación funcional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <h2>Tipos de datos</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Tipo | Clase | Notas | Ejemplo\n",
    "| --  |  --   |--     | --\n",
    "|str|Cadena|Inmutable|'Cadena'\n",
    "|unicode|Cadena|Versión Unicode de str|u'Cadena'\n",
    "|list|Secuencia|Mutable, puede contener objetos de diversos tipos|[4.0, 'Cadena', True]\n",
    "|tuple|Secuencia|Inmutable, puede contener objetos de diversos tipo|(4.0, 'Cadena', True)\n",
    "|set|Conjunto|Mutable, sin orden, no contiene duplicados |set([4.0, 'Cadena', True]) \n",
    "|frozenset|Conjunto|Inmutable, sin orden, no contiene duplicados |frozenset([4.0, 'Cadena', True]) \n",
    "|dict|Mapping|Grupo de pares clave:valor | {'key1': 1.0, 'key2': False} \n",
    "|int|Número entero |Precisión fija, convertido en long en caso de overflow. | 42\n",
    "|long|Número entero |Precisión arbitraria | 42L ó 456966786151987643L \n",
    "|float|Número decimal |Coma flotante de doble precisión |3.1415927 \n",
    "|complex |Número complejo |Parte real y parte imaginaria | (4.5 + 3j) \n",
    "|bool |Booleano|Valor booleano verdadero o falso | True o False "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Operadores Aritméticos en python<h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Suma</h3>\n",
    "    <p>Dependiendo de que tipo de dato estemos ocupando el operador suma se comportara diferente forma\n",
    "    <br>Ejemplo: \n",
    "    <br>- 2 enteros\n",
    "    <br>- 2 float\n",
    "    <br>- 2 booleano\n",
    "    <br>- 2 cadenas de caracteres\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 enteros \n",
    "2 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 float\n",
    "1.3 + 1.4 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Booleano, es como sumar 1's y 0's\n",
    "True + True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 Cadenas de Caracteres\n",
    "'Hola' + ' Mundo'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "49\n",
      "544\n"
     ]
    }
   ],
   "source": [
    "#Van a haber veces en las que en el manejo de los datos, vayamos a encontrarnos con querer sumar un string con el número 5, con algun otro otro entero. Directamente nos daría un error, por lo que hacemos una conversión de tipos. Por ejemplo:\n",
    "print( int('5') + 44)\n",
    "print( str(5) + '44')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Resta</h3>\n",
    "    <p>Dependiendo de que tipo de dato estemos ocupando el operador resta se comportara diferente forma\n",
    "    <br>Ejemplo: \n",
    "    <br>- 2 enteros\n",
    "    <br>- 2 float\n",
    "    <br>- 2 booleano\n",
    "    <br>- 2 cadenas de caracteres\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 enteros \n",
    "7 - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 float\n",
    "1.3 - 1.4 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Booleano, es como restar 1's y 0's\n",
    "False - True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 Cadenas de Caracteresdara error ya que este operador no funciona con Strings\n",
    "#'Hola' - ' Mundo'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Multiplicacion</h3>\n",
    "    <p>Dependiendo de que tipo de dato estemos ocupando el operador multiplicacion se comportara diferente forma\n",
    "    <br>Ejemplo: \n",
    "    <br>- 2 enteros\n",
    "    <br>- 2 float\n",
    "    <br>- 2 booleano\n",
    "    <br>- 2 cadenas de caracteres\n",
    "    <br>- Multiplicar cadenas por un entero\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 enteros \n",
    "7 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 float \n",
    "7.12 * 2.21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 Booleanos, se comple la compuerta AND, con 0's y 1's\n",
    "print(True * True)\n",
    "print(True * False)\n",
    "print(False * True)\n",
    "print(False * False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 Cadenas de Caracteres\n",
    "#Esta operacion nos dara un error como el siguiente \n",
    "#TypeError: can't multiply sequence by non-int of type 'str'\n",
    "'Hola' * ' Mundo'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Podemos multiplicar cadenas de caracteres\n",
    "'Google '* 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Exponente</h3>\n",
    "    <p>Dependiendo de que tipo de dato estemos ocupando el operador exponente se comportara diferente forma\n",
    "    <br>Ejemplo: \n",
    "    <br>- 2 enteros\n",
    "    <br>- 2 float\n",
    "    <br>- 2 booleano\n",
    "    <br>- 2 cadenas de caracteres\n",
    "    <br>- Multiplicar cadenas por un entero\n",
    "    <br>- Notación científica\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 enteros \n",
    "7 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 float \n",
    "7.3 ** 2.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#También podemos tener expresiones como 40X10^4 para ahorrarnos escriir los ceros\n",
    "#Esto se puede hacer poniendo la letra E/e seguida de un numero que representa el exponente.\n",
    "print(40E-4)\n",
    "print(40e4)\n",
    "#Notamos que nos regresa un tipo de dato float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 Cadenas de Caracteres\n",
    "#Esta operacion nos dara un error como el siguiente \n",
    "#TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'\n",
    "'Hola' ** ' Mundo'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con 2 Booleanos, observemos que pasa\n",
    "print(True ** True)\n",
    "print(True ** False)\n",
    "print(False ** True)\n",
    "print(False ** False)\n",
    "#¡Recordemos que 0 a la 0 es 1, pero 0 a la 1, es 0!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>División</h3>\n",
    "    <p>El operador division regresa las veces que cabe el dividendo en el divisor de manera exacta teniedo en cuenta los decimales\n",
    "    <br>Ejemplo: \n",
    "    <br>- 2 enteros\n",
    "    <br>- 2 float\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Division de 2 enteros, si no es entera, automaticamente se vuelve de tipo float\n",
    "2 / 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Division de 2 float\n",
    "5.5 / 7.7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>División entera</h3>\n",
    "    <p>El operador division entera solo toma en cuenta cuantas veces entra el dividendo en el divisor sin tener en cuenta el residuo\n",
    "    <br>Ejemplo: \n",
    "    <br>- 2 enteros\n",
    "    <br>- 2 float\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Division de 2 enteros\n",
    "10 // 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Division de 2 float\n",
    "105.5 // 7.7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Modulo</h3>\n",
    "<p>Cuando hacemos la division exacta no tenemos en cuenta el residuo ,la operacion mudulo lo unico que no regresa es ese residuo por ejemplo en la division 10 / 3 el '3' cabe '3' en el 10 y sobra '1' , la operacion division entera nos regresara el '3' y el modulo nos regresara el '1'</p>\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Modulo de 2 enteros\n",
    "10 // 3 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Modulo de 2 enteros\n",
    "105.5 % 7.7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Operadores logicos </h3>\n",
    "<p>Son los distintos tipos de operadores con los que puede trabajar con valores booleanos, sigue las reglas del algebra de Boole</p>\n",
    "<ul>\n",
    "<li>Operador AND: Se puede declarar de dos maneras, escribiendo 'and' o '&'</li>\n",
    "<li>Operador OR: Se puede declarar de dos maneras, escribiendo 'or' o '|'</li>\n",
    "<li>Operador NOT: Se declara escribiendo \"not\"</li>\n",
    "</ul>\n",
    "<p>Nota: No incluir las comillas, estarias trabajando con una cadena, no con el operador</p>\n",
    "<center>\n",
    "<img src = 'https://image.slidesharecdn.com/circuitoscombinatoriosyalgebrabooleanaa-140217091808-phpapp01/95/circuitos-combinatorios-y-algebra-booleana-11-638.jpg?cb=1392628712'\n",
    "alt = 'DSC' height = '350' width = '550'>\n",
    "</center>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Con expresiones booleanas, se cumple la compuerta AND\n",
    "print(True and True)\n",
    "print(True and False)\n",
    "print(False & True)\n",
    "print(False & False)\n",
    "#Notosé que no imprime 1's y 0's como en la multiplicación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Compuerta OR\n",
    "print(True or True)\n",
    "print(True | False)\n",
    "print(False or True)\n",
    "print(False | False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compuerta NOT\n",
    "print(not(False))\n",
    "print(not(True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Variables</h3>\n",
    "    <p> Una variable se puede entender como una especie de caja en la que se puede guardar un valor (por ejemplo, un valor numérico), y se puede acceder a el cuando queramos, 'mandando a llamar' a ese contenedor. <br>Esa caja suele corresponder a una posición de memoria en la memoria del ordenador.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creamos un entero\n",
    "el_entero = 5\n",
    "#Creamos un float\n",
    "el_flotante = 15.5\n",
    "#Creamos una cadena de caracteres\n",
    "cadena = 'Hola nuevos programadores de python'\n",
    "#Los tipos de cada variable\n",
    "print(type(el_entero), type(el_flotante),type(cadena))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Estructuras de control</h3>\n",
    "<p>\n",
    "En python, al igual que en C/C++ y prácticamente cualquier lenguaje de programación, disponemos de estuctruras de control condicionales e iterativas, tales como If-else, For, While, sin embargo no se cuenta con Switch. <br>La indentación, define los bloques de código, no existen los corchetes.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### IF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=10\n",
    "y=20\n",
    "if x > y :\n",
    "  print(\" X es mayor \")#Se aprecia la indentación\n",
    "else :\n",
    "  print(\" Y es mayor \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Elif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=45\n",
    "if x > 500 :\n",
    "  print(\" X es mayor que 500 \")\n",
    "elif x < 500 :                 #elif es Else If\n",
    "  print(\" X es menor que 500 \")\n",
    "elif x == 500 :\n",
    "  print(\" X es 500 \")\n",
    "else :\n",
    "  print(\" X no es un número \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### While"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=10\n",
    "while True:\n",
    "  x+=1;\n",
    "  if x == 11:\n",
    "    continue\n",
    "  print (x)\n",
    "  if x==20:\n",
    "    break\n",
    "print(\"After Break\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>For</h3>\n",
    "<p>El ciclo for lo utilizamos para <b>iterar</b> entre los elementos de listas, diccionarios, arreglos, etc.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for index in range(5): #Range regresa una lista [0,1,2,3,4]\n",
    "    print(index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Funciones</h2>\n",
    "<p>Es un bloque de codigo reutilizable el cual puede recibir variables de entrada y devuelve algún valor procesado o realizar alguna operación (por ejemplo, puede imprimir un valor, pero no regresar un valor)<br>\n",
    "Se sintaxis es la siguiente:<br><br>\n",
    "def nombre_funcion(argumentos de entrada):<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;....<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;....<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;....<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;return valor/es_procesados #Opcional\n",
    "</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declaramos las funciones de suma y multiplicación\n",
    "def suma(a,b):\n",
    "    return a + b\n",
    "def multiplicación(a,b):\n",
    "    return a * b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Poniendo en práctica variables y funciones</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utilizamos las variables declaradas anteriormente\n",
    "# Para \"mandar a llamar\" a las funciones solo ponemos su nombre y los argumentos que recibe\n",
    "# Ej nombre_funcion(args)\n",
    "# Mandando a llamar las funciones e imprimiendo el resultado\n",
    "print( suma(el_entero, el_flotante) )\n",
    "print( multiplicación( el_flotante, el_entero) )\n",
    "print( multiplicación(cadena, el_entero) )\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tambien podemos guardar el resultado de una función en una variable\n",
    "resultado1 = suma(el_entero, el_flotante)\n",
    "resultado2 = multiplicación( el_flotante, el_entero)\n",
    "print(resultado1)\n",
    "print(resultado2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "Ahora un pequeño ejercicio, ¿Como le hariamos para hacer que \"cadena\"*el_entero tuviera un resultado como el que se muestra?<br>\n",
    "Hola nuevos programadores de python<br>\n",
    "Hola nuevos programadores de python<br>\n",
    "Hola nuevos programadores de python<br>\n",
    "Hola nuevos programadores de python<br>\n",
    "Hola nuevos programadores de python<br>\n",
    "<p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Vamos a ver si lo lograste\n",
    "#Primero tenemos que observar a \"cadena\", notamos que le debemos de hacer algo para agregar un salto de linea '\\n'\n",
    "#¿Que vimos anteriormente para poder concatenar cadenas?, Correcto, el simbolo de suma ( + )\n",
    "cadena_salto = cadena + '\\n' #Creamos una nueva variable, y a cadena le \"sumamos\" el salto de linea\n",
    "respuesta = multiplicación(cadena_salto, el_entero) #Mandamos a llamar a multiplicación\n",
    "print(respuesta)\n",
    "#Excelete\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Vamos a programar una función mas util, la chicharronera</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{equation*}\n",
    "x = \\frac {-b \\pm \\sqrt {b^2 - 4ac}}{2a}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chicharronera(a, b, c):\n",
    "    if ((b**2)-4*a*c) < 0:\n",
    "        print(\"La solución de la ecuación es con números complejos\")\n",
    "        return None, None\n",
    "    else:\n",
    "        x1 = (-b + (B**2 - (4*A*C))**0.5) / (2*a)\n",
    "        x2 = (-b - (B**2 - (4*A*C))**0.5) / (2*a)\n",
    "        return x1,x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creando variables\n",
    "A = 2\n",
    "B = 15\n",
    "C = 3\n",
    "# Probando la función\n",
    "x1, x2 = chicharronera(A,B,C)\n",
    "print(x1,x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 >Listas</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string\n",
      "133\n",
      "13.33333\n",
      "('estanoesuntuple', 10)\n",
      "{'manzana': 'verde', 'fresa': 'roja'}\n",
      "\n",
      "\n",
      " 133\n"
     ]
    }
   ],
   "source": [
    "#Las listas pueden almacenar todos los tipos de datos y se puede ingresar a ellas mediante un indice o iterando directamente en sus elementos\n",
    "variado = ['string', 133, 13.33333, ('estanoesuntuple', 10), {'manzana':'verde', 'fresa':'roja'}]\n",
    "for elemento in variado:\n",
    "    print(elemento)\n",
    "    \n",
    "print('\\n\\n', variado[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#También podemos investigar si hay un elemento en específico en la lista mediante la palabra reservada \"in\"\n",
    "# La sintaxis es la siguiente:\n",
    "print( 'string' in variado )\n",
    "print( 134 in variado )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Algunos metodos para trabajar con listas\n",
    "variado.append('Nuevo elemento') #Añade un nuevo elemento al final de la lista\n",
    "print(variado, '\\n')\n",
    "variado.pop(3)#Elimina al elemento en el índice indicado\n",
    "print(variado, '\\n')\n",
    "variado.reverse() #Iniverte el orden de la lista\n",
    "print(variado, '\\n')\n",
    "'''\n",
    "Otros métodos que existen son:\n",
    "lista.sort() ordena la lista ascendentemente\n",
    "lista.count( elemento ) devuelve un valor entero de las veces que se repite 'elemento\n",
    "lista.clear() vacía la lista\n",
    "\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Diccionarios</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Los diccionarios es una estructura de datos en la cual podemos guardar pares de valores.\n",
    "empleados = {\n",
    "    '104': {'Nombre' : 'Juan', 'Puesto' : 'Sistemas'},\n",
    "    '06' : {'Nombre' : 'Pedro', 'Puesto' : 'Gerente'}\n",
    "}\n",
    "print(empleados['104']['Nombre'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Para agregar una entrada al diccionario, en este caso, un nuevo empleado\n",
    "empleados['203'] = {'Nombre' : 'Eduardo', 'Puesto' : 'Mantenimiento'}\n",
    "print(empleados)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>List Comprehension</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Es una bondad de Python, llenar un diccionario o lista en una sola línea de código.\n",
    "\n",
    "#¿Cómo le hariamos para llenar una lista con todos los números impares hasta el 100?\n",
    "\n",
    "#Podriamos tener el siguiente código\n",
    "impares = [] #inicializamos la lista vacia\n",
    "for i in range(101): #recuerden que el for termina en n-1, o sea que el ultimo número en evaluar sería el 100\n",
    "    if i % 2 != 0:\n",
    "        impares.append(i)\n",
    "    else:\n",
    "        pass\n",
    "print(impares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#¡¡Ahora con List comprehension!!\n",
    "imp = [x for x in range(101) if x % 2 != 0]\n",
    "print(imp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problema de ejemplo\n",
    "#### Fizz Buzz\n",
    "Escribe un programa que recibe una entrada N y su salida es una lista con cadenas de texto siguiendo la siguiente regla.\n",
    "- Para los múltiplos de 3, la salida es \"Fizz\"\n",
    "- Para los múltiplos de 5, la salida es \"Buzz\"\n",
    "- Para los multiplos de 3 y 5, la salida es \"Fizz Buzz\"\n",
    "- Para cualquier otro número la salida es el mismo número N\n",
    "##### Ejemplo de salida\n",
    "\n",
    "```Python\n",
    "n = 5,\n",
    "\n",
    "Return:\n",
    "[\n",
    "    \"1\",\n",
    "    \"2\",\n",
    "    \"Fizz\",\n",
    "    \"4\",\n",
    "    \"Buzz\"\n",
    "]\n",
    "```  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def queEs(n) :\n",
    "    if n % 3 == 0 and n % 5 == 0:\n",
    "        return 'FizzBuzz'\n",
    "    elif n % 3 == 0 :\n",
    "        return 'Fizz'\n",
    "    elif n % 5 == 0 :\n",
    "        return 'Buzz'\n",
    "    else:\n",
    "        return str(n)\n",
    "\n",
    "n=5\n",
    "\n",
    "list = [queEs(num) for num in range(1,n+1)]\n",
    "\n",
    "print(list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Ahora vamos a graficar una función</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importamos la biblioteca de bokeh, numpy\n",
    "from bokeh.plotting import figure,output_notebook,show\n",
    "import numpy as np\n",
    "import math\n",
    "from numpy import pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src=https://www.monografias.com/trabajos106/elementos-trigonometria/img46.png>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>f(x)=A∙sin(kx+α)</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = figure()\n",
    "inicio = float(input(\"Dame el valor de inicio :\"))\n",
    "final = float(input(\"El numero des ciclos que quieres Graficar despues del inicio :\"))\n",
    "pasos = int(input(\"Dame el numero de datos que quieres graficar\"))\n",
    "x_vals = np.linspace( inicio, final, pasos )\n",
    "#print(x_vals)\n",
    "A = float(input('Dame la amplitud'))\n",
    "F = float(input('Dame una frecuencia'))\n",
    "Fa = float(input('Dame una fase'))\n",
    "y_vals = []\n",
    "print(len(x_vals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_vals = []\n",
    "for i in range(len(x_vals)):\n",
    "    val = A * (math.sin( x_vals[i] * F + Fa))\n",
    "    y_vals.append(val)\n",
    "    \n",
    "print(len(y_vals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.line(x_vals,y_vals,line_width=2)\n",
    "show(fig)"
   ]
  }
 ],
 "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",
<<<<<<< HEAD
   "version": "3.8.5"
=======
   "version": "3.8.3"
>>>>>>> upstream2/master
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}