{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Primeros pasos\n",
    "\n",
    "Sobre la filosofía de programación en Python..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los comentarios se marcan con #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Esto es un comentario"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El final de línea indica el fin de una sentencia (no es necesario marcarlo con ; ni con ningún otro carácter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La indentación (indentation) es clave.\n",
    "\n",
    "En Python los bloques de código se indican por indentación. El uso de indentación ayuda a reforzar el estilo uniforme y legible que muchos encuentran atractivo en el código Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lower:  [0, 1, 2, 3, 4]\n",
      "upper:  [5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "lower = []; upper = []\n",
    "for i in range(10):\n",
    "    if i < x:\n",
    "        lower.append(i)\n",
    "    else:\n",
    "        upper.append(i)\n",
    "        \n",
    "print('lower: ', lower)\n",
    "print('upper: ', upper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una puntualización sobre print:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first value: 1\n"
     ]
    }
   ],
   "source": [
    "# Python 2 only!\n",
    "# print \"first value:\", 1\n",
    "# Python 3 only!\n",
    "print(\"first value:\", 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables y Objetos\n",
    "\n",
    "### Variables\n",
    "\n",
    "En Python las variables son punteros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "x es un puntero que apunta a un espacio de memoria donde se almacena el valor 4.\n",
    "\n",
    "Una consecuencia de esto es que no tenemos que declarar el tipo de x, es un puntero que puede apuntar a información/datos de otro tipo. Por eso se dice que Python es un lenguaje de tipado dinámico y podemos hacer cosas como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1         # x is an integer\n",
    "x = 'hello'   # now x is a string\n",
    "x = [1, 2, 3] # now x is a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta es otra de las propiedades de Python que permite que sea rápido de escribir y fácil de leer.\n",
    "\n",
    "##### ¡Cuidado!\n",
    "Este tipado dinámico tiene otras consecuencias que hay que tener en cuenta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x:  [1, 2, 3]\n",
      "y:  [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print('x: ', x)\n",
    "print('y: ', y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.append(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hemos usado el puntero x para cambiar el contenido del espacio de memoria al que apunta, por eso el valor de y cambia (y es otro puntero que apunta al mismo espacio de memoria que x).\n",
    "\n",
    "Sin embargo, si usamos '=' para modificar x:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "x = 'hasta luego'\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al usar '=' hemos hecho que x apunte a un espacio distinto.\n",
    "\n",
    "El contenido del espacio de memoria al que apuntaba antes x (al que sigue apuntando y) está intacto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 15\n",
      "y = 10\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = x\n",
    "x += 5  # add 5 to x's value, and assign it to x\n",
    "print(\"x =\", x)\n",
    "print(\"y =\", y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objetos\n",
    "\n",
    "Python es un lenguaje de programación orientada a objetos, y en Python todo es un objeto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acabamos de ver que en Python las variables son simplemente punteros y que la declaración del nombre de una variable no lleva asociada información sobre su tipo. Sin embargo, eso no significa que Python sea un lenguaje sin tipos.\n",
    "\n",
    "Python tiene tipos; pero no van asociados al nombre de las variables sino a los objetos en sí."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 4\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 'hello'\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3.14159\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operadores de identidad y pertenencia\n",
    "\n",
    "## Operadores de identidad: 'is' e 'is not'\n",
    "\n",
    "Identidad o identidad de objeto es distinto a igualdad. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a==b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a is b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a is not b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a y b apuntan a distintos objetos. \n",
    "\n",
    "Antes hemos visto que en Python las variables son punteros. El operador 'is' comprueba si las dos variables están apuntando al mismo contenedor/espacio de memoria (al mismo objeto).\n",
    "Así, la mayoría de las veces que un principiante tiene la tentación de usar 'is' lo que de verdad quiere hacer es '=='."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operadores de pertenencia\n",
    "Estos operadores comprueban pertenencia en objetos compuestos. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 in [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 not in [1,2,3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En los lenguajes de programación orientados a objetos como Python, un objeto es una entidad que contiene datos junto con metadatos y/o funcionalidad asociados. \n",
    "\n",
    "En Python todo es un objeto, lo que significa que cada entidad tiene algunos metadatos (llamados atributos) y funcionalidad asociada (llamados métodos). Se accede a estos atributos y métodos a través de la sintaxis de puntos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 100]\n"
     ]
    }
   ],
   "source": [
    "L = [1, 2, 3]\n",
    "L.append(100)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quizá nos resulte más extraño que no solo objetos compuestos (como las listas) sino también tipos simples de objetos tengan atributos y métodos asociados. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.5 + 0.0 i\n"
     ]
    }
   ],
   "source": [
    "x = 4.5\n",
    "print(x.real, \"+\", x.imag, 'i')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.is_integer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 4.0\n",
    "x.is_integer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Incluso los atributos y métodos de objetos son a su vez objetos con su propia información de tipo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "builtin_function_or_method"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x.is_integer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Flujo de control\n",
    "\n",
    "## Condicionales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-15 es negativo\n"
     ]
    }
   ],
   "source": [
    "x = -15\n",
    "\n",
    "if x == 0:\n",
    "    print(x, \"es cero\")\n",
    "elif x > 0:\n",
    "    print(x, \"es positivo\")\n",
    "elif x < 0:\n",
    "    print(x, \"es negativo\")\n",
    "else:\n",
    "    print(x, \"no se parece a nada que haya visto antes ...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tanto los dos puntos (:) como los espacios en blanco (indentación) se utilizan para indicar bloques de código separados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bucles\n",
    "\n",
    "### Bucle for\n",
    "\n",
    "Vamos a ver algunos ejemplos de bucles for en Python.\n",
    "\n",
    "Si queremos imprimir cada uno de los elementos de una lista podríamos usar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 5 7 "
     ]
    }
   ],
   "source": [
    "for N in [2, 3, 5, 7]:\n",
    "    print(N, end=' ') # print all on same line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Especificamos la variable que queremos usar, la secuencia sobre la que queremos iterar, y usamos el operador 'in' para unirlos de forma intuitiva y legible. El objeto a la derecha del operador 'in' puede ser cualquier iterador de Python.\n",
    "\n",
    "Uno de los iteradores más usados en Python es el objeto range que genera una secuencia de números:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 "
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# range from 5 to 10\n",
    "list(range(5, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# range from 0 to 10 by 2\n",
    "list(range(0, 10, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bucle while"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 "
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i, end=' ')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### break and continue\n",
    "\n",
    "Dos sentencias útiles que podemos utilizar dentro de los bucles para ajustar con precisión cómo se ejecutan.\n",
    "- break: rompe completamente el bucle\n",
    "- continue: salta lo que quede de la iteración actual del bucle y pasa directamente a la siguiente iteración\n",
    "\n",
    "Ambos pueden utilizarse tanto en bucles for como en while"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 5 7 9 11 13 15 17 19 "
     ]
    }
   ],
   "source": [
    "for n in range(20):\n",
    "    # si el resto de n / 2 es 0, sáltate el resto del bucle\n",
    "    if n % 2 == 0:\n",
    "        continue\n",
    "    print(n, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n"
     ]
    }
   ],
   "source": [
    "# Completa una lista con la sucesión de Fibonacci hasta un valor determinado\n",
    "a, b = 0, 1\n",
    "amax = 100\n",
    "L = []\n",
    "\n",
    "while True:\n",
    "    (a, b) = (b, a + b)\n",
    "    if a > amax:\n",
    "        break\n",
    "    L.append(a)\n",
    "\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funciones\n",
    "\n",
    "En Python las funciones se definen con la sentencia def."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(N):\n",
    "    L = []\n",
    "    a, b = 0, 1\n",
    "    while len(L) < N:\n",
    "        a, b = b, a + b\n",
    "        L.append(a)\n",
    "    return L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hemos definido una función llamada fibonacci que tiene un único argumento N y que devuelve un valor, una lista con los N primeros números de la sucesión de Fibonacci."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No se especifica ninguna información de tipos sobre la entrada o salida de la función. Una función puede devolver cualquier objeto de Python simple o compuesto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A veces cuando definimos una función, hay ciertos valores que queremos que la función use la mayor parte del tiempo (o que creemos que son los que se van a usar mayoritariamente) pero también nos gustaría dar al usuario opciones/flexibilidad. En esos casos, podemos usar valores por defecto para los argumentos de la función. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(N, a=0, b=1):\n",
    "    L = []\n",
    "    while len(L) < N:\n",
    "        a, b = b, a + b\n",
    "        L.append(a)\n",
    "    return L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci(10, 0, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 2, 4, 6, 10, 16, 26, 42, 68, 110]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci(10, 0, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 7, 11, 18, 29, 47, 76, 123, 199]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci(10, b=3, a=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Módulos y paquetes\n",
    "\n",
    "Para poder cargar y utilizar módulos ya existentes utilizamos la sentencia import.\n",
    "\n",
    "Podemos importar un módulo directamente. Cuando hagamos referencia al contenido de dicho módulo tendremos que indicar el namespace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.cos(math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos importar un módulo asignándole un alias:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.cos(np.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si solo nos interesa importar algunos elementos concretos del módulo también podemos hacerlo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import cos, pi\n",
    "cos(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos importar todo el contenido de un paquete en el espacio de nombres (namespace) local"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import *\n",
    "sin(pi) ** 2 + cos(pi) ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta opción debe usarse con cuidado y moderación, si es que se usa. El problema es que tales importaciones pueden a veces sobrescribir nombres de funciones que no se pretende sobrescribir, y puede ser difícil darse cuenta de lo que hemos cambiado. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sum in module builtins:\n",
      "\n",
      "sum(iterable, start=0, /)\n",
      "    Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
      "    \n",
      "    When the iterable is empty, return the start value.\n",
      "    This function is intended specifically for use with numeric values and may\n",
      "    reject non-numeric types.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(5), -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import *\n",
    "sum(range(5), -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el primero, sumamos range(5) empezando en -1; en el segundo, sumamos range(5) a lo largo del último eje (indicado por -1)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Módulos de \"terceros\"\n",
    "Una de las cosas que hace que Python sea útil, especialmente en el mundo de la ciencia de datos, es su ecosistema de módulos de terceros. Estos pueden ser importados como los módulos built-in, pero primero tenemos que instalarlos en nuestro sistema. El registro estándar para estos módulos es el Python Package Index (PyPI), que se encuentra en la Web en http://pypi.python.org/.\n",
    "Cuando queramos instalar uno de estos módulos en nuestro sistema usaremos el programa pip. Por ejemplo, si quisiéramos instalar el módulo supersmoother:\n",
    "\n",
    "$ pip install supersmoother\n",
    "\n",
    "El código fuente del paquete se descargará automáticamente del repositorio de PyPI, y el paquete se instalará en la ruta estándar de Python (suponiendo que tenemos los permisos)."
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}