intro-python(ejercicios resueltos).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": 2,
   "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": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiplica ***a*** por ***b***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obten el residuo de la división entre ***a*** y ***b***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "res = a % b\n",
    "print(res)"
   ]
  },
  {
   "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": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.615773105863909"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "sqrt(a**2 + b**2)\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": 18,
   "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": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre_completo = \"{} {}\".format(nombre.title(), apellido.title())\n"
   ]
  },
  {
   "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": 22,
   "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": [
    "\n",
    "nombre_usuario = \"{}_{}\".format(nombre, apellido)\n",
    "\n",
    "print(\"Hola {}, tu usuario del sistema es '{}'. El password será enviado al correo 'ivan.ivanovski@email.com\".format(nombre.title(),nombre_usuario))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diccionarios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "usuario = {\n",
    "    'login': 'local_admin',\n",
    "    'nombre': 'Mario',\n",
    "    'apellido': ''\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Actualiza el valor referenciado con la llave `'apellido'` usando tu apellido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "usuario['apellido'] = 'Reyes'"
   ]
  },
  {
   "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": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mario.reyes@email.com\n"
     ]
    }
   ],
   "source": [
    "correo = '{}.{}@email.com'.format(usuario['nombre'].lower(), usuario['apellido'].lower())\n",
    "\n",
    "usuario['correo'] = correo\n",
    "\n",
    "print(usuario['correo'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indices y cortes (slicing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "numeros = list(range(1,101))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selecciona el elemento con el tercer elemento de la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 34,
     "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": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 38,
     "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": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 40,
     "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": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]"
      ]
     },
     "execution_count": 42,
     "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": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros[5:10:15]"
   ]
  },
  {
   "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": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "def area(b,a):\n",
    "    return b*a\n",
    "\n",
    "print(area(2,2))"
   ]
  },
  {
   "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": 82,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 3, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "def ordena(l):\n",
    "    l.sort()\n",
    "    return l\n",
    "\n",
    "lista = [3,2,4,6,3,1]\n",
    "lista_ordenada = ordena(lista)\n",
    "print(lista_ordenada)"
   ]
  },
  {
   "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": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compara(str1, str2):\n",
    "    if str1.lower() == str2.lower():\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "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": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "def calcula_factorial(numero):\n",
    "    factorial = 1\n",
    "    while numero != 1:\n",
    "        factorial *= numero\n",
    "        numero -= 1\n",
    "    return factorial\n",
    "\n",
    "print(calcula_factorial(5))"
   ]
  },
  {
   "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": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cara\n",
      "cruz\n",
      "cruz\n",
      "cara\n",
      "cruz\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "def lanzamiento_moneda():\n",
    "    if random.randrange(2) == 1:\n",
    "        return 'cara'\n",
    "    else:\n",
    "        return 'cruz'\n",
    "    \n",
    "print(lanzamiento_moneda())    \n",
    "print(lanzamiento_moneda())    \n",
    "print(lanzamiento_moneda())    \n",
    "print(lanzamiento_moneda())    \n",
    "print(lanzamiento_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": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cara', 'cara', 'cara', 'cruz', 'cruz']\n"
     ]
    }
   ],
   "source": [
    "def tira_n_monedas(x):\n",
    "    resultados = []\n",
    "\n",
    "    for x in range(0, x):\n",
    "        res = lanzamiento_moneda()\n",
    "        resultados.append(res)\n",
    "    return resultados\n",
    "        \n",
    "final = tira_n_monedas(5)\n",
    "print(final)"
   ]
  },
  {
   "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": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "def selecciona_ganador(opcion, num_lanzamientos, lanzamientos_requeridos):\n",
    "    res = tira_n_monedas(num_lanzamientos)\n",
    "    conteo_exitos = res.count(opcion)\n",
    "    if conteo_exitos >= lanzamientos_requeridos:\n",
    "        print (\"¡Ganaste!\")\n",
    "    else:\n",
    "        print (\"Lo siento, intenta de nuevo\")\n",
    "    print(\"Resultados: {}\".format(res))\n",
    "          \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "¡Ganaste!\n",
      "Resultados: ['cara', 'cruz', 'cara']\n"
     ]
    }
   ],
   "source": [
    "selecciona_ganador('cara', 3, 1)\n"
   ]
  },
  {
   "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": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "cuadrados = [ x**2 for x in range(0,10)  ]\n",
    "print(cuadrados)"
   ]
  },
  {
   "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": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 34, 68]\n"
     ]
    }
   ],
   "source": [
    "impares_17 = [ x for x in range(0,100) if (x%17==0 and x%2==0)  ]\n",
    "print(impares_17)\n"
   ]
  },
  {
   "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": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "cadena = 'hugo paco luis'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hugo', 'Paco', 'Luis']\n"
     ]
    }
   ],
   "source": [
    "cadena = cadena.split()\n",
    "cadena_mayusc = [x.title() for x in cadena]\n",
    "\n",
    "print(cadena_mayusc)"
   ]
  },
  {
   "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": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['impar', 'par', 'impar', 'par', 'impar', 'par', 'impar', 'par', 'impar']\n"
     ]
    }
   ],
   "source": [
    "par_impar = [ 'par' if x%2==0 else 'impar' for x in range(1,10) ]\n",
    "print(par_impar)"
   ]
  },
  {
   "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": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocales = ['a', 'e', 'i', 'o', 'u']\n",
    "test_string = 'hola mundo'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocales_2 = [ x.upper() if x in vocales else x for x in test_string ]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hOlA mUndO\n"
     ]
    }
   ],
   "source": [
    "print(''.join(vocales_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}