Python/Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://www.python.org/static/community_logos/python-logo-master-v3-TM.png\" width=\"400\">\n",
    "\n",
    "---\n",
    "`Nota: Si crees que este notebook necesita algún cambio no dudes en contribuir a su desarrollo.`\n",
    "\n",
    "---\n",
    "\n",
    "<img src=\"https://imgs.xkcd.com/comics/python.png\" width=\"400\">\n",
    "\n",
    "# Introducción a la programación en Python\n",
    "\n",
    "Si conoces otros lenguajes es posible que esta introducción te resulte innecesaria, pero se ha escrito pensando en un lector completamente lego en programación.\n",
    "\n",
    "Un lenguaje de programación es un conjunto de reglas sintácticas que permiten codificar la secuencia de ordenes lógicas (algoritmo) que traducido a lenguage máquina y ejecutado por el procesador de tu computadora resolverá una tarea. Para esto Python hace uso de unos mecanismos elementales comunes a cualquier lenguaje, interpretado o compilado, como es el uso del almacenamiento de información en variables, el algebra lógica o los bucles.\n",
    "\n",
    "## Antes de empezar\n",
    "\n",
    "Para realizar este notebook has debido previamente echarle un ojo a la unidad de este repositorio [Qué es Python, cómo se instala y cómo se usa.](../Introducción/Python.ipynb) \n",
    "\n",
    "Si estás ejecutando este Jupyter Notebook en tu computadora haciendo uso de tu Jupyter Lab, te recomendamos que lo reinicialices completamente borrando la salida de las celdas. Para ello acude al menú *Kernel* (top menú de la ventana) y elige la opción *Restart Kernel and Clear All Outputs...*. Puede que hayamos dejado en la copia maestra de GitHub el resultado de la ejecución de las celdas, pero es sólo para que cualquiera pueda leer el notebook allí sin necesidad de ejecutarl. Pero tu no lo vas a leer. Vas a jugar con él. Así que resetéalo.\n",
    "\n",
    "Recuerda también que para ejecutar una celda debes presionar la combinación de teclas 'mayús'+'entrar' cuanto esta está seleccionada.\n",
    "\n",
    "## Variables\n",
    "\n",
    "Lenguajes como Fortran o C obligan a comenzar un programa con una sección de declaración de variables, con nombre y tipo (es número entero, es letra, es número real, etc.). Así, el uso 'al vuelo' de una nueva variable a mitad del programa, si no fue declarada al inicio, provoca un error. Afortunadamente esto ya no pasa en lenguajes como Python. En Python cualquier variable que el interpretador encuentra por primera vez, y en cualquier momento, la registra como conocida y le da el tipo que tiene el valor que se le asigna. Por ejemplo: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1 = 3\n",
    "var2 = 4.6\n",
    "var3 = 'python'\n",
    "var4 = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veamos que la variable `var1` es un entero (`int`), `var2` es un número de coma flotante (`float`), `var3` es una cadena de caracteres (`str`) y `var4` es una variable lógica o booleana (`bool`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(var1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(var2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(var3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(var4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estas variables, además de almacenar información, pueden ser empleadas en operaciones lógicas y algebráicas con un sentido distinto según su naturaleza:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1+var2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var3*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var3+' o no python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var3 == 'python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'y' in var3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'a' in var3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var4 is False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(var4 and False) is False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var4*True == True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas y tuplas\n",
    "\n",
    "Además estas variables pueden ser almacenadas en listas o tuplas. Aunque para un purista la lista y la tupla son [objetos filosóficamente distintos](https://stackoverflow.com/questions/626759/whats-the-difference-between-lists-and-tuples/626871#626871), ambas se manejan de manera similar. [Una de las pocas diferencias](https://www.uno-de-piera.com/diferencias-entre-listas-y-tuplas-en-python/) es que, como veremos, una puede ser mutada, y la otra no.\n",
    "\n",
    "La tupla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "una_tupla = (var1, var2, var3, var4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(una_tupla)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "una_tupla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "una_lista = [var1, var2, var3, var4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(una_lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "una_lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como ves, ahora mismo la única diferencia es que una se define entre paréntesis y la otra entre corchetes. Veamos ahora la diferencia más relevante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "una_lista[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "una_lista[0] = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "una_lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "una_tupla[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "una_tupla[0]= 15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En primer lugar debes ver que en Python el primer elemento es siempre el cero '0'.\n",
    "Por otro lado, acabamos de comprobar que la tupla no permite la reasignación de sus elementos, y la lista si."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Volviendo a las cosas que una lista y una tupla tienen en común podemos añadir que ambos son objetos que permiten operaciones algebráicas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "otra_lista = ['pato','peto','pito']\n",
    "requetelista = una_lista + otra_lista\n",
    "print(requetelista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[0,1,2]+[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "('a','b','c')*4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Además, las tuplas y las listas son objetos. Si se pueden hacer listas o tuplas de objetos, también se pueden hacer listas de listas, tuplas de tuplas, listas de tuplas o tuplas de listas, o listas de tuplas de tuplas de listas, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quimera = ['a','b',[1,2,3],'d',('pato','peto','pito')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quimera[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quimera[2][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quimera[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quimera[4][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quimera[4][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quimera[4][:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En estos últimos ejemplos has visto que el contenido de las listas o tuplas puede ser obtenido elemento a elemento con el argumento de qué posición ocupa entre corchetes. Recuerda que la posición '0' es siempre la primera, de modo que el índice de la última posición es el número de elementos (longitud de la lista) menos uno:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# len nos da la longitud de una lista o tupla\n",
    "len(quimera)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quimera[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hemos visto también que el indexado de elementos también entiende índices negativos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quimera[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quimera[-4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y que ':' hace referencia a todos los elementos de esa lista o tupla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quimera[2][:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "\n",
    "En Python existe la manera de almacenar elementos sin orden, conjuntos en los que sus componentes no están jerarquizados o indexados. A este conjunto se le llama `set` y se define entre llaves. Estos objetos tienen incluso sus propias funciones útiles.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conjunto_A = {2, 1, 6, 3}\n",
    "conjunto_B = {10, 6, 2, 12}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(conjunto_A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conjunto_A | conjunto_B # el simbolo \"|\" crea la unión de conjuntos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conjunto_A & conjunto_B # el simbolo \"&\" crea la intersección de conjuntos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diccionarios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último Python dispone de otra clase de objetos llamada diccionario (`dict`). El diccionario es la relación no ordenada entre claves y valores, y se define con ayuda de las llaves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_diccionario = {'hello':'hola', 'apple':'manzana', 'house':'casa'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(un_diccionario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_diccionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_diccionario.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_diccionario.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_diccionario['house']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_diccionario[0] # veamos que los elementos no están indexados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es la tercera vez que ves '#'. Seguramente ya habrás deducido que '#' sirve para comentar código. Aquí va otro ejemplo de código con comentarios:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Almaceno el resultado de una operación matemática\n",
    "resultado=(2+3)/2\n",
    "# Y lo saco por pantalla\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Atributos y Métodos\n",
    "\n",
    "Algo que sí distingue a Python (y a otros) de Fortran o C es que son [lenguajes orientados a objetos](https://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos). [El uso de objetos hace que un lenguage resulte más intuitivo para el programador amateur](https://www.desarrolloweb.com/articulos/499.php). Además los objetos pueden contener tener otros objetos como atributos y métodos. Esto simplifica mucho la organización de la información y hace de Python un lenguage compacto y sencillo. Debes de comenzar a apreciar la simplicidad como principio que guíe tus lineas de código, joven padawan. Ya estás preparado para instruirte en los [principios Zen de python](https://www.python.org/dev/peps/pep-0020/).\n",
    "\n",
    "Ya podemos ver, por ejemplo, que los objetos presentados en secciones anteriores no son simples variables definidas como la combinación de un 'nombre de variable' y 'valor de variable', sino que tienen asociados atributos (características almacenadas en forma de objetos) y métodos (funciones). Para ver qué cosas tiene un objeto podemos emplear método `dir`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palabra = 'otorrinolaringólogo'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(palabra)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esa lista que arroja el método `dir` es el conjunto de métodos y atributos que la variable palabra, como objeto de clase 'cadena de caracteres (str)', contiene. Aquellos elementos de la lista que comienzan y terminan con dos guiones bajos, '__', son elementos de utilidad interna y privada para Python (no fueron implementados apriori como funcionalidad para el usuario). Si, pero te estarás diciendo: \"qué son esos elementos???\". Todos estos elementos almacenan información (atributos) o funciones (métodos) que cuelgan del objeto 'palabra' y a los cuales puedes acceder mediante el uso de un punto '.':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# El atributo __class__ está presente en todos los objetos y almacena el nombre del tipo de la variable:\n",
    "palabra.__class__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# El método __sizeof__() está también presente en todos los objetos y calcula su tamaño en memoria\n",
    "palabra.__sizeof__()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Habrás adivinado gracias a estas dos últimas celdas cúal es la diferencia invocando atributos o métodos. Un método necesita invocarse con paréntesis ya que es una función que podría tener argumentos de entrada -veremos esto más adelante-.\n",
    "\n",
    "También en este punto te preguntarás, pero y cómo sabes qué hace y es cada cosa? Fácilmente:\n",
    "\n",
    "1. La documentación de Python y sus librerías siempre es muy útil: [web oficial de Python 3 en su sección sobre tipos str](https://docs.python.org/3/library/stdtypes.html#str)   \n",
    "2. La comunidad de usuarios y el número de foros es enorme. Segúramente alguien ya se preguntó lo mismo que tu y otro le contestó: [búsqueda en google](https://www.google.com.mx/search?q=%C2%BFQu%C3%A9+metodos+de+un+objeto+str+en+python%3F&)\n",
    "3. El método `help` resulta de mucha ayuda\n",
    "\n",
    "Para ilustrar como funciona `help` y sin salir del notebook puedes ver qué documentación se esconde por ejemplo detrás de los siguientes elementos de la lista anterior de atributos y métodos: `__sizeof__`, `endswith` y `capitalize`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(palabra.__sizeof__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(palabra.endswith)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(palabra.capitalize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vemos por ejemplo que `endswith` es un método que tiene argumentos de entrada, un sufijo en este caso, y devuelve el valor Verdadero (True) si el valor de la variable cadena de caracteres termina con ese sufijo y Falso (False) si no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palabra.endswith('logo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "palabra.endswith('ble')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O que el método `capitalize` no tiene argumentos de entrada y devuelve la cadena con el primer caracter en mayúscula y el resto en minúsculas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(palabra)\n",
    "print(palabra.capitalize())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último podemos añadir que en este punto del notebook ya hemos visto que existen métodos propios de Python y ajenos a cualquier objeto como `dir`, `print`, `help` o `len`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(palabra.capitalize(),'tiene',len(palabra),'letras')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas, las tuplas, los diccionarios... también tienen sus propios atributos y métodos. Por ejemplo, tomando el objeto de la sección anterior `un_diccionario`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_diccionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_diccionario.keys() # Este método da la lista de claves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_diccionario.values() # Este método da la lista de valores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_diccionario.pop('house') # Este método saca un item del diccionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_diccionario"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ¿Podemos definir nuestra propia clase de objetos con métodos y atributos?\n",
    "\n",
    "Para consolidar la [comprensión en la diferencia entre métodos y atributos, y entender la trascendencia de poder definir \"clases de objetos\"](https://www.desarrolloweb.com/articulos/499.php) veamos cómo podemos definir nuestra propia clase.\n",
    "\n",
    "Una clase es la plantilla de un objeto. Las clases se definen con métodos y atributos, propios de esa clase (valga la redundancia). Y son realmente útiles.\n",
    "\n",
    "Supongamos que defino la clase `átomo`. Átomos puede haber de muchos: de naturaleza distinta, con distinta carga, radio de Van der Waals, peso atómico... pero todos tienen esas propiedades que puedo definir como atributos comunes en la plantilla que representa la clase `átomo`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class átomo():\n",
    "    def __init__(self):\n",
    "        self.tipo  = None\n",
    "        self.radio = None\n",
    "        self.carga = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hemos comenzado definiendo los tres atributos de `átomo` (tipo, radio y carga) con valor `None`. Algo todavía poco útil, pero ya podemos crear átomos haciendo uso de `átomo` como plantilla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "at1 = átomo()\n",
    "at2 = átomo()\n",
    "at3 = átomo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(at1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(at1.tipo)\n",
    "print(at2.radio)\n",
    "print(at3.carga)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hagamos ahora algo más útil. Vamos a generar la clase `átomo` con un argumento de entrada que será el `tipo` de átomo. Y el resto de atributos, `radio` y `carga`, serán adjudicados al inicializar un objeto de clase `átomo` dependiendo de su tipo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class átomo():\n",
    "    def __init__(self, tipo = None):\n",
    "        \n",
    "        self.tipo  = tipo\n",
    "        self.radio = None\n",
    "        self.carga = None\n",
    "        \n",
    "        if tipo == 'A':\n",
    "            self.radio = 2.5\n",
    "            self.carga = 1\n",
    "        \n",
    "        if tipo == 'B':\n",
    "            self.radio = 4.0\n",
    "            self.carga = -2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "at1 = átomo(tipo='A')\n",
    "at2 = átomo('B')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "at1.radio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "at2.radio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último y para que `átomo` no sea únicamente un conjunto de atributos, incluyamos un método. Un método que sea el cálculo del volumen del átomo según su radio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class átomo():\n",
    "    def __init__(self, tipo = None):\n",
    "        \n",
    "        self.tipo  = tipo\n",
    "        self.radio = None\n",
    "        self.carga = None\n",
    "        \n",
    "        if tipo == 'A':\n",
    "            self.radio = 2.5\n",
    "            self.carga = 1\n",
    "        \n",
    "        if tipo == 'B':\n",
    "            self.radio = 4.0\n",
    "            self.carga = -2\n",
    "\n",
    "    def volumen(self):\n",
    "        pi = 3.14159265359\n",
    "        return (4.0/3.0)*pi*self.radio**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "at1 = átomo('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "at1.radio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "at1.volumen()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "at1.radio = 3.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "at1.volumen()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En las líneas de código empleadas para definir la clase `átomo` habrás identificado varias cosas desconocidas para ti, aunque su significado puede ser intuitivo. Es el caso de las órdenes `def` o `if`, o los términos `class` o `self`. Cómo se define una clase, en profundidad, es materia de un nivel un poco más avanzado y escapa al propósito de este notebook. Pero de la orden `if` si vamos a hablar en la sección siguiente ya que es un elemento básico y común de todo lenguaje de programación."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estructuras condicionales y bucles\n",
    "\n",
    "Otros elementos comunes a todo lenguaje de programación son las estructuras condicionales y los bucles. Veamos unos ejemplos.\n",
    "\n",
    "### El condicional `if`..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# introduce en esta variable un nombre de persona:\n",
    "persona = 'Alberto'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if persona.endswith('a'):\n",
    "    print('Puede que', persona, 'sea de sexo femenino.')\n",
    "elif persona.endswith('o'):\n",
    "    print('Puede que', persona, 'sea de sexo masculino.')\n",
    "else:\n",
    "    print('Puede que', persona, 'sea hermafrodita.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como acabas de ver, Python tienen en su sintaxis tres palabras para imponer condicionales:\n",
    "    - if: 'si...'\n",
    "    - elif: 'si es que no entonces si...'\n",
    "    - else: 'si no...'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estos condicionales se pueden anidar dando lugar a complejas estructuras lógicas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "número_patas = 4\n",
    "según_lo_que_come = 'herbívoro'\n",
    "\n",
    "if según_lo_que_come == 'carnívoro':\n",
    "    if número_patas == 4:\n",
    "        print('es un león')\n",
    "    elif número_patas == 2:\n",
    "        print('es un Tyrannosaurus rex')\n",
    "    else:\n",
    "        print('no sé lo que es')\n",
    "elif según_lo_que_come == 'herbívoro':\n",
    "    if número_patas == 4:\n",
    "        print('es una vaca')\n",
    "    elif número_patas == 2:\n",
    "        print('es un pato')\n",
    "    else:\n",
    "        print('no sé lo que es')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### El iterador `for`..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otro elemento de Python para el control de flujo son los bucles o iteraciones. En todo lenguaje de programación podemos encontrar una orden que nos permite repetir un blóque de código las veces que deseemos, cambiando incluso el contenido de una variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for palabra in ['casa','trompeta','zapato']:\n",
    "    print(palabra, 'tiene', len(palabra), 'letras')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for número in range(11):\n",
    "    print(str(número),'x 8 =', número*8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En esta última celda hemos hecho uso de un iterador de Python muy útil: `range()`. Decimos que es un iterador porque funciona como un generador de números que solito, sin iterar, no tiene sentido:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(0,10,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(range(0,10,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ii in range(0,10,2):\n",
    "    print(ii)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observa, como en el ejemplo de la tabla de multiplicar, que `range()` tiene como argumento el límite de la secuencia sin llegar a el."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cero_uno_dos = list(range(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(cero_uno_dos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uno_dos_tres = list(range(1,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(uno_dos_tres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### El iterador `while`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos tambien repetir un bloque de código hasta que se cumpla una cierta condición:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ii = 1\n",
    "\n",
    "while ii < 10:\n",
    "    print(ii**2)\n",
    "    ii+=1 # '+=' sirve para incrementar el valor de algo, sería lo mismo que ii=ii+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interrumpiendo los bucles\n",
    "\n",
    "Los bucles se pueden alterar con ordenes como `break` o `continue`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ii in range(100):\n",
    "    if ii == 7:\n",
    "        break\n",
    "    print(ii)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ii in range(567, 575):\n",
    "    for jj in range(2, ii):\n",
    "        if ii % jj == 0:\n",
    "            print (ii, 'no es número primo porque al menos es divisible por', jj)\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ii in range(1, 10):\n",
    "    if ii % 2 == 0:\n",
    "        print(ii, 'es número par')\n",
    "        continue\n",
    "    print(ii,'es número impar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existe otro modificador aplicable a los loops, `else`, que en este caso aplica cuando el bucle fue terminado sin interrupciones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ii in range(567, 575):\n",
    "    for jj in range(2, ii):\n",
    "        if ii % jj == 0:\n",
    "            print (ii, 'no es número primo')\n",
    "            break\n",
    "    else:\n",
    "        print (ii, 'es número primo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones\n",
    "\n",
    "Hemos visto que los métodos son funciones asociadas a una clase. Pero también podemos definir funciones que trabajen independientemente, solitas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def area_círculo(radio=None):\n",
    "    pi = 3.14159265359\n",
    "    area = pi*radio**2\n",
    "    return area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_area = area_círculo(radio=2.5)\n",
    "print(mi_area)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un momento, ¿y qué pasa si el argumento radio no está dado?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_area = area_círculo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función encuentra un error porque no puede hacer el cuadrado del valor `None`. Y en la definición de la función incluimos que por defecto `radio` tomaba el valor `None`.\n",
    "Python maneja el uso de excepciones para poder solucionar estos casos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ii in [8, None]:\n",
    "    print('Para el valor de entrada:',ii)\n",
    "    try:\n",
    "        resultado = ii**2\n",
    "        print('\\t el cuadrado es', resultado)\n",
    "    except:\n",
    "        print('\\t el cuadrado no está definido')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos incluso elevar notificaciones de error. Las hay de [varios tipos](https://docs.python.org/3/tutorial/errors.html), en este caso vamos a emplear `ValueError()` y haremos ahora la inclusión de la excepción sin usar `try` y `except`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def area_círculo(radio=None):\n",
    "    \n",
    "    if not radio:\n",
    "        raise ValueError('Un valor de entrada para `radio` es necesario')\n",
    "    \n",
    "    pi = 3.14159265359\n",
    "    area = pi*radio**2\n",
    "    return area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_area = area_círculo(radio=2.5)\n",
    "print(mi_area)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "area_círculo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estas notificaciones nos permiten hacer una buena trazabilidad de los errores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## El manejo de ficheros\n",
    "\n",
    "Veamos ahora como puedo abrir un fichero para escribir información en disco."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_fichero = open('fichero_de_prueba.txt', 'w') # 'w' especifica que el fichero permite la escritura"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(mi_fichero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si estás ejecutando este notebook de manera local con tu jupyter lab, verás que en el navegador de archivos de tu izquierda acaba de aparecer el nuevo fichero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_fichero.write('hola!\\n') # \\n sirve como finalizar linea"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_fichero.write('esta es la segunda linea\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`mi_fichero` es un objeto definido por Python para entrada y salida de datos. Tiene métodos como `write()` cuya función es operar con el objeto. En este caso `write()` escribe en el fichero y devuelve como salida la cantidad de bytes escritos. Otro método que necesitarás es `close()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_fichero.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Está el fichero cerrado?')\n",
    "print(mi_fichero.closed) # `close` es un atributo que registra True o False según esté cerrado o abierto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora abriremos el fichero y lo leeremos. Pero antes, vamos a borrar mi fichero para hacer el caso más realista, lo habitual es que leamos un fichero pre-existente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(mi_fichero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Protegemos el fichero contra escritura declarándolo de lectura con 'r'\n",
    "mi_fichero = open('fichero_de_prueba.txt', 'r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contenido = mi_fichero.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_fichero.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(contenido)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(mi_fichero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos también leer por líneas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_fichero = open('fichero_de_prueba.txt', 'r')\n",
    "primera_linea = mi_fichero.readline()\n",
    "segunda_linea = mi_fichero.readline()\n",
    "mi_fichero.close()\n",
    "del(mi_fichero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(segunda_linea)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ya podemos antes de concluir esta sección borrar el fichero. Esto lo puedes hacer de dos maneras:\n",
    "- Puedes acudir al navegador de archivos de Jupyter y con el botón derecho sobre 'fichero_de_prueba.txt' seleccionar 'Delete'.\n",
    "- Puedes importar la librería de python `os` y usar uno de sus métodos cuya función es borrar ficheros del disco duro. Veamos este ejemplo en las siguientes celdas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(os)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(os.remove)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.remove('fichero_de_prueba.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si has optado por borrar el fichero haciendo uso de la librería `os`, puedes comprobar que este desapareció del navegador de archivos de Jupyter Lab que se encuentra a la izquierda de este notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Módulos y Librerías\n",
    "\n",
    "Por último y para concluir esta introducción a Python, es importante que comprendas qué es un módulo, qué es una librería y cómo se usan."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un módulo es una pieza de código que encapsulamos en un fichero aislado porque la vamos a usar con frecuencia de manera independiente o como elemento incluido en otros programas. Para comprender esto vamos a crear y a usar nuestro propio módulo.\n",
    "\n",
    "Vamos a poner la clase `átomo`, definida anteriormente, en un fichero de texto que llamaremos `atomizador.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_módulo = open('atomizador.py','w')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_código = \"\\\n",
    "class átomo():\\n \\\n",
    "\\t \\\"\\\"\\\"Clase que representa un átomo con su tipo, radio, carga y volumen.\\\"\\\"\\\"\\n \\\n",
    "\\n \\\n",
    "\\t def __init__(self, tipo = None):\\n \\\n",
    "\\n \\\n",
    "\\t \\t self.tipo  = tipo\\n \\\n",
    "\\t \\t self.radio = None\\n \\\n",
    "\\t \\t self.carga = None\\n \\\n",
    "\\n \\\n",
    "\\t \\t if tipo == 'A':\\n \\\n",
    "\\t \\t \\t self.radio = 2.5\\n \\\n",
    "\\t \\t \\t self.carga = 1\\n \\\n",
    "\\n \\\n",
    "\\t \\t if tipo == 'B':\\n \\\n",
    "\\t \\t \\t self.radio = 4.0\\n \\\n",
    "\\t \\t \\t self.carga = -2\\n \\\n",
    "\\n \\\n",
    "\\t def volumen(self):\\n \\\n",
    "\\t \\t \\\"\\\"\\\"Función de la clase átomo que calcula el volumen a partir del atributo radio.\\\"\\\"\\\"\\n \\\n",
    "\\t \\t pi = 3.14159265359\\n \\\n",
    "\\t \\t return (4.0/3.0)*pi*self.radio**3\\n \\\n",
    "\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mi_código)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_módulo.write(mi_código)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_módulo.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(mi_módulo, mi_código)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puedes ver en el navegador de ficheros que existe 'atomizador.py'. Puedes abrirlo en Jupyter Lab, o salir a una terminal o a tu navegador de ficheros del sistema operativo, y ver su contenido. En este punto debes estar pensando que quizá hubiera sido más facil crear este fichero fuera del notebook, haciendo uso de tu editor de texto habitual. Estás en lo cierto, lo hemos creado en el notebook \n",
    "únicamente como ejemplo adicional de escritura de ficheros.\n",
    "\n",
    "Bien, ya tenemos el fichero 'atomizador.py' con un bloque de código. Lo podemos llamar módulo porque la estrategia de trabajo que estamos adoptando es **modular**. Ponemos código perfectamente funcional y documentado en módulos que podrán ser usados como bloques de construcción reusables, como si fueran los ladrillos de un muro que pudieras emplear para hacer estructuras más grandes. Cuando además un conjunto de módulos, están organizados en una misma carpeta con una cierta estructura que les da entidad de grupo, hablamos de librería.\n",
    "\n",
    "Un módulo, o librería, se puede 'cargar' en cualquier momento con la orden `import`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import atomizador "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(atomizador)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Probablemente hayas advertido que en la definición de la clase `átomo` hemos incluido un par de lineas con texto entre triples comillas dobles. Así: `\"\"\"texto\"\"\"`. Mira para lo que sirvieron:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(atomizador.átomo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(atomizador.átomo.volumen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora vamos a usar el módulo `atomizador`para concluir el ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "átomo1 = atomizador.átomo('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(átomo1.volumen())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(atomizador, átomo1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acabamos de borrar los objetos `atomizador` y `átomo` para poder continuar de manera limpia.\n",
    "Veamos ahora que podemos también importar un módulo, o librería, 'cargándolo' con un alias."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import atomizador as creador_de_átomos_marca_ACME"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "átomo1 = creador_de_átomos_marca_ACME.átomo('A')\n",
    "print(átomo1.volumen())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(átomo1, creador_de_átomos_marca_ACME)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O podemos importar clases, métodos u otros objetos específicos de un módulo o de una librería:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from atomizador import átomo as átomo_marca_ACME"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "átomo1 = átomo_marca_ACME('A')\n",
    "print(átomo1.volumen())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del(átomo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Borremos por último el fichero 'atomizador.py' haciendo uso de la librería `os` como vimos anteriormente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from os import remove as borro_fichero\n",
    "borro_fichero('atomizador.py')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comentario final"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí concluye este Jupyter Notebook. Su objetivo no era documentar exhaustivamente el uso del lenguaje Python, sino facilitarte su introducción. Recuerda que al igual que un nuevo idioma no se aprende leyendo el diccionario sino usándolo. Un lenguage de programación se aprende programando. Por eso te recomendamos que, aunque al principio se haga costoso y dificil, pierdas el miedo pronto y comiences a programar tus propios scripts de análisis. \n",
    "\n",
    "Pronto entenderás las dos geniales ilustraciones de xkcd (Randall Munroe) que hay en este notebook.\n",
    "\n",
    "<img src=\"https://fabienmaussion.info/acinn_python_workshop/figures/xkcd_learning_curve_wa.png\" width=\"600\">\n",
    "\n",
    "Ahora que tienes una pequeña base, gana un poco de confianza con otros tutoriales y webs de documentación. Aquí proponemos una selección. Por favor, si encuentras algún otro tutorial o recurso de aprendizaje de utilidad, contribuye añadíendolo.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Más recursos útiles \n",
    "\n",
    "El propósito de este notebook es ser un documento únicamente introductorio. Puedes encontrar -o contribuir añadiendo- más información útil en el siguiente listado:\n",
    "\n",
    "## Documentación\n",
    "\n",
    "https://www.python.org/    \n",
    "https://realpython.com/    \n",
    "https://docs.python-guide.org/    \n",
    "https://wiki.python.org/moin/SpanishLanguage    \n",
    "http://www.scipy-lectures.org/intro/intro.html\n",
    "https://fabienmaussion.info/acinn_python_workshop/\n",
    "\n",
    "## Tutoriales\n",
    "https://realpython.com/start-here/  \n",
    "https://www.programiz.com/python-programming   \n",
    "http://www.openbookproject.net/books/bpp4awd/   \n",
    "http://www.openbookproject.net/books/pythonds/   \n",
    "http://www.openbookproject.net/books/pp4awdds/   \n",
    "http://openbookproject.net/thinkcs/python/english3e/   \n",
    "https://www.w3schools.com/python/   \n",
    "https://www.python.org/about/gettingstarted/   \n",
    "https://docs.python.org/3/tutorial/    \n",
    "http://docs.python.org.ar/tutorial/    \n",
    "http://swcarpentry.github.io/python-novice-inflammation/   \n",
    "https://www.datacamp.com/community/open-courses?tag=python   \n",
    "https://www.datacamp.com/community/tutorials?tag=python   \n",
    "https://realpython.com/tutorials/python/    \n",
    "https://www.learnpython.org/    \n",
    "https://www.datacamp.com/courses/intro-to-python-for-data-science    \n",
    "https://docs.python-guide.org/intro/learning/    \n",
    "https://www.codecademy.com/learn/learn-python    \n",
    "https://pythonprogramming.net/   \n",
    "http://www.scipy-lectures.org/   \n",
    "https://geekytheory.com/curso/python-3   \n",
    "https://www.learnpython.org/es/   \n",
    "https://www.learnpython.org/   \n",
    "http://www.iac.es/sieinvens/python-course/index.html\n",
    "https://github.com/damianavila/Python-Cientifico-HCC/blob/master/1_Python_Cientifico_Intro.ipynb   "
   ]
  },
  {
   "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.1"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}