intro-python(ejercicios).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducción a Python \n",
    "---\n",
    "Este cuaderno de ejercicios complementa los temas vistoe en el notebook \"1.1 - Introduccion a Python\". Recuerda que además de contar con este notebook en `Jupyter` puedes consultar los métodos disponibles en cada objeto escribiendo un punto despues del nombre del objeto y presionando la tecla `Tab` de tu teclado. Tambien puedes ver la documentación de cada método presionando `Shift + Tab`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables y operadores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numéricos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Realiza las siguientes operaciones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 7\n",
    "b = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suma ***a*** más ***b***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "c = a + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiplica ***a*** por ***b***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "d = a * b\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obten el residuo de la división entre ***a*** y ***b***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "e = a % b\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calcula la hipotenusa del triangulo (***c***) usando la siguiente formula:\n",
    "\n",
    "$c=\\sqrt{a^2 + b^2}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.615773105863909\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "resultado = sqrt((a**2 + b**2))\n",
    "print(resultado)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cadenas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explora los métodos disponibles en las cadenas y realiza los siguientes ejercicios. Recuerda que en Jupyter puedes usar `shift + tab` para ver los metodos disponibles de un objeto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre = 'ivan'\n",
    "apellido = 'ivanovski'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando las variables ***nombre*** y ***apellido***, crea una nueva variable llamada ***nombre_completo***, esta debe de contener la cadena `'Ivan Ivanovski'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ivan Ivanovski\n"
     ]
    }
   ],
   "source": [
    "nombre_completo = nombre.title() + ' ' + apellido.title()\n",
    "print(nombre_completo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando una cadena como plantilla y las variables ***nombre*** y ***apellido*** genera la siguiente salida:\n",
    "```\n",
    "Hola Ivan, tu usuario del sistema es 'ivan_ivanovski'. El password será enviado al correo 'ivan.ivanovski@email.com'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola Ivan, tu usuario del sistema es 'ivan_ivanovski'. El password será enviado al correo 'ivan.ivanovski@email.com'\n"
     ]
    }
   ],
   "source": [
    "nombre_usuario = '{0}_{1}'.format(nombre, apellido)\n",
    "correo = '{0}.{1}@email.com'.format(nombre, apellido)\n",
    "\n",
    "cadena = \"Hola {0}, tu usuario del sistema es '{1}'. El password será enviado al correo '{2}'\".format(nombre.title(), nombre_usuario, correo)\n",
    "print(cadena)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diccionarios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'login': 'local_admin', 'nombre': 'Mario', 'apellido': ''}\n"
     ]
    }
   ],
   "source": [
    "usuario = {\n",
    "    'login': 'local_admin',\n",
    "    'nombre': 'Mario',\n",
    "    'apellido': '',\n",
    "    'edad': '',\n",
    "    'nacionalidad': '',\n",
    "}\n",
    "\n",
    "print(usuario)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Actualiza el valor referenciado con la llave `'apellido'` usando tu apellido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'login': 'local_admin', 'nombre': 'Mario', 'apellido': 'Rodríguez', 'edad': 32, 'nacionalidad': 'Mexicano'}\n"
     ]
    }
   ],
   "source": [
    "usuario['apellido'] = 'Rodríguez'\n",
    "usuario['edad'] = 32\n",
    "usuario['nacionalidad'] = 'Mexicano'\n",
    "\n",
    "print(usuario)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crea una nueva llave para almacenar el correo electronico. Usa los valores almacenados con las llaves ***nombre*** y ***apellido*** para generarlo siguiendo el formato: `nombre.apellido@email.com`.\n",
    "\n",
    "Nota: los correos electrónicos se escriben con minúsculas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mario.rodríguez@email.com\n"
     ]
    }
   ],
   "source": [
    "\n",
    "usuario['correo_electronico'] = '{}.{}@email.com'.format(usuario['nombre'].lower(), usuario['apellido'].lower())\n",
    "\n",
    "print(usuario['correo_electronico'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indices y cortes (slicing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n"
     ]
    }
   ],
   "source": [
    "numeros = list(range(1,101))\n",
    "print(numeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selecciona el elemento con el tercer elemento de la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selecciona el último elemento de la lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crea un corte de la lista `'numeros'` con los primeros 10 elementos de la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros[0:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crea un corte de la lista `'numeros'` con los números del 11 al 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros[10:20]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explora lo que sucede al utilizar dos operadores de corte siguiendo la sintaxis `numeros[x:y:z]`. \n",
    "\n",
    "Intenta obtener la siguiente lista utilizando un solo corte: \n",
    "```\n",
    "[11, 21, 31]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 21, 31]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros[10:40:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones y estructuras de control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Area:***  \n",
    "Crea una función que calcule el área de un rectángulo a partir de su base y su altura."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "def calcula_area(base, altura):\n",
    "    area = base * altura\n",
    "    return area\n",
    "\n",
    "base = 2\n",
    "altura = 5\n",
    "\n",
    "mi_area = calcula_area(base, altura)\n",
    "print(mi_area)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Función con listas:***  \n",
    "Completa la siguiente función para que ordene la lista que recibe como parámetro y regrese la lista ordenada. Pon atención en el resultado de la ejecución de la celda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 7, 5, 4, 2, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "lista = [7,2,5,2,4,1,7]\n",
    "\n",
    "def ordena_lista(lista):\n",
    "    lista.sort(reverse=True)\n",
    "    return lista\n",
    "    \n",
    "lista = ordena_lista(lista)\n",
    "print(lista)\n",
    "\n",
    "sorted(lista)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Comparación de cadenas:***  \n",
    "Crea una función que compare dos cadenas y te diga si son iguales ignorando mayúsculas y minúsculas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cadena_1 = 'MICADENAUNO'\n",
    "cadena_2 = 'micadenauno'\n",
    "\n",
    "def compara_cadenas(cadena_1, cadena_2):\n",
    "    if cadena_1.upper() == cadena_2.upper():\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "compara_cadenas(cadena_1, cadena_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Factoriales:***  \n",
    "Crea una función que calcule el factorial del numero que recibe.\n",
    "\n",
    "> El factorial de un entero positivo n, el factorial de n o n factorial se define en principio como el producto de todos los números enteros positivos desde 1 (es decir, los números naturales) hasta n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "print('calcula_factorial')\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Lanzamiento de monedas:***  \n",
    "Usando el paquete `random`, crea una fución que simule la acción de tirar una moneda. Debe de regresar de manera aleatoria los valores `'cara'` o `'cruz'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cara\n",
      "cara\n",
      "cara\n",
      "cruz\n",
      "cruz\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "def lanza_moneda():\n",
    "    if random.random() > .5:\n",
    "        return 'cara'\n",
    "    else:\n",
    "        return 'cruz'\n",
    "    \n",
    "print(lanza_moneda())\n",
    "print(lanza_moneda())\n",
    "print(lanza_moneda())\n",
    "print(lanza_moneda())\n",
    "print(lanza_moneda())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Más lanzamientos:***  \n",
    "Crea otra función que simule tirar n número de monedas y que regrese una lista con los resultados d ecada lanzamiento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cara', 'cara', 'cara', 'cara', 'cruz']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def lanza_numero_monedas(numero_intentos):\n",
    "    lista = []\n",
    "    for intento in range(numero_intentos):\n",
    "        lista.append(lanza_moneda())\n",
    "    return lista\n",
    "\n",
    "lanza_numero_monedas(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***¿Quién ganó?***  \n",
    "Ahora crea una función que acepte 3 argumentos.\n",
    "1. Selección de `cara` o `cruz`\n",
    "2. Número de lanzamientos a hacer\n",
    "3. Lanzamientos exitosos requeridos para ganar.\n",
    "\n",
    "Deberá de imprimir el resultado y la lista de lanzamientos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listas por comprensión"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Cuadrados:***  \n",
    "Crea una lista con el cuadrado de los números del 0 al 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Múltiplos impares de 17:***  \n",
    "Crea una lista que incluya los números múltiplos de 17 entre el 0 y el 100 que sean impares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Lista de nombres:***  \n",
    "A partir de la siguiente cadena genera una lista con nombres con uso correco de mayusculas y minusculas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "cadena = 'hugo paco luis'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Par o Impar:***  \n",
    "Una lista las palabras \"par\" e \"impar\" que coresponden a los números del 1 al 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hugo', 'juan', 'jorge']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x if x == 'hugo' else 'juan' if x == 'paco' else 'jorge' for x in cadena.split()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Usando cadenas:***  \n",
    "Una lista con los caracteres de la cadena `'hola mundo'`, las vocales deben de ir en minúsculas y las consonantes en mayúsculas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iteradores\n",
    "\n",
    "Crea una lista con varios elementos y despues iterala hasta imprimirlos todos.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generadores\n",
    "\n",
    "\n",
    "Crea una funcion llamada ***mi_generador*** con 3 sentencias ***yeld*** y después utilizala para imprimir sus resultados consecutivos.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Creando una clase nueva:***\n",
    "\n",
    "Crea una clase **Empleado** con los siguientes atributos: \"departamento, id, nombre\" posteriormente inicializa la instancia del empleado #323, Juan de Tecnologías de Información. \n",
    "\n",
    "Agrega un método a la clase que regrese su departamento en mayúsculas.\n",
    "\n",
    "Nota: Asegurate que la representación en string de esta instancia regrese todos sus datos de forma legible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Utilizando herancia:***\n",
    "\n",
    "\n",
    "Crea una clase **Director** que herede de empleado y tenga un metodo: \"presentar_equipo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Refactoriza tu método lanza_moneda para que el los empleados puedan lanzar monedas.\n",
    "\n",
    "2. Después crea una nueva instancia de empleado \"Juan\" que lanze una moneda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Consumo de APIs REST\n",
    "\n",
    "Utiliza el siguiente servicio para obtener información al azar de series de Netflix:\n",
    "\n",
    "https://api.reelgood.com/roulette/netflix?availability=onAnySource&content_kind=both&nocache=true\n",
    "\n",
    "1. Guarda cada serie con su: título, reseña y fecha de estreno en un diccionario y después crea una lista de 5 diccionarios.\n",
    "\n",
    "2. Utiliza compresión de listas para obtener el titulo de cada serie y crear una lista unicamente con los títulos.\n",
    "\n",
    "2. Ordena tu lista de diccionarios diccionario for fecha de estreno.\n",
    "\n",
    "3. Guarda los resultados en un archivo de texto.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(5):\n",
    "    serie = {}\n",
    "    pass"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}