10. Funciones, alcance de variables y Módulos en Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funciones\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nosotros hemos visto diferentes formas de crear funciones:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funciones sin argumentos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_entero(num, base=2):\n",
    "    cont = 0 \n",
    "    while num >= base:\n",
    "        cont+=1\n",
    "        num /= base\n",
    "    return cont"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_entero(1024) #logaritmo entero en base 2 de 1024"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_entero(1000, 10) #logaritmo entero en base 10 de 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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 python tutor](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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(a):\n",
    "    a = False\n",
    "\n",
    "a = True\n",
    "func(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[ver en python Tutor](http://pythontutor.com/visualize.html#code=def%20func%28p%29%3A%0A%20%20%20%20p%20%3D%20False%0A%0Ap%20%3D%20True%0Afunc%28p%29%0Aprint%28p%29&cumulative=false&curInstr=7&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos lo que pasa con strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(a):\n",
    "    a += 'gente'\n",
    "\n",
    "a = 'hola '\n",
    "func(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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:\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": [
    "# Módulos en python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un módulo en python es un archivo fuente que consiste de funciones y definiciones. Para utilizar un módulo, se utiliza la palabra ```import```. Esta parte del curso se trabajará en spyder."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Cree el archivo ```module.py``` en spyder:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "def sum1(a,b):\n",
    "    c = a+b\n",
    "    return c\n",
    "\n",
    "def mul1(a,b):\n",
    "    c = a*b\n",
    "    return c\n",
    " ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Cree el archivo ```main.py``` que importa el archivo ```module.py```:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "import module\n",
    "\n",
    "x = 12\n",
    "y = 34\n",
    "\n",
    "print (\"Sum is \", module.sum1(x,y))\n",
    "print (\"Multiple is \", module.mul1(x,y))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Puede parecer tedioso importar module, así que vamos a crear un segundo archivo que contenga lo siguiente:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "\n",
    "import module as md\n",
    "x = 12\n",
    "y = 34\n",
    "print (\"Sum is \", md.sum1(x,y))\n",
    "print (\"Multiple is \", md.mul1(x,y))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Es posible importar únicamente una función específica:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "from module import sum1\n",
    "x = 12\n",
    "y = 34\n",
    "print (\"Sum is \", sum1(x,y))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para saber los métodos que tiene un método determinado se puede utilizar ```print(dir(module))```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Localización de los módulos de Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando se utliza import, python buscará el módulo en la siguiente forma:\n",
    "    \n",
    "1. El directorio actual\n",
    "2. La variable de entorno ```PYTHONPATH```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ver información sobre las rutas usadas por python para import:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "for p in sys.path:\n",
    "    print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La variable ```__name__```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creemos un archivo en spyder llamado ```myprog.py``` con el siguiente contenido:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "def sum1(a,b):\n",
    "    c = a+b\n",
    "    return c\n",
    "    \n",
    "print(\"Sum is \", sum1(3,6))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defina el programa de Alice ```alice.py```:\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "import myprog\n",
    "num = 10\n",
    "total = num+myprog.sum1(23,12)\n",
    "print(\"Alice total is \", total)\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué pasó al correr el programa de Alice?\n",
    "\n",
    "```\n",
    "Sum is  9\n",
    "Alice total is  45\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cambiemos las últimas líneas del programa ```myprog.py``` por:\n",
    "\n",
    "```\n",
    "if __name__ == '__main__' :\n",
    "    print (\"Sum is \", sum1(3,6))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```__name__``` es una variable especial que guarda el nombre ```__main__``` si se está en el mismo archivo. Si el programa es importado de otro programa ```__name__``` será el nombre del módulo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se agrega en ```myprog.py```:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```print \"name is \", __name__```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desde my_prog.py se verá así:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```name is  __main__```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desde el programa de Alice:\n",
    "\n",
    "```name is  myprog\n",
    "Alice total is  45```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definición de un paquete en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un paquete puede ser visto como una colección de módulos. Si se tiene una aplicación que realice compresión de archivos se puede tener una carpeta llamada ```compression```. Si cada módulo define un algoritmo de compresión diferente se tendrá un script para comprimir en zip ```filetozip.py``` otro para comprimr en rar ```rar.py``` y otro para comprimir en tar ```tar.py```. Para agruparlos se debe crear el archivo ```__init__.py``` en la carpeta:\n",
    "\n",
    "\n",
    "```\n",
    "---------- filetozip.py ---------\n",
    "\n",
    "def compresszip(filename):\n",
    "    print('creating...' + filename + '.zip')\n",
    "\n",
    " ---------- filetorar.py ---------\n",
    "\n",
    "def compressrar(filename):\n",
    "    print('creating...' + filename + '.rar')\n",
    "\n",
    "\n",
    "---------- filetotar.py ---------\n",
    "\n",
    "def compresstar(filename):\n",
    "    print('creating...' + filename + '.tar')\n",
    "\n",
    "```\n",
    "\n",
    "Ahora cree un archivo vacío llamado ```__init__.py``` en el directorio compression."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creamos un programa llamado ```testmodule.py``` por fuera de la carpeta compression que contenga:\n",
    "\n",
    "```\n",
    "#import sys\n",
    "#sys.path.append(\"E:\\GithubRep\\cursoPython\\cursopython\\spyder\\compression\") \n",
    "\n",
    "from compression import filetozip\n",
    "from compression import filetorar \n",
    "\n",
    "filetozip.compresszip('archivo')\n",
    "filetorar.compressrar('archivo')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "creating...archivo.zip\n",
      "creating...archivo.rar\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "sys.path.append(r\"E:\\Drive\\Konrad Lorenz\\Asignaturas\\2020-Int\\Python\") \n",
    "from compression import filetozip\n",
    "from compression import filetorar \n",
    "\n",
    "filetozip.compresszip('archivo')\n",
    "filetorar.compressrar('archivo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias\n",
    "\n",
    "Das, B. N. (2017). Learn Python in 7 Days. Packt Publishing Ltd.\n",
    "\n",
    "https://www.dummies.com/programming/python/how-to-find-path-information-in-python/\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}