Semana_3_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center>\n",
    "<h1> Introducción a la programación con Python </h1>\n",
    "<h2> Alberto Mario Ceballos Arroyo </h2>\n",
    "<h2>Ingeniero de Sistemas </h2> \n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Algunos aspectos metodológicos </h1> </center>\n",
    "\n",
    "- Para participar, preferiblemente escribir por el chat o levantar la mano (somos 150).\n",
    "\n",
    "- Recordemos que el temario está disponible si queremos adelantarnos un poco.\n",
    "\n",
    "- La evaluación es automática y se basa en los retos, el resto de actividades de la plataforma son opcionales pero muy recomendadas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <img src=\"img/temario.png\"/> </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> Agenda de la semana 3 </h1> </center>\n",
    "\n",
    "- Día 1:\n",
    "    - Subprogramas.\n",
    "    - Motivación.\n",
    "    - Parámetros y variables locales.\n",
    "    - Creación de archivos con subprogramas.\n",
    "    \n",
    "- Día 2:\n",
    "    - Vectores.\n",
    "    \n",
    "- Día 3:\n",
    "    - Programación orientada a objetos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> Enlaces de interés </h1> </center>\n",
    "\n",
    "- Enlace de la plataforma: https://lms.misiontic2022udea.com/login\n",
    "\n",
    "- Wiki de Python con muchos recursos en español: https://wiki.python.org/moin/SpanishLanguage\n",
    "\n",
    "- PDF con **muchos** ejercicios: https://www.editorialeidec.com/wp-content/uploads/2020/10/Algoritmos-resueltos-con-Python.pdf\n",
    "\n",
    "- Correo del docente: alceballosa@unal.edu.co \n",
    "\n",
    "- Correo de permanencia: permamenciamisiontic@udea.edu.co\n",
    "\n",
    "- Carpeta del repositorio con muchos ejercicios: https://github.com/alceballosa/programming_fundamentals_py/tree/main/ejercicios\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Los subprogramas o funciones</h1> </center>\n",
    "\n",
    "</br>\n",
    "\n",
    "- Los subprogramas (también conocidos como funciones) son una herramienta que facilita de manera notable la elaboración de soluciones informáticas complejas. \n",
    "\n",
    "- Son algoritmos que se desarrollan y prueban de manera independiente, y que pueden ser invocados desde cualquier otro programa cuando se necesiten.\n",
    "\n",
    "- La comunicación entre los subprogramas y otros programas se da por medio de parámetros (entrada) y valores de retorno (salida), lo que hace más fácil su elaboración.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> Motivación </h1> </center>\n",
    "\n",
    "\n",
    "- En general, los problemas que se solucionan programando son *muy* complejos y una solución que se elabore en un único bloque de código puede ocupar cientos de líneas de código.\n",
    "\n",
    "- Lo anterior pasa no solo por la cantidad de tareas que debemos realizar, sino porque en general debemos ejecutar de manera repetida instrucciones muy parecidas.\n",
    "\n",
    "- Por esto, el objetivo de las funciones es facilitar el desarrollo de algoritmos más cortos, menos complejos, más legibles y más eficientes.\n",
    "\n",
    "<center> <img width=\"500\" src=\"img/sem3_funciones.png\"> </center>\n",
    "\n",
    "\n",
    "Fuente: https://j2logo.com/python/tutorial/funciones-en-python/ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> ¿Qué pasa si no uso subprogramas? </h1> </center>\n",
    "\n",
    "- El abuso de anti-patrones como condicionales anidados con mucha profundidad o el anidado exagerado de estructuras if-elif-else, así como el exceso de complejidad, llevan al denominado [código espaguetti](https://craftofcoding.files.wordpress.com/2020/02/doy_unstructured.jpg).\n",
    "\n",
    "- Este tipo de código se caracteriza por ser poco estructurado y lleva a muchos errores (o *bugs*), ya que el código es mucho más difícil de depurar y de mantener.\n",
    "\n",
    "- Parte de la pericia que se adquiere como programador es ser capaz de llevar soluciones como la enlazada arriba arriba a códigos estructurados como [este](https://craftofcoding.files.wordpress.com/2020/02/doy_structured.jpg) o este:\n",
    "\n",
    "<center> <img width=\"400\" src=\"https://miro.medium.com/max/1074/1*h2Ngqpd9G2rCnWc-8d45Jw.png\"></center>\n",
    "\n",
    "Nota: un código bien estructurado no lo es solamente por estar hecho con funciones, otros aspectos como un adecuado nombramiento de variables, el uso de comentarios y la estructuración de los condicionales tienen la misma o más importancia ([fuente](https://medium.com/@capitalkreationz/mom-go-clean-your-code-its-a-mess-3059ecf0abbe))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Ventajas y desventajas de las funciones: una comparativa </h1> </center>\n",
    "\n",
    "\n",
    "| Ventajas de usar funciones \t| Desventajas de usar funciones\t|\n",
    "|-\t|-\t|\n",
    "|Mejoran la claridad, estructura y legibilidad del programa\t| Cuando una variable se define dentro de una función, solo es válida dentro de dicha función* \t|\n",
    "| Se pueden ejecutar más de una vez en un programa y/o en diferentes programas, ahorrando tiempo de programación\t|  Realiza una tarea explícita y única* \t|\n",
    "| Facilita la división de las tareas entre un equipo de programadores \t| Un abuso de funciones nos puede llevar a un programa difícil de entender \t|\n",
    "| Se les pueden hacer pruebas de manera individual\t|  \t|\n",
    "\n",
    "\\* realmente no es una desventaja.\n",
    "\n",
    "Fuente: https://cipsa.net/ventajas-desventajas-uso-funciones-procedimientos-programacion/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> Errores típicos al usar subprogramas </h1> </center>\n",
    "\n",
    "- No definir un valor de retorno (siempre que este sea necesario).\n",
    "\n",
    "- Elaborar subprogramas demasiado largos.\n",
    "\n",
    "- Nombrar las funciones de manera pobre y poco diciente. \n",
    "\n",
    "- No utilizar comentarios para documentar el funcionamiento de los subprogramas.\n",
    "\n",
    "- Definir una variable con el mismo nombre que un subprograma o viceversa (se pierde el valor anterior)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Definir funciones en Python </h1> </center>\n",
    "\n",
    "- Las funciones en Python se definen con la palabra clave **def** acompañada del nombre y entre paréntesis la lista de parámetros.\n",
    "\n",
    "- Después de los paréntesis *se deben* colocar dos puntos (:) y el bloque de código que corresponde a la función va con un nivel de indentación.\n",
    "\n",
    "- La última línea de la función puede ser la instrucción **return** o cualquier otra instrucción. Para dejar claro que la función se acaba nos devolvemos un nivel de indentación.\n",
    "\n",
    "- Los parámetros son, en esencia, nombres de variables que serán utilizados dentro de la función."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> Esquema general de una función en Python </h1> </center>\n",
    "<br/>\n",
    "<center> <img width=\"700\" src=\"img/sem3_esquema.png\"> </center>\n",
    "\n",
    "Nota: en Python, cuando comentamos una función con una cadena entre comillas triples, este se denomina [***docstring***](https://www.python.org/dev/peps/pep-0257/) y se espera que sea una [documentación detallada de la misma](https://python-para-impacientes.blogspot.com/2014/02/docstrings.html).\n",
    "\n",
    "Fuente: https://j2logo.com/python/tutorial/funciones-en-python/\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Usar funciones en Python </h1> </center>\n",
    "\n",
    "- Si una función se define en el mismo archivo, basta con escribir su nombre seguido por un par de paréntesis.\n",
    "\n",
    "- Si la función tiene *parámetros*, estos pueden mandarse ya sea en orden o como una asignación dentro de los paréntesis.\n",
    "\n",
    "- Ojo, a los valores que recibe una función al momento de usarla se los denomina *argumentos*.\n",
    "\n",
    "- Al momento de ejecutar una función, es como si estuviéramos \"pegando\" en su lugar todo el código que contiene.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "<center><img width=\"600\" src=\"img/sem3_func_ej.png\"></center>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estás haciéndolo bien, Pablo.\n",
      "Muchas gracias por tus contribuciones a este proyecto.\n",
      "Estás haciéndolo bien, Ana.\n",
      "Muchas gracias por tus contribuciones a este proyecto.\n",
      "Estás haciéndolo bien, Paola.\n",
      "Muchas gracias por tus contribuciones a este proyecto.\n"
     ]
    }
   ],
   "source": [
    "print(\"Estás haciéndolo bien, Pablo.\")\n",
    "print(\"Muchas gracias por tus contribuciones a este proyecto.\")\n",
    "\n",
    "print(\"Estás haciéndolo bien, Ana.\")\n",
    "print(\"Muchas gracias por tus contribuciones a este proyecto.\")\n",
    "\n",
    "print(\"Estás haciéndolo bien, Paola.\")\n",
    "print(\"Muchas gracias por tus contribuciones a este proyecto.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Estás haciéndolo muy bien, Pedro.\n",
      "Muchas gracias por tus contribuciones a este proyecto.\n",
      "\n",
      "Estás haciéndolo muy bien, Pablo.\n",
      "Muchas gracias por tus contribuciones a este proyecto.\n"
     ]
    }
   ],
   "source": [
    "def agradecimiento(nombre):\n",
    "    \"\"\"\n",
    "    Esta función imprime un agradecimiento personalizado \n",
    "    a partir de un nombre dado.\n",
    "    \n",
    "    Parámetros:\n",
    "    \n",
    "    --- nombre -- un objeto de tipo cadena con el nombre de la persona a saludar.\n",
    "    \"\"\"\n",
    "    \n",
    "    print(f\"\\nEstás haciéndolo muy bien, {nombre}.\")\n",
    "    print(\"Muchas gracias por tus contribuciones a este proyecto.\")\n",
    "\n",
    "#A partir de la línea 13 ya no estamos dentro de la función.    \n",
    "    \n",
    "#Llamada de función sin explicitar el nombre del parámetro.\n",
    "agradecimiento(\"Pedro\")\n",
    "\n",
    "#Llamada de función con el nombre del parámetro explícito.\n",
    "agradecimiento(nombre = \"Pablo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "agradecimiento() missing 1 required positional argument: 'nombre'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-2e0a4cc14807>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Si no mandamos el argumento, tendremos un error...\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0magradecimiento\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: agradecimiento() missing 1 required positional argument: 'nombre'"
     ]
    }
   ],
   "source": [
    "# Si no mandamos el argumento, tendremos un error...\n",
    "agradecimiento()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Manipulación básica de parámetros </h1> </center>\n",
    "\n",
    "Hay varias formas de definir parámetros para una función, como se intuye arriba...\n",
    "\n",
    "- Se puede definir una función sin parámetros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 "
     ]
    }
   ],
   "source": [
    "def imprimir_1_al_10():\n",
    "    for i in range(1,55): \n",
    "        print(i, end = \" \")\n",
    "\n",
    "imprimir_1_al_10()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Se puede definir los parámetros sin mayor detalle, y se pueden explicitar o no al usar la función."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 \n",
      "\n",
      "0 1 2 3 4 5 \n",
      "\n",
      "-10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 "
     ]
    }
   ],
   "source": [
    "def imprimir_rango(val_ini, val_fin):\n",
    "    for i in range(val_ini, val_fin+1): \n",
    "        print(i, end = \" \")\n",
    "\n",
    "imprimir_rango(1, 10)\n",
    "print(\"\\n\")\n",
    "imprimir_rango(val_ini = 0, val_fin = 5)\n",
    "print(\"\\n\")\n",
    "imprimir_rango(val_fin = 20, val_ini = -10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Se puede definir los parámetros con valores por defecto, para no tener que mandar ciertos argumentos cada vez que usamos la función (¿recuerdan el parámetro *end* del **print**?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 11 12 13 14 15 16 17 18 19 20 \n",
      "\n",
      "0 1 2 3 4 5 "
     ]
    }
   ],
   "source": [
    "def imprimir_rango(val_ini = 0, val_fin = 20):\n",
    "    for i in range(val_ini, val_fin+1): \n",
    "        print(i, end = \" \")\n",
    "    \n",
    "imprimir_rango(10)\n",
    "print(\"\\n\")\n",
    "#Nota, para que se use el valor por defecto de una variable debemos explicitar los parámetros siguientes...\n",
    "imprimir_rango(val_fin = 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Pero no pueden mandarse argumentos sin definir el nombre del parámetro una vez se defina explícitamente uno anterior..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (<ipython-input-36-0a7027e73c1c>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-36-0a7027e73c1c>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    imprimir_rango(val_ini = 20, 50)\u001b[0m\n\u001b[1;37m                                ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "imprimir_rango(val_ini = 20, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- De igual forma, se pueden establecer parámetros indeterminados. Para eso, utilizamos un asterisco antes del nombre de la variable que los contendrá a todos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 'Hola', False)\n"
     ]
    }
   ],
   "source": [
    "def imprimir_parametros(*params):\n",
    "    print(params)\n",
    "    \n",
    "imprimir_parametros(1, \"Hola\", False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "... y esto solo es el principio, más aquí: https://docs.python.org/es/3/tutorial/controlflow.html#defining-functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> Funciones integradas en Python </h1> </center>\n",
    "<br/>\n",
    "\n",
    "<center> <img src=\"img/builtin.png\"> </center>\n",
    "\n",
    "Fuente: https://docs.python.org/es/3/library/functions.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese un número positivo o negativo: -10\n",
      "El valor absoluto de -10 es 10\n"
     ]
    }
   ],
   "source": [
    "num = int(input(\"Ingrese un número positivo o negativo: \"))\n",
    "res = abs(num)\n",
    "print(f\"El valor absoluto de {num} es {res}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese un número: 2\n",
      "Ingrese otro número: 3\n",
      "La división de 2.0/3.0 redondeada a 2 cifras dec. es 0.66667\n"
     ]
    }
   ],
   "source": [
    "num1 = float(input(\"Ingrese un número: \"))\n",
    "num2 = float(input(\"Ingrese otro número: \"))\n",
    "res = round(num1/num2, 5)\n",
    "print(f\"La división de {num1}/{num2} redondeada a 2 cifras dec. es {res}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function chr in module builtins:\n",
      "\n",
      "chr(i, /)\n",
      "    Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(chr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Exploremos Unicode en: https://en.wikipedia.org/wiki/List_of_Unicode_characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese un número positivo: 247\n",
      "El número correspondiente a 247 en el sistema unicode es ÷\n"
     ]
    }
   ],
   "source": [
    "num = int(input(\"Ingrese un número positivo: \"))\n",
    "unic = chr(num)\n",
    "print(f\"El número correspondiente a {num} en el sistema unicode es {unic}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Ejercicios con funciones </h1> </center>\n",
    "\n",
    "Elabore dos fragmentos de código tales que:\n",
    "\n",
    "- en el primero defina una función y luego una variable con el mismo nombre, ejecútelo y observe qué ocurre.\n",
    "\n",
    "- en el segundo defina una variable y luego una función con el mismo nombre, ejecútelo y observe qué ocurre.\n",
    "\n",
    "En el primer caso, intente utilizar la función, en el segundo, la variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for *: 'function' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-27-27ff75cbc668>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     14\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 16\u001b[1;33m \u001b[0mres\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnumero\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     17\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mres\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for *: 'function' and 'int'"
     ]
    }
   ],
   "source": [
    "#def es_par(x):\n",
    "#    if x%2 == 0:\n",
    "#        return True\n",
    "#    else:\n",
    "#        return False   \n",
    "#es_par = False\n",
    "#print(es_par(10))\n",
    "\n",
    "numero = 10\n",
    "def numero(x):\n",
    "    if x%2 == 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "res = numero*10\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Ejercicios con funciones </h1> </center>\n",
    "\n",
    "\n",
    "Tomemos nuestro ejercicio de la escalera de la ocasión pasada, pero ahora vamos a hacer que la altura sea arbitraria en función de un parámetro **altura**. Por ejemplo, si le pasamos a la función el argumento 4, la función debería mostrar por pantalla lo siguiente:\n",
    "\n",
    "1<br/>\n",
    "22<br/>\n",
    "333<br/>\n",
    "4444<br/>\n",
    "\n",
    "Anotación: ¿qué debería hacerse si la entrada es negativa o cero?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "22\n",
      "333\n",
      "4444\n",
      "55555\n",
      "666666\n",
      "7777777\n",
      "88888888\n",
      "999999999\n",
      "10101010101010101010\n",
      "1111111111111111111111\n",
      "121212121212121212121212\n",
      "13131313131313131313131313\n",
      "1414141414141414141414141414\n",
      "151515151515151515151515151515\n"
     ]
    }
   ],
   "source": [
    "def escalera(altura):\n",
    "    for num_piso in range(1, altura+1):\n",
    "        for n in range(num_piso):\n",
    "            print(num_piso, end = \"\")\n",
    "        print(\"\")\n",
    "\n",
    "escalera(15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "22\n",
      "333\n",
      "4444\n"
     ]
    }
   ],
   "source": [
    "def escalera(altura):\n",
    "    for i in range(1, altura):\n",
    "        for j in range(1, i+1):\n",
    "            print(i, end=\"\")\n",
    "        print(\"\")\n",
    "\n",
    "escalera(5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Ejercicios con funciones </h1> </center>\n",
    "\n",
    "Hagamos lo mismo con nuestro ejercicio de las tablas de multiplicar. Esta vez, desarrollaremos una función con el argumento **número**. La función debe imprimir la tabla de multiplicar del 1 al 10 para el número dado. Luego de definir la función, elabore un ciclo **for** o **while** que la use para mostrar las tablas del 1 al 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Valores de retorno </h1> </center>\n",
    "\n",
    "- Las funciones en Python siempre tienen valores de retorno y estos son los que nos permiten explotar al máximo las funcionalidades de Python.\n",
    "\n",
    "- Por norma general, se define un único valor de retorno, pero se pueden definir varios valores de retorno entre paréntesis y separados por coma. Ej: ```(res1, res2, res3)``` \n",
    "\n",
    "- Una función puede tener varias instrucciones de return, pero solo se puede activar una en cada ejecución (por ejemplo, con condicionales).\n",
    "\n",
    "- Si el valor de retorno no se define, este toma el valor de **None**.\n",
    "\n",
    "Nota: ojo, el retorno múltiple solo se recomienda si los valores están relacionados lo suficiente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola mundo.\n",
      "Hello world!\n",
      "---------\n",
      "None None\n"
     ]
    }
   ],
   "source": [
    "def mensaje1():\n",
    "    print(\"Hola mundo.\")\n",
    "\n",
    "def mensaje2():\n",
    "    print(\"Hello world!\")\n",
    "res1 = mensaje1()\n",
    "res2 = mensaje2()\n",
    "print(\"---------\")\n",
    "print(res1, res2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "def suma(num1, num2):\n",
    "    res = num1 + num2\n",
    "    return res\n",
    "\n",
    "x = 10\n",
    "y = 8\n",
    "res = suma(x, y)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Al dividir 10 sobre 3 el resultado de la división entera es 3 y el residuo es 1\n"
     ]
    }
   ],
   "source": [
    "def divint_mod(num1,num2):\n",
    "    division_entera = num1//num2\n",
    "    residuo = num1%num2\n",
    "    return division_entera, residuo\n",
    "\n",
    "num1 = 10\n",
    "num2 = 3\n",
    "div, residuo = divint_mod(num1, num2)\n",
    "print(f\"Al dividir {num1} sobre {num2} el resultado de la división entera es {div} y el residuo es {residuo}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese un número por teclado: 2\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def es_par(num):\n",
    "    if num%2 == 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "num = int(input(\"Ingrese un número por teclado: \"))\n",
    "print(es_par(num))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 1)\n"
     ]
    }
   ],
   "source": [
    "print(divmod(10,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function divmod in module builtins:\n",
      "\n",
      "divmod(x, y, /)\n",
      "    Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(divmod)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'olbaP'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "help(divint_mod)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Ejercicio con valor de retorno </h1> </center>\n",
    "\n",
    "Escribir un programa que determine si una frase o una palabra es un palíndromo. Un palíndromo es una cadena de caracteres que se leen de igual forma en ambos sentidos; por ejemplo: ana. La función debe devolver True si es palíndromo y False de lo contrario. \n",
    "\n",
    "Recomendación: usar la función reversed()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def es_palindromo(palabra):\n",
    "    pass\n",
    "\n",
    "\n",
    "#nombre = \"Pablo\"\n",
    "#reverso = \"\"\n",
    "#for caracter in reversed(nombre):\n",
    "#    reverso = reverso + caracter\n",
    "#reverso"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Ejemplo de un algoritmo que debería elaborarse como función </h1> </center>\n",
    "\n",
    "Una necesidad frecuente e importante en la vida diaria es conocer el número de combinaciones que se pueden construir con n elementos tomados en grupos de a r. Por ejemplo, si se tiene un equipo de baloncesto y se dispone de 8 jugadores, se busca determinar cuántas formaciones diferentes se pueden hacer.\n",
    "\n",
    "Matemáticamente, la solución está dada por la fórmula:\n",
    "\n",
    "$$ ^{n}C_{r} = \\frac{n!}{r!*(n-r)!} $$\n",
    "\n",
    "donde n es el total de elementos y r el número de elementos a escoger.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entre valor de n 8\n",
      "Entre valor de r 3\n",
      "n = 8  r = 3  Factorial de n = 40320  Factorial de r = 6  Factorial de n − r = 120  Número de combinaciones = 56\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Entre valor de n \"))\n",
    "r = int(input(\"Entre valor de r \"))\n",
    "fn = 1\n",
    "for i in range(1, n + 1):\n",
    "    fn = fn * i\n",
    "fr = 1\n",
    "for i in range(1, r + 1):\n",
    "    fr = fr * i\n",
    "fnr = 1\n",
    "for i in range(1, n - r + 1):\n",
    "    fnr = fnr * i\n",
    "\n",
    "nc = fn // fr // fnr\n",
    "print(\"n =\", n, \" r =\", r, \" Factorial de n =\", fn, \" Factorial de r =\", fr, \" Factorial de n − r =\", fnr, \" Número de combinaciones =\", nc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Elaboremos este ejercicio con una función de factorial..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Alcance o ámbito de las variables </h1> </center>\n",
    "\n",
    "- Al utilizar funciones tenemos una gran ventaja: los nombres de las variables quedan encapsulados dentro de la función. A estas variables las llamamos variables *locales*.\n",
    "\n",
    "- Esto quiere decir que si definimos una variable dentro de una función, el valor desaparecerá cuando salgamos de esta (salvo que lo retornemos).\n",
    "\n",
    "- De manera análoga, no deberíamos usar dentro de una función una variable definida por fuera de la misma, incluso si esto no resulta en errores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100.0\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'paso2' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-55-32e29b9ddd35>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresultado\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m#Tenemos acceso al valor de paso2 como resultado ya que lo retornamos.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpaso2\u001b[0m\u001b[1;33m)\u001b[0m     \u001b[1;31m#Pero no tenemos acceso a paso1 ni a paso2,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     10\u001b[0m                  \u001b[1;31m#ya que es una variable local en la función operación.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'paso2' is not defined"
     ]
    }
   ],
   "source": [
    "def operacion(val1, val2):   #val1 y val2 son los parámetros\n",
    "    paso1 = val1*val2/5      #paso1 y paso2 son variables locales\n",
    "    paso2 = paso1**2 \n",
    "    return paso2             #aunque paso2 es local, devolvemos su valor\n",
    "\n",
    "resultado = operacion(5, 10) #resultado guarda el valor de paso2, pero no su nombre\n",
    "\n",
    "print(resultado) #Tenemos acceso al valor de paso2 como resultado ya que lo retornamos.\n",
    "print(paso2)     #Pero no tenemos acceso a paso1 ni a paso2, \n",
    "                 #ya que es una variable local en la función operación."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Variables globales </h1> </center>\n",
    "\n",
    "- Python permite acceder a variables definidas por fuera de una función. Sin embargo, no podremos modificar el valor de la variable por dentro de la función (aunque sí lo podemos definir de nuevo).\n",
    "\n",
    "- En caso de que queramos modificarlos, debemos definirlos como variable **global**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exponente antes de ejecutar la operación 2: 3\n",
      "Exponente después de ejecutar la operación 2: 3\n",
      "Resultado: 32\n"
     ]
    }
   ],
   "source": [
    "exponente = 3\n",
    "def operacion2(val1, val2):   \n",
    "    paso1 = val1*val2\n",
    "    exponente = 5            #definimos la variable dentro de la función, \n",
    "                             #así que la referencia global se pierde\n",
    "    paso2 = paso1**exponente \n",
    "    return paso2\n",
    "\n",
    "print(f\"Exponente antes de ejecutar la operación 2: {exponente}\")\n",
    "resultado = operacion2(2, 1) #resultado guarda el valor de paso2\n",
    "print(f\"Exponente después de ejecutar la operación 2: {exponente}\")\n",
    "print(f\"Resultado: {resultado}\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resultado: 8\n"
     ]
    }
   ],
   "source": [
    "exponente = 3\n",
    "def operacion2(val1, val2):   \n",
    "    paso1 = val1*val2\n",
    "    paso2 = paso1**exponente #exponente se define por fuera de la función, pero es un valor solo de lectura\n",
    "    return paso2    \n",
    "\n",
    "resultado = operacion2(2, 1) #resultado guarda el valor de paso2\n",
    "print(f\"Resultado: {resultado}\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'exponente' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-70-016bfb7392d7>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mpaso2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[0mresultado\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0moperacion2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m#resultado guarda el valor de paso2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Resultado: {resultado}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-70-016bfb7392d7>\u001b[0m in \u001b[0;36moperacion2\u001b[1;34m(val1, val2)\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0moperacion2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mval1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mval2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mpaso1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mval1\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mval2\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m     \u001b[0mpaso2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpaso1\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mexponente\u001b[0m \u001b[1;31m#exponente se define por fuera de la función, pero es un valor solo de lectura\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m     \u001b[0mexponente\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m5\u001b[0m            \u001b[1;31m#intentamos cambiar el valor tras utilizarlo, incurrimos en error de definición\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mpaso2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'exponente' referenced before assignment"
     ]
    }
   ],
   "source": [
    "exponente = 3\n",
    "def operacion2(val1, val2):   \n",
    "    paso1 = val1*val2/5 \n",
    "    paso2 = paso1**exponente #exponente se define por fuera de la función, pero es un valor solo de lectura\n",
    "    exponente = 5            #intentamos cambiar el valor tras utilizarlo, incurrimos en error de definición\n",
    "    return paso2    \n",
    "\n",
    "resultado = operacion2(5, 10) #resultado guarda el valor de paso2\n",
    "print(f\"Resultado: {resultado}\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100.0\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'paso1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-54-d6949bc5e755>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresultado\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m#Tenemos acceso al valor de paso2 como resultado ya que lo retornamos\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpaso1\u001b[0m\u001b[1;33m)\u001b[0m     \u001b[1;31m#Pero el valor de paso1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'paso1' is not defined"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exponente antes de ejecutar la operación 2: 3\n",
      "Exponente después de ejecutar la operación 2: 4\n",
      "Resultado: 16\n"
     ]
    }
   ],
   "source": [
    "exponente = 3\n",
    "def operacion2(val1, val2): \n",
    "    global exponente #establecemos que exponente es global\n",
    "    paso1 = val1*val2\n",
    "    exponente = exponente + 1 #modificamos el valor de la variable global\n",
    "    paso2 = paso1**exponente \n",
    "    return paso2    \n",
    "\n",
    "print(f\"Exponente antes de ejecutar la operación 2: {exponente}\")\n",
    "resultado = operacion2(2, 1) #resultado guarda el valor de paso2\n",
    "print(f\"Exponente después de ejecutar la operación 2: {exponente}\")\n",
    "print(f\"Resultado: {resultado}\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <h1> Advertencia </h1> </center>\n",
    "\n",
    "- Ojo, hacer uso de variables globales es muy mala práctica. En general, no se recomienda salvo que sea estrictamente necesario (por ejemplo, una solución de procesamiento paralelo muy rudimentaria)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center> <h1> Mutabilidad </h1> </center>\n",
    "\n",
    "- En Python, algunos tipos de datos son mutables y otros son inmutables. Por ahora, hablaremos sobre los inmutables.\n",
    "\n",
    "- Un tipo de dato inmutable no se puede modificar. Esto se ve reflejado al pasarlo como parámetro a una función. Si pasamos una variable inmutable, cualquier cosa que hagamos sobre esta no se verá reflejada por fuera salvo que la definamos como global.\n",
    "\n",
    "- Ejemplos de tipos de dato no mutables: cadenas, literales numéricos y lógicos.\n",
    "\n",
    "- El día jueves veremos algunos tipos de dato mutables y tendremos oportunidad de hacer algunos ejemplos..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-76-af607c773040>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mcadena\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"MINTIC\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mcadena\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"m\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "#Por ahora...\n",
    "\n",
    "cadena = \"MINTIC\"\n",
    "cadena[0] = \"m\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><h1> Creación de archivos con funciones... </h1> </center>\n",
    "\n",
    "- Aunque hemos elaborado funciones para muchas tareas y esto ha resultado en un código más organizado, es importante convertir nuestro código en módulos separados por archivos.\n",
    "\n",
    "- La ventaja de modularizar el código es que reduce el tamaño de nuestro archivo de trabajo principal y hace que sea más fácil darle mantenimiento a toda nuestra base de código.\n",
    "\n",
    "- Otra ventaja importante es que al modularizar el código podremos tener archivos reutilizables con las funciones que más usamos.\n",
    "\n",
    "- Para traer a nuestro programa un archivo usamos la palabra reservada **import**.\n",
    "\n",
    "Nota: ojo, si estamos trabajando en jupyter, cada vez que modifiquemos nuestro código debemos reiniciar el kernel."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><h1> Alternativas para importar desde archivos... </h1> </center>\n",
    "\n",
    "Lo primero que debemos tener en cuenta es que el nombre del archivo (sin el .py) será la palabra con la que lo referenciaremos.\n",
    "\n",
    "- Podemos importar una única función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function saludar_con_apellido in module saludos:\n",
      "\n",
      "saludar_con_apellido(nombre, apellido, titulo='')\n",
      "    Esta función recibe un nombre, un apellido y un título\n",
      "    e imprime un saludo personalizado.\n",
      "    \n",
      "    --- nombre: primer nombre de la persona.\n",
      "    --- apellido: primer apellido de la persona.\n",
      "    --- titulo: título de la persona (opcional).\n",
      "\n",
      "Hola Alberto Ceballos, es un gusto verle por aquí.\n"
     ]
    }
   ],
   "source": [
    "from saludos import saludar_con_apellido\n",
    "\n",
    "help(saludar_con_apellido) #Cuando hacemos archivos es importantísimo documentar.\n",
    "saludar_con_apellido(\"Alberto\", \"Ceballos\",\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Podemos importar todas las funciones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola Pablo, es un gusto verle por aquí.\n",
      "Hola Dra. Marta Lopero, es un gusto verle por aquí.\n"
     ]
    }
   ],
   "source": [
    "from saludos import *\n",
    "\n",
    "saludar(\"Pablo\")\n",
    "saludar_con_apellido(\"Marta\",\"Lopero\",\"Dra.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Podemos importar el archivo como tal y usar el identificador del archivo como referencia. Esto tiene la ventaja de que incluso si sobreescribimos las funciones por error no se perderá la definición original."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'NoneType' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-67-fc8901f99124>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0msaludos\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0msaludos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msaludar\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Pablo\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[0msaludos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msaludar_con_apellido\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Marta\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"Lopero\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"Dra.\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'NoneType' object is not callable"
     ]
    }
   ],
   "source": [
    "import saludos\n",
    "\n",
    "saludos.saludar(\"Pablo\")\n",
    "saludos.saludar_con_apellido(\"Marta\",\"Lopero\",\"Dra.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Los ejemplos anteriores asumen que el archivo desde el que importamos está en la misma carpeta que el archivo importado.\n",
    "\n",
    "- Si el archivo a importar está dentro de una subcarpeta, imitamos la ruta separando cada subcarpeta por . (punto).\n",
    "\n",
    "- En todo caso, debemos crear siempre un archivo \\_\\_init\\_\\_.py en ambas carpetas.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 es primo.\n",
      "5 es primo.\n"
     ]
    }
   ],
   "source": [
    "from utils.operaciones import es_primo\n",
    "\n",
    "num = 5\n",
    "pr = es_primo(num)\n",
    "if pr:\n",
    "    print(f\"{num} es primo.\")\n",
    "else:\n",
    "    print(f\"{num} NO es primo.\")\n",
    "    \n",
    "    \n",
    "from utils import operaciones\n",
    "\n",
    "num = 5\n",
    "pr = operaciones.es_primo(num)\n",
    "if pr:\n",
    "    print(f\"{num} es primo.\")\n",
    "else:\n",
    "    print(f\"{num} NO es primo.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Aunque podemos usar **from** *x* **import** *y*, donde *x* es la subcarpeta, *y* el archivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 es primo.\n"
     ]
    }
   ],
   "source": [
    "from utils import operaciones\n",
    "\n",
    "num = 3\n",
    "pr = operaciones.es_primo(num)\n",
    "if pr:\n",
    "    print(f\"{num} es primo.\")\n",
    "else:\n",
    "    print(f\"{num} NO es primo.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><h1> Ejercicios con archivos... </h1> </center>\n",
    "\n",
    "Ya tenemos el archivo operaciones creado en el repositorio. Ahora, probemos a expandirlo con las siguientes funciones:\n",
    "\n",
    "    - mcd (máximo común divisor de dos números)\n",
    "    - mcm (mínimo común múltiplo de dos números)\n",
    "    - digito_inicial (obtener el primer dígito de un número)\n",
    "    \n",
    "    \n",
    "    \n",
    "A partir de lo anterior, elabore un archivo principal que importe el archivo, lea dos números enteros y determine:\n",
    "\n",
    "1. Si alguno de ellos es número primo.\n",
    "2. El máximo común divisor de ellos.\n",
    "3. El mínimo común múltiplo de ellos.\n",
    "4. El dígito con el que comienza cada uno de ellos.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ingrese el primer numero: 5\n",
      "Ingrese el segundo numero: 10\n"
     ]
    }
   ],
   "source": [
    "num1 = int(input(\"Ingrese el primer numero: \"))\n",
    "num2 = int(input(\"Ingrese el segundo numero: \"))\n",
    "\n",
    "# ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><h1> Otros recursos... </h1> </center>\n",
    "\n",
    "- https://j2logo.com/python/tutorial/funciones-en-python/ <- muy bueno.\n",
    "- https://www.freecodecamp.org/espanol/news/guia-de-funciones-de-python-con-ejemplos/\n",
    "- https://www.w3schools.com/python/python_functions.asp\n",
    "- https://unipython.com/modulos-en-python/\n",
    "- https://www.mclibre.org/consultar/python/lecciones/python-funciones-2.html\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><h1> Preguntas... </h1> </center>\n",
    "\n",
    "\n",
    "- Pregunta:\n",
    "    - R/:\n",
    "    \n",
    "\n",
    "- Pregunta:\n",
    "    - R/:\n",
    "    \n",
    " \n",
    "- Pregunta:\n",
    "    - R/:\n",
    "    \n",
    "    \n",
    "- Pregunta:\n",
    "    - R/:\n",
    "    \n",
    "    \n",
    "- Pregunta:\n",
    "    - R/:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}