4-Introducción a Funciones.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducción a Funciones\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones (Métodos) en Python \n",
    "\n",
    "Son unidades pequeñas dentro de una construcción más grande que genera una salida esperada. Si se piensa en un televisor, cada botón en el control remoto cumple una función (subir volumen, bajar volumen, etc..)\n",
    "\n",
    "Las funciones tienen dos categorías: \n",
    "\n",
    "- Funciones incluídas (len, append, pop, etc..).\n",
    "- Funciones definidas por el usuario\n",
    "\n",
    "En programación, así como en matemáticas, para las funciones definidas como $f: A \\to B$, al conjunto $A$ se le denomina dominio y al conjunto $B$ como rango. A partir de estos objetos se construye el encabezado de las funciones de programación.\n",
    "\n",
    "Sobre esta función se tiene que $f$ corresponde al nombre de la función, el conjunto $A$ corresponde al tipo de los argumentos de dicha función y el conjunto $B$ que es el rango corresponderá al valor de retorno de dicha función."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones con un parámetro de entrada: cuadrado de un número\n",
    "\n",
    "Se definirá una función que eleve un número dado al cuadrado. Para expresar una función que calcule esta operación, en primera instancia debe pensar en el dominio y en el rango de la función $f: \\mathbb{R} \\to \\mathbb{R}$ que define la función tiene como entrada (dominio) un número real $x$ y como salida (rango) un número real. \n",
    "\n",
    "La declaración de la función junto con su cuerpo quedará de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "354\n",
      "125316.0\n"
     ]
    }
   ],
   "source": [
    "def cuadrado(x):\n",
    "   \"\"\"\n",
    "   Input: x, a float\n",
    "   Returns square of x\n",
    "   \"\"\"\n",
    "   return x**2\n",
    "\n",
    "def main():\n",
    "    var = float(input())\n",
    "    print(cuadrado(var))\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Área de un círculo \n",
    "\n",
    "Para el desarrollo de esta función lo primero es determinar el nombre. La función se llamará $area\\_circulo$ cuyo dominio es el conjunto de los números reales (para el radio) y cuyo rango pertenece al conjunto de los números reales (el valor de retorno que corresponde al área del círculo).  \n",
    "\n",
    "Teniendo en cuenta que el algoritmo para el cálculo del área de un círculo depende del valor de su radio, entonces, el área del círculo está dada por la expresión $A_c = \\pi*r^2$, donde las variables están definidas y el planteamiento matemático de la función solicitada será el siguiente:\n",
    "\n",
    "\\begin{align*}\n",
    "area\\_circulo: \\mathbb{R} &\\to \\mathbb{R}\\\\\n",
    "(r) &\\mapsto 3.14159265*r*r\n",
    "\\end{align*}\n",
    "\n",
    "En python se tendrá:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi\n",
    "\n",
    "def area_circulo(r):\n",
    "  \"\"\"\n",
    "  Input: r correspondiente al radio\n",
    "  Returns: área del círculo\n",
    "  \"\"\"\n",
    "  return pi*r*r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "digite el radio:4\n",
      "50.26548245743669\n"
     ]
    }
   ],
   "source": [
    "radio = float(input('digite el radio:'))\n",
    "resultado = area_circulo(radio)\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones con más de un parámetro de entrada: área de un rectángulo\n",
    "\n",
    "La función que calcula el área de un rectángulo es una función que tiene como parámetros de entrada el ancho y el largo del rectángulo que son valores de tipo real y retorna como salida el área del rectángulo. Lo que puede escribirse como $$area\\_rectangulo: \\mathbb{R} \\times \\mathbb{R} \\to \\mathbb{R}.$$\n",
    "\n",
    "Para el calculo del área de un rectángulo es necesario conocer el largo y el ancho del rectángulo, a partir de los cuales el área del rectángulo está dada por la expresión $A_r = l * a$, donde las variables están definidas así:\n",
    "\n",
    "\n",
    "Entonces, la función matemática queda definida de la siguiente forma:\n",
    "\n",
    "\\begin{align*}\n",
    "area\\_rectangulo: \\mathbb{R} \\times \\mathbb{R} &\\to \\mathbb{R}\\\\\n",
    "(l,a) &\\mapsto l*a\n",
    "\\end{align*}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def area_rectangulo(l, a):\n",
    "  \"\"\"\n",
    "  Input: l correspondiente al largo\n",
    "         a correspondiente al ancho\n",
    "  Returns: área del rectángulo\n",
    "  \"\"\"\n",
    "  return l*a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "digite el largo del rectángunlo: 10\n",
      "digite el ancho del rectángunlo: 2\n",
      "El área del rectángulo es: 20.0\n"
     ]
    }
   ],
   "source": [
    "largo = float(input('digite el largo del rectángunlo: '))\n",
    "ancho = float(input('digite el ancho del rectángunlo: '))\n",
    "print(\"El área del rectángulo es:\", area_rectangulo(largo, ancho))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ejercicio 1: \n",
    "\n",
    "Utilizando los métodos area_rectangulo y area_circulo, escriba una función para calcular el área del vagón que se da a continuación:\n",
    "\n",
    "![](https://raw.githubusercontent.com/arleserp/cursopython/master/images//vagon.png \"El vagon\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "largo?3\n",
      "ancho?2\n",
      "radio?2\n",
      "31.132741228718345\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 2: \n",
    "\n",
    "Utilizando los métodos area_rectangulo y area_circulo, escriba un método para calcular el área del carrito que se da a continuación:\n",
    "\n",
    "![](https://raw.githubusercontent.com/arleserp/cursopython/master/images/carrito.png \"El carrito\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Información adicional sobre Funciones\n",
    "\n",
    "Existen también funciones sin argumentos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Students of MinTIC 2022\n",
      "Hello Students of MinTIC 2022\n"
     ]
    }
   ],
   "source": [
    "#funciones sin argumentos.\n",
    "\n",
    "def sayHi():\n",
    "    name = input()\n",
    "    print('Hello', name)\n",
    "\n",
    "sayHi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funciones con argumentos y sin retorno"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "People\n",
      "Hello People\n"
     ]
    }
   ],
   "source": [
    "def sayHi(name):\n",
    "    print('Hello', name)\n",
    "\n",
    "name = input()\n",
    "sayHi(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funciones con argumentos y retorno:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "World!\n",
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "def sayHi(name):\n",
    "    return 'Hello ' + name\n",
    "\n",
    "name = input()\n",
    "print(sayHi(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones con argumentos por defecto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede especificar un valor por defecto para una función de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "log en base 2 de 1024:  10\n",
      "logaritmo entero en base 10 de 1000:  3\n",
      "logaritmo entero en base 3 de 9:  2\n"
     ]
    }
   ],
   "source": [
    "def log_entero(num, base=2):\n",
    "    cont = 0 \n",
    "    while num >= base:\n",
    "        cont+=1\n",
    "        num /= base\n",
    "    return cont\n",
    "\n",
    "print(\"log en base 2 de 1024: \", log_entero(1024))\n",
    "print(\"logaritmo entero en base 10 de 1000: \", log_entero(1000, 10)) \n",
    "print(\"logaritmo entero en base 3 de 9: \", log_entero(9, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones con un número de argumentos variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para pasar más parámetros de los que que se especificó al definir la función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "salida:60\n",
      "salida:100\n",
      "90\n",
      "67\n",
      "23\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "def variable_argument(var1, *vari):\n",
    "    print('salida:'+ str(var1))    \n",
    "    for var in vari:\n",
    "        print(var)\n",
    "\n",
    "variable_argument(60)\n",
    "variable_argument(100, 90, 67, 23, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible enviar parejas llave valor como argumentos de longitud variable a un método:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "llamado con 3 argumentos:\n",
      "{'age': 20, 'city': 'Los Angeles', 'name': 'l4w'}\n",
      "'name == l4w'\n",
      "'age == 20'\n",
      "'city == Los Angeles'\n",
      "\n",
      "llamado con 4 argumentos:\n",
      "{'age': 45, 'city': 'London', 'medals': 0, 'name': 'John', 'sex': 'male'}\n",
      "'name == John'\n",
      "'age == 45'\n",
      "'city == London'\n",
      "'sex == male'\n",
      "'medals == 0'\n"
     ]
    }
   ],
   "source": [
    "from pprint import pprint \n",
    "\n",
    "def infocity(**var):\n",
    "    pprint(var)\n",
    "    for key, value in var.items():\n",
    "        pprint(\"%s == %s\" %(key,value))\n",
    "\n",
    "print('llamado con 3 argumentos:')\n",
    "infocity(name=\"l4w\", age = 20, city=\"Los Angeles\")\n",
    "\n",
    "print('\\nllamado con 4 argumentos:')\n",
    "infocity(name=\"John\",age=45, city=\"London\", sex=\"male\", medals=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paso de parámetros en python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En python el paso de parámetros a funciones se realiza por referencia. Durante la llamada a una función se utiliza el valor pasado como dirección a la dirección pasada a este y cualquier cambio afecta también a la variable fuente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Tony', 'Natalia', 'Steve', 'Thor', 'Peter']\n"
     ]
    }
   ],
   "source": [
    "def unir_listas(list1, list2):\n",
    "    list1.extend(list2)\n",
    "\n",
    "avengers = ['Tony', 'Natalia', 'Steve']\n",
    "nuevos_avengers = ['Thor', 'Peter']\n",
    "\n",
    "unir_listas(avengers, nuevos_avengers)\n",
    "print(avengers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[ver en pythontutor](http://pythontutor.com/visualize.html#code=def%20unir_listas%28list1,%20list2%29%3A%0A%20%20%20%20list1.extend%28list2%29%0A%0Aavengers%20%3D%20%5B'Tony',%20'Natalia',%20'Steve'%5D%0Anuevos_avengers%20%3D%20%5B'Thor',%20'Peter'%5D%0A%0Aunir_listas%28avengers,%20nuevos_avengers%29%0Aprint%28avengers%29&cumulative=false&heapPrimitives=nevernest&mode=edit&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En los siguientes ejemplos el valor de a no se afecta el valor por la asignación que se está realizando dentro de la función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    }
   ],
   "source": [
    "def func(a):\n",
    "    a *= 10\n",
    "\n",
    "a = 45\n",
    "func(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[ver en pythontutor](http://pythontutor.com/visualize.html#code=def%20func%28a%29%3A%0A%20%20%20%20a%20*%3D%2010%0A%0Aa%20%3D%2045%0Afunc%28a%29%0Aprint%28a%29&cumulative=false&curInstr=6&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45.0\n"
     ]
    }
   ],
   "source": [
    "def func(a):\n",
    "    a *= 10.0\n",
    "\n",
    "a = 45.0\n",
    "func(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Ver en pythontutor](http://pythontutor.com/visualize.html#code=def%20func%28a%29%3A%0A%20%20%20%20a%20*%3D%2010.0%0A%0Aa%20%3D%2045.0%0Afunc%28a%29%0Aprint%28a%29&cumulative=false&curInstr=5&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "def func(a):\n",
    "    a = False\n",
    "\n",
    "a = True\n",
    "func(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos lo que pasa con strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola \n"
     ]
    }
   ],
   "source": [
    "def func(a):\n",
    "    a += 'gente'\n",
    "\n",
    "a = 'hola '\n",
    "func(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Tony', 'Natalia', 'Steve']\n"
     ]
    }
   ],
   "source": [
    "def unir_listas(list1, list2):\n",
    "    list1 = list2 \n",
    "\n",
    "avengers = ['Tony', 'Natalia', 'Steve']\n",
    "nuevos_avengers = ['Thor', 'Peter']\n",
    "\n",
    "unir_listas(avengers, nuevos_avengers)\n",
    "print(avengers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Alcance de variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un ejemplo práctico de esto puede ser un decreto expedido por la alcaldía de Bogotá. Tiene alcance sólo para los habitantes de la capital pero no para los del resto del país. Un decreto expedido por la presidencia de Colombia tiene alcance en el país pero no en otros países. \n",
    "\n",
    "En python hay dos típos básicos de alcance de las variables:\n",
    "\n",
    "- Variables locales\n",
    "- Variables Globales\n",
    "\n",
    "En el siguiente código k es una variable global, list1 es una variable local y existe únicamente cuando se llama el método add:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "k = 4\n",
    "\n",
    "def main():\n",
    "    list1 = []\n",
    "    \n",
    "    def add():\n",
    "        for x in range(k):\n",
    "            list1.append(x)\n",
    "        print(list1)\n",
    "    add()\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Analizar código](http://pythontutor.com/visualize.html#code=k%20%3D%204%0A%0Adef%20main%28%29%3A%0A%20%20%20%20list1%20%3D%20%5B%5D%0A%20%20%20%20%0A%20%20%20%20def%20add%28%29%3A%0A%20%20%20%20%20%20%20%20for%20x%20in%20range%28k%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20list1.append%28x%29%0A%20%20%20%20%20%20%20%20print%28list1%29%0A%20%20%20%20add%28%29%0A%0Amain%28%29&cumulative=false&curInstr=20&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para entender más el alcance de variables se tiene el siguiente ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside the function the value o a is acting as local variable 12\n",
      "Outside function the value of a is acting as global variable 10\n"
     ]
    }
   ],
   "source": [
    "def func():\n",
    "    a =12\n",
    "    print('''Inside the function the value o a is acting as local variable''', a)\n",
    "\n",
    "a= 10\n",
    "\n",
    "func()\n",
    "print ('''Outside function the value of a is acting as global variable''',a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[ver en pythontutor](http://pythontutor.com/visualize.html#code=def%20func%28%29%3A%0A%20%20%20%20a%20%3D12%0A%20%20%20%20print%28'''Inside%20the%20function%20the%20value%20o%20a%20is%20acting%20as%20local%20variable''',%20a%29%0A%0Aa%3D%2010%0A%0Afunc%28%29%0Aprint%20%28'''Outside%20function%20the%20value%20of%20a%20is%20acting%20as%20global%20variable''',a%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a inside the function is the local variable 12\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'b' 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-27-f61f4f84efa8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mfunc\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[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Trying to access the local variable outside the function.\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'b' is not defined"
     ]
    }
   ],
   "source": [
    "\n",
    "def func():\n",
    "    b =12\n",
    "    print (\"a inside the function is the local variable\",b)\n",
    "\n",
    "func()\n",
    "print(\"Trying to access the local variable outside the function.\",b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[ver en pythontutor](\"http://pythontutor.com/visualize.html#code=def%20func%28%29%3A%0A%20%20%20%20b%20%3D12%0A%20%20%20%20print%20%28%22a%20inside%20the%20function%20is%20the%20local%20variable%22,b%29%0A%0Afunc%28%29%0Aprint%28%22Trying%20to%20access%20the%20local%20variable%20outside%20the%20function.%22,b%29&cumulative=false&heapPrimitives=nevernest&mode=edit&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La palabra reservada ```global```:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí se está declarando k de forma global dentro de la función. La palabra global indica al intérprete que la variable es global y debe detenerse de buscar sobre todas las funciones o los accesos locales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "variable k is now global 12\n",
      "Accessing the value of k outside the function 10\n"
     ]
    }
   ],
   "source": [
    "k=5 \n",
    "\n",
    "def func():\n",
    "    global k\n",
    "    k=k+7\n",
    "    print(\"variable k is now global\",k)\n",
    "    k=10\n",
    "\n",
    "func()\n",
    "print (\"Accessing the value of k outside the function\",k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para cambiar el valor de una variable global dentro de una función también se puede utilizar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python is fantastic\n"
     ]
    }
   ],
   "source": [
    "x = \"awesome\"\n",
    "\n",
    "def myfunc():\n",
    "  global x\n",
    "  x = \"fantastic\"\n",
    "\n",
    "myfunc()\n",
    "\n",
    "print(\"Python is \" + x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clausuras en python: \n",
    "\n",
    "Como se vió antes es posible definir una función dentro de otra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n",
      "15\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "def make_multiplier_of(n):\n",
    "    def multiplier(x):\n",
    "        return x * n\n",
    "    return multiplier\n",
    "\n",
    "\n",
    "# Multiplier of 3\n",
    "times3 = make_multiplier_of(3)\n",
    "\n",
    "# Multiplier of 5\n",
    "times5 = make_multiplier_of(5)\n",
    "\n",
    "# Output: 27\n",
    "print(times3(9))\n",
    "\n",
    "# Output: 15\n",
    "print(times5(3))\n",
    "\n",
    "# Output: 30\n",
    "print(times5(times3(2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[ver en pythontutor](http://pythontutor.com/visualize.html#code=def%20make_multiplier_of%28n%29%3A%0A%20%20%20%20def%20multiplier%28x%29%3A%0A%20%20%20%20%20%20%20%20return%20x%20*%20n%0A%20%20%20%20return%20multiplier%0A%0A%0A%23%20Multiplier%20of%203%0Atimes3%20%3D%20make_multiplier_of%283%29%0A%0A%23%20Multiplier%20of%205%0Atimes5%20%3D%20make_multiplier_of%285%29%0A%0A%23%20Output%3A%2027%0Aprint%28times3%289%29%29%0A%0A%23%20Output%3A%2015%0Aprint%28times5%283%29%29%0A%0A%23%20Output%3A%2030%0Aprint%28times5%28times3%282%29%29%29&cumulative=false&curInstr=23&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias:\n",
    "\n",
    "https://docs.python.org/3/reference/lexical_analysis.html#identifiers\n",
    "\n",
    "Das, B. N. (2017). Learn Python in 7 Days. Packt Publishing Ltd.\n",
    "\n",
    "\n",
    "Gomez, J, Rodriguez A y Cubides C. La ciencia de Programar. Universidad Nacional de Colombia.\n",
    "\n",
    "Rodríguez, A (2020). Curso de Programación en Python. https://github.com/arleserp/cursopython"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}