1_ABC_Python_github.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "---\n",
    "<span style=\"color:blue\">Clase 1: ABC de Python</span>  \n",
    "Jesus Antonio Alvarado Huayhuaz  \n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducción  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visión general"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__¿Por qué aprender a programar será útil en mis proyectos de Ciencia y Tecnología?__  \n",
    "\n",
    "<div class=text-justify>Programar, o escribir programas, es una actividad enriquecedora porque ejercita nuestra creatividad, nos ayuda a visualizar situaciones desde diferentes perspectivas, a optimizar vías de solución y por supuesto, nos ayuda a automatizar operaciones repetitivas, entre muchas otras ventajas. Los proyectos de ciencia y tecnología requieren del estado del arte de nuestra temática, planteamiento de hipótesis, experimentación, tratamiento de datos, discusión de resultados, predicciones de nuevos resultados, etc., por ello, implementar la programación potenciará nuestras exploraciones.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__¿Cual fue la palabra más repetida del párrafo anterior?__  \n",
    "Esta tarea puede ser tediosa para nosotros, sin embargo, es la especialidad del computador..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b>Ejemplo 1:</b> La palabra más repetida</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No es necesario profundizar en el siguiente código en estos momentos, esto será abordado con detalle más adelante. Para ejecutar el siguiente programa podemos guardar el párrafo en cuestión como ej0 (sin extensión) en la misma carpeta donde esta este manual en formato ipynb."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "name = input('Nombre del archivo:')\n",
    "handle = open(name, 'r')\n",
    "counts = dict()\n",
    "\n",
    "for line in handle:\n",
    "    words = line.split()\n",
    "    for word in words:\n",
    "        counts[word] = counts.get(word, 0) + 1\n",
    "\n",
    "bigcount = None\n",
    "bigword = None\n",
    "for word, count in list(counts.items()):\n",
    "    if bigcount is None or count > bigcount:\n",
    "        bigword = word\n",
    "        bigcount = count\n",
    "\n",
    "print(f\"La palabra que más se repitió fue '{bigword}' y se mencionó {bigcount} veces\")\n",
    "#podemos insertar el archivo llamado ej0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora veremos cómo están constituidas las máquinas que lo ejecutan."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arquitectura Hardware"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta compuesto por:\n",
    "\n",
    "La **Unidad Central de Procesamiento (o CPU)** es el componente de la computadora encargado del “¿qué hago ahora?”. Si tu equipo está dentro de la clasificación de 3.0 Gigahercios, significa que la CPU preguntará “¿Qué hago ahora?” tres mil millones de veces por segundo.\n",
    "\n",
    "La **Memoria Principal** se usa para almacenar la información que la CPU necesita de forma inmediata. La memoria principal es casi tan rápida como la CPU. Pero la información almacenada en la memoria principal desaparece cuando se apaga el equipo.\n",
    "\n",
    "La **Memoria Secundaria** también se utiliza para almacenar información pero a \"largo plazo\". La ventaja de la memoria secundaria es que puede almacenar la información incluso cuando el equipo está apagado. Algunos ejemplos de memoria secundaria serían las unidades de disco o las memorias flash (que suelen encontrarse en los pendrives USB y en los reproductores de música portátiles).\n",
    "\n",
    "Los **Dispositivos de Entrada y Salida** son: la pantalla, teclado, ratón, micrófono, altavoz, touchpad, etc. Incluyen cualquier modo de interacción con una computadora.  \n",
    "\n",
    "Las **Conexiones de Red** se pueden entender como un lugar donde almacenar y recuperar datos de forma lenta que puede no estar siempre “activa”. Así que, en cierto sentido, la red no es más que un tipo de Memoria Secundaria más lenta y a veces poco fiable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"imagenes/imagen1.PNG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<img src=\"imagenes/imagen2.png\">  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Zen de Python</b> \n",
    "\n",
    "Bello es mejor que feo.  \n",
    "Explícito es mejor que implícito.  \n",
    "Simple es mejor que complejo.  \n",
    "Complejo es mejor que complicado.  \n",
    "Plano es mejor que anidado.  \n",
    "Espaciado es mejor que denso.  \n",
    "La legibilidad es importante.  \n",
    "Los casos especiales no son lo suficientemente especiales como para romper las reglas.  \n",
    "Sin embargo la practicidad le gana a la pureza.  \n",
    "Los errores nunca deberían pasar silenciosamente.  \n",
    "A menos que se silencien explícitamente.  \n",
    "Frente a la ambigüedad, evitar la tentación de adivinar.  \n",
    "Debería haber una, y preferiblemente solo una, manera obvia de hacerlo.  \n",
    "A pesar de que eso no sea obvio al principio a menos que seas Holandés.  \n",
    "Ahora es mejor que nunca.  \n",
    "A pesar de que nunca es muchas veces mejor que *ahora* mismo.  \n",
    "Si la implementación es difícil de explicar, es una mala idea.  \n",
    "Si la implementación es fácil de explicar, puede que sea una buena idea.  \n",
    "Los espacios de nombres son una gran idea, ¡tengamos más de esos!  \n",
    "</br>    \n",
    "[\"import this\"]\n",
    "</br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=text-justify>Python es uno de los lenguajes de programación dinámicos más populares que existen entre los que se encuentran Java, Javascript, Go y C#. Aunque es considerado a menudo como un lenguaje \"scripting\", es realmente un lenguaje de propósito general. En la actualidad, Python es usado para practicamente todo, desde simples \"scripts\", hasta grandes servidores web que proveen servicio ininterrumpido 24×7. Es utilizado para la programación de interfaces gráficas y bases de datos, programación web tanto en el cliente como en el servidor (véase Django o Flask) y \"testing\" de aplicaciones. Además tiene una amplia aceptación por científicos que hacen aplicaciones para las supercomputadores más rápidas del mundo y por los niños que recién están comenzando a programar.</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=text-justify>La historia del lenguaje de programación Python se remonta hacia finales de los 80s y principio de los 90s, su implementación comenzó en diciembre de 1989 cuando en Navidad Guido Van Rossum que trabajaba en el (CWI) (un centro de investigación holandés de carácter oficial que, entre otras cosas, actualmente alberga la oficina central del W3C) decidió empezar el proyecto como un pasatiempo dándole continuidad al lenguaje de programación ABC del que había formado parte del equipo de desarrollo en el CWI, dicho lenguaje se enfocaba en ser fácil de usar y aprender manteniendo potencia en su desempeño pero el hardware disponible en la época de su creación hacía difícil su uso y el proyecto no trascendió como se esperaba. Van Rossum es por tanto el autor principal de Python y continúa ejerciendo un rol central decidiendo la dirección del lenguaje, en la comunidad de Python se le conoce como Benevolente Dictador Vitalicio (en inglés: Benevolent Dictator for Life, BDFL). El nombre \"Python\" viene dado por la afición de Van Rossum al grupo Monty Python.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Palabras reservadas__  \n",
    "\n",
    "\n",
    "En Python 3.7, disponemos de 35:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"imagenes/miau.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Figura 1. Conversando con python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "help(\"keywords\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b>Ejemplo 2:</b> ¿Será una palabra reservada? </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reserv = [\"False\",\"class\",\"from\",\"or\",\"None\",\"continue\",\"global\",\"pass\",\"True\",\"def\",\"if\",\"raise\",\"and\",\"del\",\"import\",\"return\",\"as\",\"elif\",\"in\",\"try\",\"assert\",\"else\",\"is\",\"while\",\"async\",\"except\",\"lambda\",\"with\",\"await\",\"finally\",\"nonlocal\",\"yield\",\"break\",\"for\",\"not\"]\n",
    "len(reserv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palabrita = input(\"Qué palabra deseas consultar? \")\n",
    "\n",
    "if (palabrita in reserv):\n",
    "    print(\"La palabra está reservada por Python\")\n",
    "else:\n",
    "    print(\"No, no está reservada por Python\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "35 palabras reservadas, son relativamente pocas, pero cada vez que sean usadas servirán unicamente para la tarea creada. Nosotros podemos crear nuestras propias palabras con significado, que llamaremos *variables*. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b>Ejemplo 3:</b> Masa molecular del agua</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variables: masa_hidrogeno y masa_oxigeno\n",
    "masa_hidrogeno = 1.001\n",
    "masa_oxigeno = 15.999"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "masa_agua = masa_hidrogeno*2 + masa_oxigeno\n",
    "print(f\"la masa molecular del agua es {masa_agua}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Interpretar y compilar**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=text-justify>Como se mencionó Python es un <span style=\"color:magenta\">lenguaje de alto nivel</span>, como por ejemplo Java, C++, PHP, Ruby, Basic, Perl, JavaScript, y muchos más, sin embargo, el hardware que se encuentra dentro del CPU solo \"entiende\" un lenguaje llamado lenguaje de máquina o código\n",
    "máquina. El código máquina es muy simple y pesado de escribir, ya que está representado en su totalidad por solamente ceros y unos: \n",
    "\n",
    ".</div> \n",
    "</br>\n",
    "> 0010100011101001001010100000011  \n",
    "> 11100110000011101010010101101101  \n",
    "> ...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=text-justify>Como muy pocos programadores escriben en código máquina, Python, Javascript funcionan como traductores. Dado que el código máquina está ligado al hardware de la máquina que lo ejecuta, ese código no es portable (trasladable) entre equipos de  diferente tipo. Los programas escritos en lenguajes de alto nivel pueden ser trasladados entre distintas máquinas usando un intérprete diferente en cada una de ellas, o recompilando el código para crear una versión diferente del código máquina del programa para cada uno de los tipos de equipo. Esos traductores de lenguajes de programación forman dos categorías generales:</div>  \n",
    "    \n",
    "    (1) intérpretes y  \n",
    "    (2) compiladores  \n",
    "    \n",
    "<div class=text-justify>Un <span style=\"color:magenta\">intérprete</span> lee el código fuente de los programas tal y como ha sido escrito por el programador, lo analiza, e interpreta sus instrucciones sobre la marcha. Python es un intérprete y cuando lo estamos ejecutando de forma interactiva, podemos escribir una línea de Python (una frase), y este la procesa de forma inmediata, quedando listo para que podamos escribir otra línea. Algunas de esas líneas le indican a Python que tú quieres que recuerde cierto valor para utilizarlo más tarde. Tenemos que escoger un nombre para que ese valor sea recordado y usaremos ese nombre simbólico para recuperar el valor más tarde. Utilizamos el término <span style=\"color:magenta\">variable</span> para denominar las etiquetas que usamos para referirnos a esos datos almacenados.</div> \n",
    "\n",
    "> x = 6  \n",
    "> print(x)  \n",
    "> <span style=\"color:blue\">6</span>  \n",
    "\n",
    "> y = x * 7  \n",
    "> print(y)  \n",
    "> <span style=\"color:blue\">42</span>    \n",
    "</br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=text-justify>En este ejemplo, le pedimos a Python que recuerde el valor seis y use la etiqueta \"x\" para que podamos recuperar luego. Comprobamos que Python ha guardado de verdad el valor usando print. Luego le pedimos a Python que recupere \"x\", lo multiplique por siete y guarde el valor calculado en y. Finalmente, le pedimos a Python que escriba el valor actual de y. A pesar de que estamos escribiendo estos comandos en Python línea a línea, Python los está tratando como una secuencia ordenada de sentencias, en la cual las últimas frases son capaces de obtener datos creados en las anteriores. Estamos, por tanto, escribiendo nuestro primer párrafo sencillo con cuatro frases en un orden lógico y útil.</div>   \n",
    "</br>\n",
    "</br>\n",
    "<div class=text-justify>La esencia de un intérprete consiste en ser capaz de mantener una conversación interactiva como la mostrada más arriba. Un <span style=\"color:magenta\">compilador</span> necesita que le entreguen el programa completo en un fichero, y luego ejecuta un proceso para traducir el código fuente de alto nivel a código máquina, tras lo cual coloca ese código máquina resultante dentro de otro fichero para su ejecución posterior. En sistemas Windows, a menudo esos ejecutables en código máquina tienen un sufijo o extensión como “.exe” o “.dll”, que significan “ejecutable” y “librería de enlace dinámico” (dynamic link library) respectivamente. En Linux y Macintosh, no existe un sufijo que identifique de manera exclusiva a un fichero como ejecutable.  \n",
    "</br>\n",
    "</br>\n",
    "</br>\n",
    "</div> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Escribiendo un programa**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=text-justify>Escribir comandos en el intérprete de Python es un buen modo de experimentar con las capacidades de Python, pero no es lo más recomendado a la hora de resolver problemas más complejos.\n",
    "Cuando queremos escribir un programa, usamos un editor de texto para escribir las instrucciones de Python en un fichero, que recibe el nombre de <span style=\"color:blue\"><b>script</b> </span>. Por convención, los scripts de Python tienen nombres que terminan en <span style=\"color:magenta\">.py</span>. Para ejecutar el script, hay que indicarle al intérprete de Python el nombre del fichero. En una ventana de comandos de Unix o Windows, escribirías <span style=\"color:magenta\">python hola.py</span>, de este modo:</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cat hola.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python hola.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**¿Qué es un programa?**  \n",
    "\n",
    "<div class=text-justify>Podemos definir un programa, en su forma más básica, como una secuencia de declaraciones o sentencias que han sido diseñadas para hacer algo. Incluso nuestro sencillo script “<span style=\"color:magenta\">hola.py</span>” es un programa. Es un programa de una sola línea y no resulta particularmente útil, pero si nos ajustamos estrictamente a la definición, se trata de un programa en Python.</span>  \n",
    "    \n",
    "<div class=text-justify>Tal vez resulte más fácil comprender qué es un programa pensando en un problema que pudiera ser resuelto a través de un programa, y luego estudiando cómo sería el programa que solucionaría ese problema.</span>  \n",
    "\n",
    "<div class=text-justify>Supongamos que estás haciendo una investigación de computación o informática social en mensajes de Facebook, y te interesa conocer cual es la palabra más utilizada en un conjunto de mensajes. Podrías imprimir el flujo de mensajes de Facebook y revisar con atención el texto, buscando la palabra más común, pero sería un proceso largo y muy propenso a errores. Sería más inteligente escribir un programa en Python para encargarse de la tarea con rapidez y precisión, y así poder emplear nuestro tiempo en hacer otras cosas más divertidas.</span>   \n",
    "\n",
    "<div class=text-justify>Por ejemplo, fíjate en el texto del archivo <span style=\"color:magenta\">WW_canto.txt</span>, que contiene el poema «Canto a mí mismo» de Walt Whitman (Traducción de Jorge Luis Borges). Revísalo, trataremos de averiguar cual es la palabra más común y cuántas veces se repite con el programa visto líneas arriba, pero ahora guardado en el archivo <span style=\"color:magenta\">contador.py</span></span>.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python contador.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b>Ejemplo 4: ¿Cuántas \"A\" contiene la siguiente secuencia?</b></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**AGTCCCGATAAATCAG**  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'ATG'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 'TTT'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x + y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x+y #suma de strings produce concatenacion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AGTCCCGATAAATCAG'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq1=\"AGTCCCGATAAATCAG\"\n",
    "seq1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq1.lower()\n",
    "#seq1.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq1.count(\"A\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AGUCCCGAUAAAUCAG'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Reemplazando\n",
    "seq1.replace(\"T\",\"U\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'T'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq1[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Si se cambio la T por la U, por qué aparece 'T' en seq1[2]?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'GTCC'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Tomando unua porción\n",
    "seq1[1:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Tipos de Errores de sintaxis__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Errores de sintaxis:  \n",
    "<div class=text-justify>Estos son los primeros errores que cometerás y también los más fáciles de solucionar. Un error de sintaxis significa que has violado las reglas “gramaticales” de Python. Python hace todo lo que puede para señalar el punto exacto, la línea y el carácter donde ha detectado el fallo. Lo único complicado de los errores de sintaxis es que a veces el error que debe corregirse está en realidad en una línea anterior a la cual Python detectó ese fallo. De modo que la línea y el carácter que Python indica en un error de sintaxis pueden ser tan sólo un punto de partida para tu investigación.</div>\n",
    "<br/>\n",
    "2. Errores lógicos:    \n",
    "<div class=text-justify>Se produce un error lógico cuando un programa tiene una sintaxis correcta, pero existe un error en el orden de las sentencias o en la forma en que están relacionadas unas con otras. Un buen ejemplo de un error lógico sería: “toma un trago de tu botella de agua, ponla en tu mochila, camina hasta la biblioteca y luego vuelve a enroscar la tapa en la botella.”</div>\n",
    "<br/>\n",
    "3. Errores semánticos:  \n",
    "<div class=text-justify>Un error semántico ocurre cuando la descripción que has brindado de los pasos a seguir es sintácticamente perfecta y está en el orden\n",
    "correcto, pero sencillamente hay un error en el programa. El programa es correcto, pero no hace lo que tú pretendías que hiciera. Un ejemplo podría ser cuando le das indicaciones a alguien sobre cómo llegar a un restaurante, y le dices “. . . cuando llegues a la intersección con la gasolinera, gira a la izquierda, continúa durante otro kilómetro y el restaurante es el edificio rojo que encontrarás a tu izquierda.”. Tu amigo se retrasa y te llama para decirte que está en una granja dando vueltas alrededor de un granero, sin rastro alguno de un restaurante. Entonces le preguntas “¿giraste a la izquierda o la derecha?”, y te responde “Seguí tus indicaciones al pie de la letra, dijiste que girara a la izquierda y continuar un kilómetro desde la gasolinera.”, entonces le respondes “Lo siento mucho, porque a pesar de que mis indicaciones fueron sintácticamente correctas, tristemente contenían un pequeño pero indetectado error semántico.”</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Glosario"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__bug__ Un error en un programa.  \n",
    "__código fuente__ Un programa en un lenguaje de alto nivel.  \n",
    "__código máquina__ El lenguaje de más bajo nivel para el software, es decir, el lenguaje que es directamente ejecutado por la unidad central de procesamiento (CPU).  \n",
    "__compilar__ Traducir un programa completo escrito en un lenguaje de alto nivel a un lenguaje de bajo nivel, para dejarlo listo para una ejecución posterior.  \n",
    "__error semántico__ Un error dentro de un programa que provoca que haga algo diferente de lo que pretendía el programador.  \n",
    "__función print__ Una instrucción que hace que el intérprete de Python muestre un valor en la pantalla.  \n",
    "__indicador de línea de comandos (prompt)__ Cuando un programa muestra un mensaje y se detiene para que el usuario teclee algún tipo de dato.  \n",
    "__interpretar__ Ejecutar un programa escrito en un lenguaje de alto nivel traduciéndolo línea a línea.  \n",
    "__lenguaje de alto nivel__ Un lenguaje de programación como Python, que ha sido diseñado para que sea fácil de leer y escribir por las personas.  \n",
    "__lenguaje de bajo nivel__ Un lenguaje de programación que está diseñado para ser fácil de ejecutar para una computadora; también recibe el nombre de “código máquina”, “lenguaje máquina” o “lenguaje ensamblador”.  \n",
    "__memoria principal__ Almacena los programas y datos. La memoria principal pierde su información cuando se desconecta la alimentación.  \n",
    "__memoria secundaria__ Almacena los programas y datos y mantiene su información incluso cuando se interrumpe la alimentación. Es generalmente más lenta que la memoria principal. Algunos ejemplos de memoria secundaria son las unidades de disco y memorias flash que se encuentran dentro de los dispositivos USB.  \n",
    "__modo interactivo__ Un modo de usar el intérprete de Python, escribiendo comandos y expresiones directamente en el indicador de la línea de comandos.  \n",
    "__parsear__ Examinar un programa y analizar la estructura sintáctica.  \n",
    "__portabilidad__ Es la propiedad que poseen los programas que pueden  funcionar en más de un tipo de computadora.  \n",
    "__programa__ Un conjunto de instrucciones que indican cómo realizar algún tipo de cálculo.  \n",
    "__resolución de un problema__ El proceso de formular un problema, encontrar una solución, y mostrar esa solución.  \n",
    "__semántica__ El significado de un programa.  \n",
    "__unidad central de procesamiento__ El corazón de cualquier computadora. Eslo que ejecuta el software que escribimos. También recibe el nombre de “CPU” por sus siglas en inglés (Central Processsing Unit), o simplemente, “el procesador”.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Ejercicio 1: ¿Cuál es la función de la memoria secundaria en una computadora?__  \n",
    "a) Ejecutar todos los cálculos y la lógica del programa  \n",
    "b) Descargar páginas web de Internet  \n",
    "c) Almacenar información durante mucho tiempo, incluso después de ciclos de apagado y encendido  \n",
    "d) Recolectar la entrada del usuario  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejercicio 2: ¿Qué es un programa?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejercicio 3: ¿Cuál es la diferencia entre un compilador y un intérprete?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Ejercicio 4: ¿Cuál de los siguientes contiene “código máquina”?__  \n",
    "a) El intérprete de Python  \n",
    "b) El teclado  \n",
    "c) El código fuente de Python  \n",
    "d) Un documento de un procesador de texto  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Ejercicio 5: ¿Qué está mal en el siguiente código?:__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"imagenes/imagen3.PNG\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Ejercicio 6: ¿En qué lugar del computador queda almacenada una variable, como en este caso “X”, después de ejecutar la siguiente línea de Python?:__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "x = 123  \n",
    "a) Unidad central de procesamiento  \n",
    "b) Memoria Principal  \n",
    "c) Memoria Secundaria  \n",
    "d) Dispositivos de Entrada  \n",
    "e) Dispositivos de Salida  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Ejercicio 7: ¿Qué mostrará en pantalla el siguiente programa?:__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> x = 43  \n",
    "> x = x + 1  \n",
    "> print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a) 43  \n",
    "b) 44  \n",
    "c) x + 1  \n",
    "d) Error, porque x = x + 1 no es posible matemáticamente.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Ejercicio 8:__ Explica cada uno de los siguientes conceptos usando un ejemplo de una capacidad humana:   \n",
    "(1) Unidad central de procesamiento,   \n",
    "(2) Memoria principal,   \n",
    "(3) Memoria secundaria,  \n",
    "(4) Dispositivos de entrada, y  \n",
    "(5) Dispositivos de salida.  \n",
    "Por ejemplo, “¿Cuál sería el equivalente humano de la Unidad central de procesamiento?”."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Ejercicio 9:__ ¿Cómo puedes corregir un “Error de sintaxis”?."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<img src=\"imagenes/xkcd911.PNG\">\n",
    "<br/>  \n",
    "<br/>  \n",
    "<br/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Valores, tipos & variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Valores y tipos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los números o las palabras son *valores* y estos pertenecen a categorías o *tipos* diferentes, como los enteros o las cadenas (*strings*). Las cadenas reciben este nombre por contener un conjunto o \"cadena\" de letras. Podemos identificar las cadenas porque van encerradas entre comillas. Entonces también podemos expresar los números como cadenas si les colocamos comillas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "saludo = 'hola'\n",
    "type(saludo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(12.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clave_numerica = '123456'\n",
    "type(clave_numerica)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si usamos comas para denotar un número grande, python lo interpretará como "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 0, 0)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "que_es = (1,000,000)\n",
    "que_es"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(que_es)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0 0\n"
     ]
    }
   ],
   "source": [
    "print(1,000,000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(print(1,000,000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una de las características más potentes de un lenguaje de programación es la capacidad de manipular variables. Una variable es un nombre que se refiere a un\n",
    "valor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nombres de las variables**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los nombres que les asignamos a las variables generalmente documentan lo que estamos haciendo. Estas no pueden comenzar en números y tampoco tener espacios, caracteres especiales o guiones, a menos que sea un guión-bajo. De cometer estos errores, recibiremos el mensaje: \"SyntaxError: invalid syntax\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-11-e6a74f76181f>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-11-e6a74f76181f>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    123bien = 'primer comentario'\u001b[0m\n\u001b[0m       ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "123bien = 'primer comentario'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-12-24bd7a562ff5>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-12-24bd7a562ff5>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    123 bien = \"segundo comentario\"\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "123 bien = \"segundo comentario\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "cannot assign to operator (<ipython-input-13-3c2db65e27a6>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-13-3c2db65e27a6>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    ninh@s = \"3\"\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m cannot assign to operator\n"
     ]
    }
   ],
   "source": [
    "ninh@s = \"3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "mensaje = 'Y ahora algo completamente diferente'\n",
    "n = 17\n",
    "pi = 3.1415926535897931"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La última celda no comete los errores mencionados, por ende, podemos emplear esas variables para realizar operaciones con python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sentencias"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una sentencia es una unidad de código que el intérprete de Python puede ejecutar, como por ejemplo, print('hola') o pi=3.14.  \n",
    "\n",
    "Cuando escribes una sentencia en modo interactivo, el intérprete la ejecuta y muestra el resultado, si es que lo hay.  \n",
    "\n",
    "Un script normalmente contiene una secuencia de sentencias. Si hay más de una sentencia, los resultados aparecen de uno en uno según se van ejecutando las sentencias."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores y operandos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los operadores son símbolos especiales que representan cálculos, como la suma o la multiplicación. Los valores a los cuales se aplican esos operadores reciben el nombre de operandos.  \n",
    "\n",
    "Los operadores +, -,/,\\\\, y * realizan sumas, restas, multiplicaciones, divisiones y exponenciación (elevar un número a una potencia), como se muestra en los ejemplos siguientes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21 440 440.0 25 -16\n"
     ]
    }
   ],
   "source": [
    "hora=20+2\n",
    "print(\n",
    "    hora-1,\n",
    "    hora*20,\n",
    "    hora*60/3,\n",
    "    5**2,\n",
    "    (5-7)*(15-7)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2//5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expresiones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una expresión es una combinación de valores, variables y operadores. Un valor por si mismo se considera una expresión, y también lo es una variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=1\n",
    "x+2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las expresiones se tornarán más útiles en un script, cuando realicemos iteración o recursividad más adelante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejemplo de recursividad, se verá con mayor detalle más adelante \n",
    "def fun_fact(x):\n",
    " if (x==1):\n",
    "   return 1\n",
    " else:\n",
    "   x=(x*fun_fact(x-1))\n",
    " return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El factorial de  6 es  720\n"
     ]
    }
   ],
   "source": [
    "num=6\n",
    "print(\"El factorial de \", num, \"es \",fun_fact(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Orden de las operaciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando tenemos más de un operador \n",
    "\n",
    "Las reglas de precedencia, para cuando tenemos más de un operador"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operador módulo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El operador módulo trabaja con enteros y obtiene el resto de la operación consistente en dividir el primer operando por el segundo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quotient = 7 // 3\n",
    "print(quotient)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "remainder = 7 % 3\n",
    "print(remainder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operaciones con cadenas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El operador + funciona con las cadenas, pero no realiza una suma en el sentido\n",
    "matemático. En vez de eso, realiza una concatenación, que quiere decir que une\n",
    "ambas cadenas, enlazando el final de la primera con el principio de la segunda. Por\n",
    "ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "primero = 10\n",
    "segundo = 15\n",
    "print(primero+segundo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100150\n"
     ]
    }
   ],
   "source": [
    "primero = '100'\n",
    "segundo = '150'\n",
    "print(primero+segundo) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El operador * también trabaja con cadenas multiplicando el contenido de una\n",
    "cadena por un entero. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Test Test \n"
     ]
    }
   ],
   "source": [
    "primero = 'Test '\n",
    "second = 3\n",
    "print(primero * second)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Glosario"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__asignación__ Una sentencia que asigna un valor a una variable.  \n",
    "__cadena__ Un tipo que representa secuencias de caracteres.  \n",
    "__concatenar__ Unir dos operandos, uno a continuación del otro.   \n",
    "__comentario__ Información en un programa que se pone para otros programadores\n",
    "(o para cualquiera que lea el código fuente), y no tiene efecto alguno en la\n",
    "ejecución del programa.  \n",
    "__división entera__ La operación que divide dos números y trunca la parte fraccionaria.  \n",
    "__entero__ Un tipo que representa números enteros.  \n",
    "__evaluar__ Simplificar una expresión realizando las operaciones en orden para obtener un único valor.  \n",
    "__expresión__ Una combinación de variables, operadores y valores que representan un único valor resultante.  \n",
    "__mnemónico__ Una ayuda para memorizar. A menudo damos nombres mnemónicos a las variables para ayudarnos a recordar qué está almacenado en ellas.  \n",
    "__palabra clave__ Una palabra reservada que es usada por el compilador para analizar un programa; no se pueden usar palabres clave como *if*, *def*, y *while* como nombres de variables.  \n",
    "__punto flotante__ Un tipo que representa números con parte decimal.  \n",
    "__operador__ Un símbolo especial que representa un cálculo simple, como suma, multiplicación o concatenación de cadenas.  \n",
    "__operador módulo__ Un operador, representado por un signo de porcentaje (%), que funciona con enteros y obtiene el resto cuando un número es dividido por otro.  \n",
    "__operando__ Uno de los valores con los cuales un operador opera.  \n",
    "__reglas de precedencia__ El conjunto de reglas que gobierna el orden en el cual son evaluadas las expresiones que involucran a múltiples operadores.   \n",
    "__sentencia__ Una sección del código que representa un comando o acción. Hasta ahora, las únicas sentencias que hemos visto son asignaciones y sentencias print.  \n",
    "__tipo__ Una categoría de valores. Los tipos que hemos visto hasta ahora son enteros (tipo int), números en punto flotante (tipo float), y cadenas (tipo str).   \n",
    "__valor__ Una de las unidades básicas de datos, como un número o una cadena, que un programa manipula.  \n",
    "__variable__ Un nombre que hace referencia a un valor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio 10: Escribe un programa que pida al usuario su nombre y luego darle la bienvenida.**\n",
    "> Introduzca su nombre: Puquna  \n",
    "> Hola, Puquna"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio 11: Escribe un programa para pedirle al usuario el número de horas y la tarifa por hora para calcular el salario bruto.**\n",
    "> Introduzca Horas: 35  \n",
    "> Introduzca Tarifa: 2.75  \n",
    "> Salario: 96.25  \n",
    "\n",
    "<div class=text-justify>Por ahora no es necesario preocuparse de que nuestro salario tenga exactamente\n",
    "dos dígitos después del punto decimal. Si quieres, puedes probar la función interna\n",
    "de Python round para redondear de forma adecuada el salario resultante a dos\n",
    "dígitos decimales.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio 12: Asume que ejecutamos las siguientes sentencias de asignación:**\n",
    "> ancho = 17  \n",
    "> alto = 12.0  \n",
    "\n",
    "Para cada una de las expresiones siguientes, escribe el valor de la expresión y el tipo (del valor de la expresión).\n",
    "1. ancho/2\n",
    "2. ancho/2.0\n",
    "3. alto/3\n",
    "4. 1 + 2 * 5  \n",
    "\n",
    "Usa el intérprete de Python para comprobar tus respuestas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=text-justify>Ejercicio 13: Escribe un programa que le pida al usuario una temperatura en grados Celsius, la convierta a grados Fahrenheit e imprima por pantalla la temperatura convertida.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "https://xkcd.com/99/\n",
    "<img src=\"imagenes/xkcd99.jpg\">\n",    
    "<br/>  \n",
    "<br/>  \n",
    "<br/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejecución condicional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expresiones booleanas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=text-justify>Una expresión booleana es aquella que puede ser verdadera (True) o falsa (False). Los ejemplos siguientes usan el operador ==, que compara dos operandos y devuelve True si son iguales y False en caso contrario:</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 == 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "True y False son valores especiales que pertenecen al tipo bool (booleano); no son cadenas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">El operador == es uno de los operadores de comparación; los demás son:</div>\n",
    "\n",
    "x es distinto de y   \n",
    "**x != y**  \n",
    "\n",
    "x es mayor que y  \n",
    "**x > y** #   \n",
    "\n",
    "x es menor que y  \n",
    "**x < y** #   \n",
    "\n",
    "x es mayor o igual que y  \n",
    "**x >= y** # \n",
    "\n",
    "\n",
    "**x <= y** # x es menor o igual que y  \n",
    "\n",
    "\n",
    "**x is y** # x es lo mismo que y  \n",
    "\n",
    "\n",
    "**x is not y** # x no es lo mismo que y  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">Recuerda que = es un operador de asignación, y == es un operador de comparación. No existe algo como =< o => </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores lógicos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen tres operadores lógicos: and (y), or (o), y not (no). El significado\n",
    "semántico de estas operaciones es similar a su significado en inglés. Por ejemplo,\n",
    "\n",
    "x > 0 and x < 10\n",
    "\n",
    "es verdadero sólo cuando x es mayor que 0 y menor que 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "13 and True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejecución condicional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=text-justify>Para poder escribir programas útiles, casi siempre vamos a necesitar la capacidad de comprobar condiciones y cambiar el comportamiento del programa de acuerdo a ellas. Las sentencias condicionales nos proporcionan esa capacidad. La forma más sencilla es la sentencia if:</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x es positivo\n"
     ]
    }
   ],
   "source": [
    "x=3\n",
    "if x>0:\n",
    "    print('x es positivo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ent = input('Introduzca la Temperatura Fahrenheit:')\n",
    "try:\n",
    "    fahr = float(ent)\n",
    "    cel = (fahr - 32.0) * 5.0 / 9.0\n",
    "    print(cel)\n",
    "except:\n",
    "    print('Por favor, introduzca un número')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Glosario"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**condición** La expresión booleana en una sentencia condicional que determina qué rama será ejecutada.  \n",
    "**condicional anidado** Una sentencia condicional que aparece en una de las ramas de otra sentencia condicional.  \n",
    "**condicional encadenado** Una sentencia condicional con una serie de ramas alternativas.  \n",
    "**cortocircuito** Cuando Python va evaluando una expresión lógica por tramos y detiene el proceso de evaluación debido a que ya conoce el valor final que va a tener el resultado sin necesidad de evaluar el resto de la expresión.  \n",
    "**cuerpo** La secuencia de sentencias en el interior de una sentencia compuesta.  \n",
    "**expresión booleana** Un expresión cuyo valor puede ser o bien Verdadero o bien Falso.  \n",
    "**operadores de comparación** Uno de los operadores que se utiliza para comparar dos operandos: ==, !=, >, <, >=, y <=.  \n",
    "**operador lógico** Uno de los operadores que se combinan en las expresiones booleanas: and, or, y not.  \n",
    "**patrón guardián** Cuando construimos una expresión lógica con comparaciones adicionales para aprovecharnos del funcionamiento en cortocircuito.  \n",
    "**rama** Una de las secuencias alternativas de sentencias en una sentencia condicional.  \n",
    "**sentencia compuesta** Una sentencia que consiste en un encabezado y un cuerpo. El encabezado termina con dos-puntos (:). El cuerpo está indentado con relación al encabezado.  \n",
    "**sentencia condicional** Una sentencia que controla el flujo de ejecución, dependiendo de cierta condición.  \n",
    "**traceback** Una lista de las funciones que se están ejecutando, que se muestra en pantalla cuando se produce una excepción."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio 14: Reescribe el programa del cálculo del salario de la referencia 2, para darle al empleado 1.5 veces la tarifa horaria para todas las horas trabajadas que excedan de 40.**  \n",
    "> Introduzca las Horas: 45  \n",
    "> Introduzca la Tarifa por hora: 10  \n",
    "> Salario: 475.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio 15: Reescribe el programa del salario de la referencia 2, usando try y except, de modo que el programa sea capaz de gestionar entradas no numéricas con elegancia, mostrando un mensaje y saliendo del programa. A continuación se muestran dos ejecuciones\n",
    "del programa:**  \n",
    "> Introduzca las Horas: 20  \n",
    "> Introduzca la Tarifa por hora: nueve  \n",
    "> Error, por favor introduzca un número  \n",
    "<br/>\n",
    "> Introduzca las Horas: cuarenta  \n",
    "> Error, por favor introduzca un número"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio 16: Escribe un programa que solicite una puntuación entre 0.0 y 1.0. Si la puntuación está fuera de ese rango, muestra un mensaje de error. Si la puntuación está entre 0.0 y 1.0, muestra la calificación usando la tabla siguiente:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puntuación Calificación  \n",
    "**>= 0.9** Sobresaliente  \n",
    "**>= 0.8** Notable  \n",
    "**>= 0.7** Bien  \n",
    "**>= 0.6** Suficiente  \n",
    "**< 0.6** Insuficiente  \n",
    "Introduzca puntuación: 0.95  \n",
    "Sobresaliente  \n",
    "Introduzca puntuación: perfecto  \n",
    "Puntuación incorrecta  \n",
    "Introduzca puntuación: 10.0  \n",
    "Puntuación incorrecta  \n",
    "Introduzca puntuación: 0.75  \n",
    "Bien  \n",
    "Introduzca puntuación: 0.5  \n",
    "Insuficiente  \n",
    "Ejecuta el programa repetidamente, como se muestra arriba, para probar con varios valores de entrada diferentes.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones e iteraciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LLamadas a funciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el contexto de la programación, una función es una secuencia de sentencias que\n",
    "realizan una operación y que reciben un nombre. Cuando se define una función, se\n",
    "especifica el nombre y la secuencia de sentencias. Más adelante, se puede “llamar”\n",
    "a la función por ese nombre. Ya hemos visto un ejemplo de una llamada a una\n",
    "función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El nombre de la función es type. La expresión entre paréntesis recibe el nombre\n",
    "de argumento de la función. El argumento es un valor o variable que se pasa a la\n",
    "función como parámetro de entrada. El resultado de la función type es el tipo del\n",
    "argumento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es habitual decir que una función “toma” (o recibe) un argumento y “retorna” (o\n",
    "devuelve) un resultado. El resultado se llama valor de retorno."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones internas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python proporciona un número importante de funciones internas, que pueden ser\n",
    "usadas sin necesidad de tener que definirlas previamente. Los creadores de Python\n",
    "han escrito un conjunto de funciones para resolver problemas comunes y las han\n",
    "incluido en Python para que las podamos utilizar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las funciones max y min nos darán respectivamente el valor mayor y menor de una\n",
    "lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'u'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max('Hola, mundo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' '"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min('Hola, mundo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función max nos dice cuál es el “carácter más grande” de la cadena (que resulta\n",
    "ser la letra “u”), mientras que la función min nos muestra el carácter más pequeño\n",
    "(que en ese caso es un espacio).\n",
    "Otra función interna muy común es len, que nos dice cuántos elementos hay en\n",
    "su argumento. Si el argumento de"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len('Hola, mundo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estas funciones no se limitan a buscar en cadenas. Pueden operar con cualquier\n",
    "conjunto de valores, como veremos en los siguientes capítulos.\n",
    "Se deben tratar los nombres de las funciones internas como si fueran palabras\n",
    "reservadas (es decir, evita usar “max” como nombre para una variable)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones de conversión de tipos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python también proporciona funciones internas que convierten valores de un tipo\n",
    "a otro. La función int toma cualquier valor y lo convierte en un entero, si puede,\n",
    "o se queja si no puede:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(3.99999)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(-2.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32.0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.14159"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('3.14159')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'32'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones matemáticas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.989700043360188"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "relacion = 5 #int_senal / int_ruido\n",
    "decibelios = 10 * math.log10(relacion)\n",
    "decibelios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grados = 45\n",
    "radianes = grados / 360.0 * 2 * math.pi\n",
    "math.sin(radianes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.sqrt(2) / 2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Números aleatorios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9460030887870019\n",
      "0.17224869763679995\n",
      "0.0808937428958314\n",
      "0.40493208480156195\n",
      "0.8673881501034678\n",
      "0.7153739728451465\n",
      "0.011614281532977389\n",
      "0.4388313391110873\n",
      "0.220485869457975\n",
      "0.21925199108987714\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "for i in range(10):\n",
    "    x = random.random()\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.randint(5, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.randint(5, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = [1, 2, 3]\n",
    "random.choice(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.choice(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nuevas funciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def muestra_estribillo():\n",
    "    print('Soy un leñador, qué alegría.')\n",
    "    print('Duermo toda la noche y trabajo todo el día.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "muestra_estribillo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sumados(a, b):\n",
    "    suma = a + b\n",
    "    return suma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = sumados(3, 5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iteraciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**WHILE**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    linea = input('> ')\n",
    "    if linea == 'fin':\n",
    "        break\n",
    "    print(linea)\n",
    "print('¡Terminado!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**CONTINUE**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunas veces, estando dentro de un bucle se necesita terminar con la iteración\n",
    "actual y saltar a la siguiente de forma inmediata. En ese caso se puede utilizar\n",
    "la sentencia continue para pasar a la siguiente iteración sin terminar la ejecución\n",
    "del cuerpo del bucle para la actual.\n",
    "A continuación se muestra un ejemplo de un bucle que repite lo que recibe como\n",
    "entrada hasta que el usuario escribe “fin”, pero trata las líneas que empiezan por el\n",
    "carácter almohadilla como líneas que no deben mostrarse en pantalla (algo parecido\n",
    "a lo que hace Python con los comentarios)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    linea = input('> ')\n",
    "    if linea[0] == '#' :\n",
    "        continue\n",
    "    if linea == 'fin':\n",
    "        break\n",
    "    print(linea)\n",
    "print('¡Terminado!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**FOR**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amigos = ['Joseph', 'Glenn', 'Sally']\n",
    "for amigo in amigos:\n",
    "    print('Feliz año nuevo:', amigo)\n",
    "    print('¡Terminado!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Glosario"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**acumulador** Una variable usada en un bucle para sumar o acumular un resultado.  \n",
    "**algoritmo** Un proceso general para resolver una categoría de problemas.  \n",
    "**argumento** Un valor proporcionado a una función cuando ésta es llamada. Ese valor se asigna al parámetro correspondiente en la función.  \n",
    "**bucle infinito** Un bucle en el cual la condición de terminación no se satisface nunca o para el cual no existe dicha condición de terminación.  \n",
    "**cabecera** La primera línea de una definición de función.  \n",
    "**contador** Una variable usada en un bucle para contar el número de veces que algo sucede. Inicializamos el contador a cero y luego lo vamos incrementando cada vez que queramos que “cuente” algo.  \n",
    "**cuerpo** La secuencia de sentencias dentro de la definición de una función.  \n",
    "**composición** Uso de una expresión o sentencia como parte de otra más larga.  \n",
    "**decremento** Una actualización que disminuye el valor de una variable.  \n",
    "**definición de función** Una sentencia que crea una función nueva, especificando su nombre, parámetros, y las sentencias que ejecuta.  \n",
    "**determinístico** Perteneciente a un programa que hace lo mismo cada vez que se ejecuta, a partir de las mismas entradas.  \n",
    "**función** Una secuencia de sentencias con un nombre que realizan alguna operación útil. Las funciones pueden tomar argumentos o no, y pueden producir un resultado o no.  \n",
    "**función productiva (fruitful function)** Una función que devuelve un valor.  \n",
    "**función estéril (void function)** Una función que no devuelve ningún valor.  \n",
    "**flujo de ejecución** El orden en el cual se ejecutan las sentencias durante el funcionamiento de un programa.  \n",
    "**inicializar** Una asignación que da un valor inicial a una variable que va a ser después actualizada.  \n",
    "**incremento** Una actualización que aumenta el valor de una variable (a menudo en una unidad).  \n",
    "**iteración** Ejecución repetida de una serie de sentencias usando bien una función que se llama a si misma o bien un bucle.  \n",
    "**llamada a función** Una sentencia que ejecuta una función. Consiste en el nombre de la función seguido por una lista de argumentos.  \n",
    "**notación punto** La sintaxis para llamar a una función de otro módulo, especificando el nombre del módulo seguido por un punto y el nombre de la función.  \n",
    "**objeto función** Un valor creado por una definición de función. El nombre de la función es una variable que se refiere al objeto función.  \n",
    "**objeto módulo** Un valor creado por una sentencia import, que proporciona acceso a los datos y código definidos en un módulo.  \n",
    "**parámetro** Un nombre usado dentro de una función para referirse al valor pasado como argumento.  \n",
    "**pseudoaleatorio** Perteneciente a una secuencia de números que parecen ser aleatorios, pero son generados por un programa determinista.  \n",
    "**sentencia import** Una sentencia que lee un archivo módulo y crea un objeto módulo.  \n",
    "**valor de retorno** El resultado de una función. Si una llamada a una función es usada como una expresión, el valor de retorno es el valor de la expresión."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio 17: ¿Cuál es la utilidad de la palabra clave “def” en Python?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a) Es una jerga que significa “este código es realmente estupendo”  \n",
    "b) Indica el comienzo de una función  \n",
    "c) Indica que la siguiente sección de código indentado debe ser almacenada para usarla más tarde  \n",
    "d) b y c son correctas ambas  \n",
    "e) Ninguna de las anteriores  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio 18: ¿Qué mostrará en pantalla el siguiente programa Python?**  \n",
    "def fred():  \n",
    "> print(\"Zap\")  \n",
    "\n",
    "def jane():  \n",
    "> print(\"ABC\")  \n",
    "\n",
    "jane()  \n",
    "fred()  \n",
    "jane()  \n",
    "\n",
    "a) Zap ABC jane fred jane  \n",
    "b) Zap ABC Zap  \n",
    "c) ABC Zap jane  \n",
    "d) ABC Zap ABC  \n",
    "e) Zap Zap Zap  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio 19: (De la ref. 2) Reescribe el programa de cálculo del salario, con tarifa-y-media para las horas extras, y crea una función llamada calculo_salario que reciba dos parámetros (horas y tarifa).**  \n",
    "Introduzca Horas: 45  \n",
    "Introduzca Tarifa: 10  \n",
    "Salario: 475.0  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio 20: Reescribe el programa de calificaciones del capítulo anterior usando una función llamada calcula_calificacion, que reciba una puntuación como parámetro y devuelva una calificación como cadena.**  \n",
    "**Puntuación** Calificación  \n",
    "> **0.9** Sobresaliente  \n",
    "> **0.8** Notable  \n",
    "> **0.7** Bien  \n",
    "> **0.6** Suficiente  \n",
    "**<= 0.6** Insuficiente    \n",
    "\n",
    "<br/>\n",
    "Introduzca puntuación: 0.95  \n",
    "Sobresaliente  \n",
    "\n",
    "Introduzca puntuación: perfecto  \n",
    "Puntuación incorrecta  \n",
    "\n",
    "Introduzca puntuación: 10.0  \n",
    "Puntuación incorrecta  \n",
    "\n",
    "Introduzca puntuación: 0.75  \n",
    "Bien  \n",
    "\n",
    "Introduzca puntuación: 0.5  \n",
    "Insuficiente  \n",
    "\n",
    "Ejecuta el programa repetidamente para probar con varios valores de entrada diferentes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio 21: Escribe un programa que lea repetidamente números hasta que el usuario introduzca “fin”. Una vez se haya introducido “fin”, muestra por pantalla el total, la cantidad de números y la media de esos números. Si el usuario introduce cualquier otra cosa que no sea un número, detecta su fallo usando try y except, muestra un mensaje de error y pasa al número siguiente.**  \n",
    "Introduzca un número: 4  \n",
    "Introduzca un número: 5  \n",
    "Introduzca un número: dato erróneo    \n",
    "Entrada inválida  \n",
    "Introduzca un número: 7  \n",
    "Introduzca un número: fin  \n",
    "16 3 5.33333333333  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejercicio 22: Escribe otro programa que pida una lista de números como la anterior y al final muestre por pantalla el máximo y mínimo de los números, en vez de la media."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://xkcd.com/149/\n",
    "<img src=\"imagenes/xkcd149.PNG\">",
    "<br/>  \n",
    "<br/>  \n",
    "<br/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "nueva_lista = []\n",
    "\n",
    "for **i** in **list**:\n",
    "\n",
    "  if condición:\n",
    "\n",
    "    nueva_lista.append(expresion(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Formato de la compresión**\n",
    "\n",
    "[resultado(i) for i in list if condición]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1: Imprimir los números pares de la siguiente lista\n",
    "numeros = [1, 2, 34, 86, 4, 5, 99, 890, 45]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 34, 86, 4, 890]\n"
     ]
    }
   ],
   "source": [
    "pares = []\n",
    "for num in numeros:\n",
    "    if num % 2 == 0:\n",
    "        pares.append(num)\n",
    "print(pares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 34, 86, 4, 890]\n"
     ]
    }
   ],
   "source": [
    "pares = [num for num in numeros if num % 2 == 0]\n",
    "print(pares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Casa', 'Perro', 'Puerta', 'Pizza']\n"
     ]
    }
   ],
   "source": [
    "#2 Capitalizar las palabras de una lista\n",
    "palabras = ['casa', 'perro', 'puerta', 'pizza']\n",
    "cap = [palabra.title() for palabra in palabras]\n",
    "print(cap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "#3 Calcular los cuadrados del 0 al 9\n",
    "cuadrados = [num**2 for num in range(10)]\n",
    "print(cuadrados)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['texput.log', 'tbromoindol_2.log']\n"
     ]
    }
   ],
   "source": [
    "#4 Extraer todas los archivos .*log de un fichero que empiezan con t\n",
    "import os\n",
    "ficheros_python = [f for f in os.listdir('.') if f.endswith('.log') and f.startswith('t')]\n",
    "print(ficheros_python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Copyright (c) 1988,1990,1992,1993,1995,1998,2003,2009,2013,\r\n",
      "            Gaussian, Inc.  All Rights Reserved.\r\n",
      "  \r\n",
      " the Gaussian 86(TM) system (copyright 1986, Carnegie Mellon\r\n",
      " University), and the Gaussian 82(TM) system (copyright 1983,\r\n",
      " Carnegie Mellon University). Gaussian is a federally registered\r\n",
      " trademark of Gaussian, Inc.\r\n",
      "  \r\n",
      " ******************************************\r\n",
      " Gaussian 09:  EM64L-G09RevD.01 24-Apr-2013\r\n",
      "                10-Apr-2022 \r\n",
      " ******************************************\r\n",
      " %NProcShared=6\r\n",
      " Will use up to    6 processors via shared memory.\r\n",
      " %Chk=neutro.chk\r\n",
      " ----------------------------\r\n",
      " #p B3LYP/6-31G(d) SP pop=NBO\r\n",
      " ----------------------------\r\n",
      " 1/38=1/1;\r\n",
      " 2/12=2,17=6,18=5,40=1/2;\r\n",
      " 3/5=1,6=6,7=1,11=2,16=1,25=1,30=1,74=-5/1,2,3;\r\n",
      " 4//1;\r\n",
      " 5/5=2,38=5/2;\r\n",
      " 6/7=2,8=2,9=2,10=2,28=1,40=1/1,7;\r\n",
      " 99/5=1,9=1/99;\r\n",
      " Leave Link    1 at Sun Apr 10 21:14:14 2022, MaxMem=           0 cpu:         0.6\r\n",
      " (Enter /home/matilda/g09/l101.exe)\r\n",
      " ------------------------------\r\n",
      " bromoindol_neutro_single_point\r\n",
      " ------------------------------\r\n",
      " Symbolic Z-matrix:\r\n",
      " Charge =  0 Multiplicity = 1\r\n",
      " O                     6.03765  -4.34556  -0.71508 \r\n",
      " C                     5.70826  -3.17715  -0.7675 \r\n",
      " C                     4.35428  -2.76599  -1.33742 \r\n",
      " N                     3.90775  -1.46083  -0.86484 \r\n",
      " C                     2.57786  -1.32032  -0.53267 \r\n",
      " O                     2.29753  -0.04648  -0.17491 \r\n",
      " C                     0.95308   0.35307   0.2643 \r\n",
      " C                     0.56294  -0.42074   1.52812 \r\n",
      " C                     1.12307   1.8421    0.57364 \r\n",
      " C                    -0.05249   0.14922  -0.87371 \r\n",
      " O                     1.77398  -2.23103  -0.56181 \r\n",
      " C                     4.84398  -0.33819  -0.86232 \r\n",
      " C                     6.23006  -0.78775  -0.49282 \r\n",
      " C                     6.61126  -2.07231  -0.38822 \r\n",
      " C                     4.79343   0.4695   -2.19946 \r\n",
      " C                     5.60741   1.73758  -2.18355 \r\n",
      " C                     5.19636   2.8803   -1.54727 \r\n",
      " N                     6.13757   3.8941   -1.70258 \r\n",
      " S                     6.05317   5.38274  -0.83044 \r\n",
      " O                     4.65222   5.48917  -0.43644 \r\n",
      " C                     7.03902   5.09298   0.63269 \r\n",
      " C                     8.35615   5.55477   0.67944 \r\n",
      " C                     9.11194   5.32765   1.8324 \r\n",
      " C                     8.57087   4.65228   2.93759 \r\n",
      " C                     9.36287   4.38413   4.14229 \r\n",
      " C                     7.235     4.21281   2.86363 \r\n",
      " C                     6.46321   4.43112   1.72495 \r\n",
      " O                     6.72012   6.3834   -1.65467 \r\n",
      " C                     7.20674   3.40308  -2.45696 \r\n",
      " C                     8.37047   4.05401  -2.88255 \r\n",
      " C                     9.27324   3.31863  -3.64376 \r\n",
      " C                     9.019     1.97818  -3.98344 \r\n",
      " C                     7.8496    1.34952  -3.5648 \r\n",
      " Br                    7.59235  -0.46567  -4.1164 \r\n",
      " C                     6.9032    2.04136  -2.77643 \r\n",
      " H                     3.60224  -3.51377  -1.05819 \r\n",
      " H                     4.44216  -2.79388  -2.44322 \r\n",
      " H                     1.32749  -0.28782   2.31058 \r\n",
      " H                     0.45212  -1.49224   1.31827 \r\n",
      " H                    -0.39252  -0.03499   1.91718 \r\n",
      " H                     1.87948   1.99384   1.35955 \r\n",
      " H                     0.17067   2.26867   0.92332 \r\n",
      " H                     1.4371    2.39547  -0.32513 \r\n",
      " H                    -0.16443  -0.91456  -1.11715 \r\n",
      " H                     0.27497   0.68808  -1.77706 \r\n",
      " H                    -1.03412   0.55131  -0.57705 \r\n",
      " H                     4.51521   0.35296  -0.07172 \r\n",
      " H                     6.94752   0.014    -0.29187 \r\n",
      " H                     7.62158  -2.35513  -0.08064 \r\n",
      " H                     3.73553   0.72747  -2.35678 \r\n",
      " H                     5.09858  -0.18158  -3.02811 \r\n",
      " H                     4.27293   3.08311  -1.00993 \r\n",
      " H                     8.77532   6.09888  -0.16803 \r\n",
      " H                     10.14192   5.69102   1.87388 \r\n",
      " H                     6.78958   3.69878   3.72033 \r\n",
      " H                     5.42125   4.10931   1.68486 \r\n",
      " H                     8.54078   5.10438  -2.65134 \r\n",
      " H                     10.19221   3.79077  -3.99908 \r\n",
      " H                     9.73704   1.42314  -4.5894 \r\n",
      " H                     10.36892   4.80637   4.04986 \r\n",
      " H                     9.45403   3.35001   4.35816 \r\n",
      " H                     8.92952   4.85861   5.09822 \r\n",
      "\r\n",
      " TO ERR IS HUMAN - AND TO BLAME IT ON A COMPUTER IS EVEN MORE SO.\r\n",
      " Job cpu time:       0 days  0 hours 22 minutes 12.7 seconds.\r\n",
      " File lengths (MBytes):  RWF=    194 Int=      0 D2E=      0 Chk=     14 Scr=      1\r\n",
      " Normal termination of Gaussian 09 at Sun Apr 10 21:18:02 2022.\r\n"
     ]
    }
   ],
   "source": [
    "!cat 5 tbromoindol_2.log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 0, 0), (1, 2, 1), (2, 4, 4), (3, 6, 9), (4, 8, 16), (5, 10, 25), (6, 12, 36), (7, 14, 49), (8, 16, 64), (9, 18, 81)]\n"
     ]
    }
   ],
   "source": [
    "#5 Número, doble y cuadrado de los números del 0 al 9\n",
    "num_doble_cuadrado = [(num, num*2, num**2) for num in range(10)]\n",
    "print(num_doble_cuadrado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hola J2Logo', 'Hola Antonio', 'Hola Vega', 'Saludos J2Logo', 'Saludos Antonio', 'Saludos Vega', 'Hi J2Logo', 'Hi Antonio', 'Hi Vega']\n"
     ]
    }
   ],
   "source": [
    "#6 Ejemplo de doble bucle for\n",
    "saludos = ['hola', 'saludos', 'hi']\n",
    "nombres = ['j2logo', 'antonio', 'vega']\n",
    "frases = ['{} {}'.format(saludo.title(), nombre.title()) for saludo in saludos for nombre in nombres]\n",
    "print(frases)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Referencias\n",
    " \n",
    "1. Severance, C. R. (2009). Python para todos.  \n",
    "http://do1.dr-chuck.com/pythonlearn/ES_es/pythonlearn.pdf\n",
    "2. Seguimiento de ejecución de código:  \n",
    "https://pythontutor.com/"
   ]
  }
 ],
 "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "604px",
    "left": "259px",
    "top": "110.525px",
    "width": "291.663px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}