Cuadernos/0801_leer_ficheros.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tema 8: Ficheros y módulos (I)\n",
    "Hasta ahora, hemos escrito programas en los que, cada vez que los ejecutábamos, había que introducir toda la información, y esta se perdía una vez salíamos de ellos. Pero hay una forma de superar esta limitación y conservar información entre distintas ejecuciones de un programa: guardarla en ficheros.\n",
    "\n",
    "Pero aprender a leer y escribir en ficheros no solo sirve para escribir programas con esas características, sino que también es útil para compartir datos, es decir, para poder trabajar con datos de terceros, o que otros puedan trabajar con los nuestros. Esto es especialmente importante en proyectos de [_open data_](https://es.wikipedia.org/wiki/Datos_abiertos) o [_linked data_](https://es.wikipedia.org/wiki/Datos_enlazados).\n",
    "\n",
    "Existen dos tipos de ficheros: de texto y binarios. Los primeros se pueden leer y escribir con programas de edición de textos (como Notepad++, el bloc de notas, Sublime, PyCharm, TextMate, etc.). Los segundos almacenan la información en largas secuencias de números que solo tienen sentido para los programas. En este curso vamos a aprender a manejar los primeros.\n",
    "\n",
    "## Crear ficheros de texto\n",
    "Vamos a crear un fichero de texto. La forma más fácil es a través de un editor de texto plano. Puedes usar el que quieras, pero si no sabes cuál usar, te recomiendo el Notepad++. Lo más importante es que no utilices un procesador de textos como puede ser el Word del Microsoft Office, WordPad, o el Writer de LibreOffice/OpenOffice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Escribe unas líneas en tu archivo nuevo. Por ejemplo:\n",
    "\n",
    "    Muchos años después, frente al pelotón de fusilamiento,\n",
    "    el coronel Aureliano Buendía había de recordar aquella\n",
    "    tarde remota en que su padre lo llevó a conocer el hielo.\n",
    "    Macondo era entonces una aldea de veinte casas de barro y\n",
    "    cañabrava construidas a la orilla de un río de aguas\n",
    "    diáfanas que se precipitaban por un lecho de piedras\n",
    "    pulidas, blancas y enormes como huevos prehistóricos.\n",
    "\n",
    "Ahora guárdalo como `datos.txt` en la misma carpeta en la que guardes tus archivos .py o .ipynb. Si usas Colab, sube el archivo a la misma carpeta en que tengas los cuadernos y presta atención a la siguiente subsección; si no, puedes saltar directamente a [Abrir ficheros de texto en Python](#Abrir-ficheros-de-texto-en-Python).\n",
    "\n",
    "### Acceder a archivos en Colab\n",
    "Si estás usando Colab, tienes que ejecutar estas líneas siempre que vayas a querer acceder a archivos desde un cuaderno:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from google.colab import drive\n",
    "drive.mount('/content/drive')"
   ]
  },
  {
   "attachments": {
    "pic-0801-1.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al hacerlo, tienen que salirte un enlace y un campo donde escribir como los de la siguiente imagen:\n",
    "\n",
    "![Dos líneas. Una dice \"Go to this URL in a browser\", seguida de una URL. La siguiente dice: \"Enter your authorization code\" y tiene una caja de texto debajo](attachment:pic-0801-1.png)\n",
    "\n",
    "Simplemente, sigue las instrucciones: ve al enlace, copia el código y pégalo en el campo que ha aparecido en tu cuaderno. Ya puedes seguir :)\n",
    "\n",
    "## Abrir ficheros de texto en Python\n",
    "Ahora vamos a crear un programa que lea ese archivo. Para ello, lo primero que necesitamos es que el archivo «exista» dentro del programa, es decir, que exista un objeto que lo represente, igual que las variables representan strings, números o booleanos. Eso lo vamos a hacer con la función `open()`, a la que le tenemos que pasar como argumento la ruta o _path_ del archivo entre comillas. También tenemos que guardar su salida en una variable, a la que llamaremos, por ejemplo, `fichero`.\n",
    "\n",
    "Si estás ejecutando los cuadernos en local o estás trabajando con archivos .py, y has guardado el archivo en la misma carpeta, la ruta será `\"datos.txt\"`, sin más (hay que poner las comillas porque `open()` requiere un dato de tipo string). Si estás usando Colab y has subido el fichero a la misma carpeta que los cuadernos, la ruta será `\"/content/drive/My Drive/Introducción a la programación para humanistas/datos.txt\"` (suponiendo que la carpeta se llama \"Introducción a la programación para humanistas\" y que no está dentro de otra carpeta de tu Drive). En realidad, no hay ningún problema en guardar el fichero en otro sitio que no sea el mismo que el programa que va a acceder a él, pero entonces habría que modificar la ruta. Así que decide bien dónde colocarlo y no lo muevas mucho de ahí."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "fichero = open(\"datos.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si nos equivocamos con la ruta del fichero, obtendremos un error porque el programa no será capaz de encontrarlo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'dato.txt'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-1-9a226982a83a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfichero_error\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"dato.txt\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'dato.txt'"
     ]
    }
   ],
   "source": [
    "fichero_error = open(\"dato.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora podemos comprobar el tipo de objeto que es `fichero` con `type()` y obtendremos `_io.TextIOWrapper`. Esto simplemente es la forma que tiene Python de representar los ficheros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_io.TextIOWrapper"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(fichero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Leer ficheros de texto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es importante entender que no podemos tratar los objetos de ficheros como si fueran strings, es decir, `print(fichero)` probablemente no se va a comportar como esperas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_io.TextIOWrapper name='datos.txt' mode='r' encoding='cp1252'>\n"
     ]
    }
   ],
   "source": [
    "print(fichero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como ves, nos devuelve la información del fichero, pero no imprime su contenido. En cambio, para acceder a su contenido, nos falta un último paso, que es leerlo. Esto se puede hacer de muchas maneras; vamos a ver aquí las más habituales.\n",
    "\n",
    "Empecemos por el método `.read()`, cuyo output meteremos en una variable que ya sí será de tipo string y podremos imprimir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Muchos aÃ±os despuÃ©s, frente al pelotÃ³n de fusilamiento,\n",
      "el coronel Aureliano BuendÃ­a habÃ­a de recordar aquella\n",
      "tarde remota en que su padre lo llevÃ³ a conocer el hielo.\n",
      "Macondo era entonces una aldea de veinte casas de barro y\n",
      "caÃ±abrava construidas a la orilla de un rÃ­o de aguas\n",
      "diÃ¡fanas que se precipitaban por un lecho de piedras\n",
      "pulidas, blancas y enormes como huevos prehistÃ³ricos.\n"
     ]
    }
   ],
   "source": [
    "contenido = fichero.read()\n",
    "print(contenido)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¡Ahora sí! Aunque hay un problema: las tildes y las eñes no se ven bien. Si pasa esto en un texto, indica que hay un problema con la codificación, lo cual casi siempre es un quebradero de cabeza, porque puede deberse al programa que estemos usando para ver el texto (el navegador, el bloc de notas, la terminal...) o a nuestro código.\n",
    "\n",
    "En este caso, fíjate en que cuando hemos usado `print()` hemos visto en la información del fichero `encoding='cp1252'`, cuando lo deseable es siempre (al menos cuando trabajamos con textos distintos del inglés) usar la codificación utf-8.\n",
    "\n",
    "Por suerte, podemos arreglarlo. Uno de los parámetros opcionales que admite la función `open()` es `encoding`, y por defecto no es utf-8, así que tenemos que especificárselo de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La codificación de este fichero es UTF-8\n",
      "\n",
      "Muchos años después, frente al pelotón de fusilamiento,\n",
      "el coronel Aureliano Buendía había de recordar aquella\n",
      "tarde remota en que su padre lo llevó a conocer el hielo.\n",
      "Macondo era entonces una aldea de veinte casas de barro y\n",
      "cañabrava construidas a la orilla de un río de aguas\n",
      "diáfanas que se precipitaban por un lecho de piedras\n",
      "pulidas, blancas y enormes como huevos prehistóricos.\n"
     ]
    }
   ],
   "source": [
    "fichero = open(\"datos.txt\", encoding = \"UTF-8\")\n",
    "contenido = fichero.read()\n",
    "print(\"La codificación de este fichero es\", fichero.encoding)\n",
    "print()\n",
    "print(contenido)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perfecto. Fíjate en que en la tercera línea estamos imprimiendo solo la información de `fichero` que nos interesa, en ese caso, la que está bajo la clave `encoding`, separándolo con un punto del objeto al que pertenece. Se parece a cómo llamamos a los métodos, pero es distinto en que no necesita un paréntesis al final.\n",
    "## Cerrar ficheros de texto\n",
    "Ahora, antes de terminar, todavía nos queda por hacer algo muy importante: cerrar el archivo. Sí, en el código también hay que cerrar las cosas después de abrirlas. Y es importante, porque si se quedan abiertas gastan recursos innecesariamente.\n",
    "\n",
    "Para cerrar un fichero usaremos el método `.close()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "fichero.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Leer ficheros de texto línea por línea\n",
    "Otra forma de leer ficheros es hacerlo línea por línea, es decir, después de volcar su contenido en una variable con `read()` podemos usar `.splitlines()` para que nos devuelva, en vez de una string, una lista, con tantos elementos como líneas tenía el fichero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Muchos años después, frente al pelotón de fusilamiento,', 'el coronel Aureliano Buendía había de recordar aquella', 'tarde remota en que su padre lo llevó a conocer el hielo.', 'Macondo era entonces una aldea de veinte casas de barro y', 'cañabrava construidas a la orilla de un río de aguas', 'diáfanas que se precipitaban por un lecho de piedras', 'pulidas, blancas y enormes como huevos prehistóricos.']\n"
     ]
    }
   ],
   "source": [
    "fichero = open(\"datos.txt\", encoding=\"UTF-8\")\n",
    "contenido = fichero.read()\n",
    "fichero.close() # cerramos el fichero porque ya hemos volcado su contenido en una variable\n",
    "\n",
    "lineas = contenido.splitlines()\n",
    "print(lineas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero podemos leerlo directamente como una lista en un solo paso, usando `.readlines()` sobre el fichero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Muchos años después, frente al pelotón de fusilamiento,\\n', 'el coronel Aureliano Buendía había de recordar aquella\\n', 'tarde remota en que su padre lo llevó a conocer el hielo.\\n', 'Macondo era entonces una aldea de veinte casas de barro y\\n', 'cañabrava construidas a la orilla de un río de aguas\\n', 'diáfanas que se precipitaban por un lecho de piedras\\n', 'pulidas, blancas y enormes como huevos prehistóricos.']\n"
     ]
    }
   ],
   "source": [
    "fichero = open(\"datos.txt\", encoding=\"UTF-8\")\n",
    "lineas2 = fichero.readlines()\n",
    "fichero.close()\n",
    "\n",
    "print(lineas2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Caracteres de salto de línea\n",
    "Fíjate en que usar `.splitlines()` hace que se eliminen del final de las líneas los caracteres de salto de línea (`\\n`). Sin embargo, `.readlines()` mete directamente lo que encuentra en cada línea, incluido el salto. Por tanto, si intentamos imprimir cada una de las listas de forma \"bonita\" (recorriendo cada elemento e imprimiéndolo, no imprimiéndolo como una lista como hemos hecho antes), habrá una gran diferencia:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Usando read() y .splitlines():\n",
      "\n",
      "Muchos años después, frente al pelotón de fusilamiento,\n",
      "el coronel Aureliano Buendía había de recordar aquella\n",
      "tarde remota en que su padre lo llevó a conocer el hielo.\n",
      "Macondo era entonces una aldea de veinte casas de barro y\n",
      "cañabrava construidas a la orilla de un río de aguas\n",
      "diáfanas que se precipitaban por un lecho de piedras\n",
      "pulidas, blancas y enormes como huevos prehistóricos.\n",
      "\n",
      "Usando .readlines()\n",
      "\n",
      "Muchos años después, frente al pelotón de fusilamiento,\n",
      "\n",
      "el coronel Aureliano Buendía había de recordar aquella\n",
      "\n",
      "tarde remota en que su padre lo llevó a conocer el hielo.\n",
      "\n",
      "Macondo era entonces una aldea de veinte casas de barro y\n",
      "\n",
      "cañabrava construidas a la orilla de un río de aguas\n",
      "\n",
      "diáfanas que se precipitaban por un lecho de piedras\n",
      "\n",
      "pulidas, blancas y enormes como huevos prehistóricos.\n"
     ]
    }
   ],
   "source": [
    "print(\"Usando read() y .splitlines():\")\n",
    "print()\n",
    "for linea in lineas:\n",
    "    print(linea)\n",
    "\n",
    "print()\n",
    "print(\"Usando .readlines():\")\n",
    "print()\n",
    "for linea in lineas2:\n",
    "    print(linea)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero podemos arreglarlo fácilmente con `.strip()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Muchos años después, frente al pelotón de fusilamiento,\n",
      "el coronel Aureliano Buendía había de recordar aquella\n",
      "tarde remota en que su padre lo llevó a conocer el hielo.\n",
      "Macondo era entonces una aldea de veinte casas de barro y\n",
      "cañabrava construidas a la orilla de un río de aguas\n",
      "diáfanas que se precipitaban por un lecho de piedras\n",
      "pulidas, blancas y enormes como huevos prehistóricos.\n"
     ]
    }
   ],
   "source": [
    "for linea in lineas2:\n",
    "    print(linea.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al leer texto e imprimirlo siempre hay que tener cuidado con los saltos de línea: son caracteres que no vemos, pero que están ahí siempre que hay separación en líneas, y que obviamente el programa sí ve y lee. El problema es que `print()` está hecho para imprimir bonito para humanos, así que cada cosa que imprime (por ejemplo, un elemento de un bucle), la separa por un salto de línea. Además, cuando encuentra un carácter de salto de línea, lo interpreta y lo ejecuta, lo cual puede hacer que se junten los dos saltos. Simplemente, ten en cuenta que esto puede pasar y prepárate para arreglarlo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero volviendo a las maneras de leer un fichero, trabajar así puede ser un poco problemático. Tanto con `read()` como con `.readlines()` estamos cargando todo el contenido del archivo en memoria, y esto puede valernos cuando trabajamos con archivos pequeños, pero en cuanto manejemos volúmenes más grandes de datos el código tardará demasiado en ejecutarse.\n",
    "\n",
    "Por suerte, los ficheros son objetos iterables, así que los podemos recorrer con un `for`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Muchos años después, frente al pelotón de fusilamiento,\n",
      "el coronel Aureliano Buendía había de recordar aquella\n",
      "tarde remota en que su padre lo llevó a conocer el hielo.\n",
      "Macondo era entonces una aldea de veinte casas de barro y\n",
      "cañabrava construidas a la orilla de un río de aguas\n",
      "diáfanas que se precipitaban por un lecho de piedras\n",
      "pulidas, blancas y enormes como huevos prehistóricos.\n"
     ]
    }
   ],
   "source": [
    "fichero = open(\"datos.txt\", encoding = \"UTF-8\")\n",
    "for linea in fichero:\n",
    "    print(linea.strip()) # eliminamos el carácter de salto de línea\n",
    "fichero.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puede que te preguntes por qué hay tantas formas distintas de leer un fichero. En programación te vas a encontrar todo el rato con que hay muchas formas de hacer lo mismo, pero siempre se diferencian en algún detalle y eso nos va a permitir elegir una para cada ocasión, según nos convenga."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Abrir ficheros con `with ... as`\n",
    "Finalmente, existe una forma rápida de abrir ficheros en Python que consiste en usar las instrucciones `with` y `as`. La principal diferencia y la causa de que sea rápida es que no hace falta cerrar después el archivo, porque ya lo hace Python. Además, el esquema cambia ligeramente:\n",
    "\n",
    "    with open(ruta) as nombre_del_fichero:\n",
    "        <instrucciones sobre el fichero>\n",
    "\n",
    "Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Muchos años después, frente al pelotón de fusilamiento,\n",
      "el coronel Aureliano Buendía había de recordar aquella\n",
      "tarde remota en que su padre lo llevó a conocer el hielo.\n",
      "Macondo era entonces una aldea de veinte casas de barro y\n",
      "cañabrava construidas a la orilla de un río de aguas\n",
      "diáfanas que se precipitaban por un lecho de piedras\n",
      "pulidas, blancas y enormes como huevos prehistóricos.\n"
     ]
    }
   ],
   "source": [
    "with open(\"datos.txt\", encoding=\"UTF-8\") as fichero:\n",
    "    for linea in fichero:\n",
    "        print(linea.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En vez de guardar lo que sale de `open()` en una variable con el operador de asignación (`=`), lo hacemos con `with` y `as` (que se parece bastante más al lenguaje natural).\n",
    "\n",
    "Como hemos visto, muchas veces solo abrimos el fichero para cargarlo en una variable y a partir de ahí trabajar con él, así que enseguida lo cerrábamos. Por eso se inventó esta manera de abrir archivos. Por supuesto, no es recomendable si vamos a necesitar que el fichero siga abierto para continuar leyendo o escribiendo en él."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicios\n",
    "### 080101\n",
    "Modifica la función `fichero_a_lista` para que:\n",
    "\n",
    "1. en vez de usar `open()` y `.close()`, use `with ... as`\n",
    "2. en vez de recorrer el fichero con un `for`, use `read()` y `.splitlines()`\n",
    "\n",
    "Comprueba que has hecho bien cada modificación ejecutando de nuevo la celda; debería salir el mismo texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Muchos años después, frente al pelotón de fusilamiento,\n",
      "el coronel Aureliano Buendía había de recordar aquella\n",
      "tarde remota en que su padre lo llevó a conocer el hielo.\n",
      "Macondo era entonces una aldea de veinte casas de barro y\n",
      "cañabrava construidas a la orilla de un río de aguas\n",
      "diáfanas que se precipitaban por un lecho de piedras\n",
      "pulidas, blancas y enormes como huevos prehistóricos.\n"
     ]
    }
   ],
   "source": [
    "def fichero_a_lista(ruta):\n",
    "    # Convierte las líneas de un fichero de texto en elementos de una lista y devuelve la lista\n",
    "    lista_de_lineas = []\n",
    "    fichero = open(ruta, encoding=\"UTF-8\")\n",
    "    for linea in fichero:\n",
    "        lista_de_lineas.append(linea.strip())\n",
    "    fichero.close()\n",
    "    return lista_de_lineas\n",
    "\n",
    "# Programa\n",
    "lista = fichero_a_lista(\"datos.txt\")\n",
    "for elemento in lista:\n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 080102\n",
    "Vamos a hacer algo más que imprimir por pantalla los ficheros que abramos. Podemos convertir un texto en una lista de líneas para contar, por ejemplo, la longitud de cada línea en caracteres o en palabras (atención, en la siguiente celda reutilizaremos la función `fichero_a_lista` del ejercicio anterior):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estadísticas del fichero datos.txt\n",
      "------------------------------------------------------------\n",
      "Línea 1\n",
      "Contenido: Muchos años después, frente al pelotón de fusilamiento,\n",
      "Número de palabras: 8\n",
      "Número de caracteres: 55\n",
      "Línea 2\n",
      "Contenido: el coronel Aureliano Buendía había de recordar aquella\n",
      "Número de palabras: 8\n",
      "Número de caracteres: 54\n",
      "Línea 3\n",
      "Contenido: tarde remota en que su padre lo llevó a conocer el hielo.\n",
      "Número de palabras: 12\n",
      "Número de caracteres: 57\n",
      "Línea 4\n",
      "Contenido: Macondo era entonces una aldea de veinte casas de barro y\n",
      "Número de palabras: 11\n",
      "Número de caracteres: 57\n",
      "Línea 5\n",
      "Contenido: cañabrava construidas a la orilla de un río de aguas\n",
      "Número de palabras: 10\n",
      "Número de caracteres: 52\n",
      "Línea 6\n",
      "Contenido: diáfanas que se precipitaban por un lecho de piedras\n",
      "Número de palabras: 9\n",
      "Número de caracteres: 52\n",
      "Línea 7\n",
      "Contenido: pulidas, blancas y enormes como huevos prehistóricos.\n",
      "Número de palabras: 7\n",
      "Número de caracteres: 53\n"
     ]
    }
   ],
   "source": [
    "def num_caracteres(lista):\n",
    "    # Devuelve una lista con la longitud, en caracteres, de las líneas de una lista\n",
    "    caracteres_por_linea = []\n",
    "    for elemento in lista:\n",
    "        caracteres_por_linea.append(len(elemento)) # Contamos los caracteres en cada línea y metemos cada resultado en una lista\n",
    "    return caracteres_por_linea\n",
    "\n",
    "def num_palabras(lista):\n",
    "    # Devuelve una lista con la longitud, en palabras, de las líneas de una lista\n",
    "    palabras_por_linea = []\n",
    "    for elemento in lista:\n",
    "        lista_de_palabras = elemento.split() # Convertimos cada línea en una lista de palabras\n",
    "        palabras_por_linea.append(len(lista_de_palabras)) # Contamos las palabras en cada línea y metemos cada resultado en una lista\n",
    "    return palabras_por_linea\n",
    "\n",
    "def estadisticas_fichero(ruta):\n",
    "    # Saca las estadísticas de caracteres y palabras por línea de un fichero\n",
    "    lineas = fichero_a_lista(ruta)\n",
    "    print(\"Estadísticas del fichero\", ruta) # Imprimimos un cabecero\n",
    "    print(\"-\" * 60)\n",
    "    palabras = num_palabras(lineas) # Creamos una lista con el número de palabras por línea\n",
    "    caracteres = num_caracteres(lineas) # Creamos una lista con el número de caracteres por línea\n",
    "    i = 1 # Creamos un índice para poder usarlo al imprimir el número de cada línea\n",
    "    for linea in lineas:\n",
    "        print(\"Línea\", i)\n",
    "        print(\"Contenido:\", linea)\n",
    "        print(\"Número de palabras:\", palabras[i-1]) # Restamos 1 al índice, porque Python empieza a contar por el 0\n",
    "        print(\"Número de caracteres:\", caracteres[i-1])\n",
    "        i = i + 1 # Al final, añadimos 1 al índice para que se imprima bien el número de línea y se consulten las posiciones correctas de las líneas\n",
    "\n",
    "# Programa\n",
    "ruta = \"datos.txt\"\n",
    "estadisticas_fichero(ruta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora crea otro fichero de texto y modifica solo la ruta en la línea 32, para que el programa haga lo mismo pero con el nuevo fichero."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 080103\n",
    "Guarda en un archivo `temperaturas.txt` el siguiente texto:\n",
    "\n",
    "    17\n",
    "    20\n",
    "    20\n",
    "    21\n",
    "    20\n",
    "    22\n",
    "    18\n",
    "\n",
    "Define una función `lee_temperaturas()` que:\n",
    "- reciba como argumento una ruta de fichero\n",
    "- cree una lista vacía llamada `valores`\n",
    "- abra el fichero con `open()`\n",
    "- recorra el fichero línea por línea\n",
    "- convierta cada línea en un número entero y la guarde en una variable `valor`\n",
    "- añada `valor` a `valores`\n",
    "- cierre el fichero\n",
    "- devuelva `valores`\n",
    "\n",
    "Comprueba que el programa te ha salido bien ejecutando este código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temperaturas:\n",
      "17\n",
      "20\n",
      "20\n",
      "21\n",
      "20\n",
      "22\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "temperaturas = lee_temperaturas(\"temperaturas.txt\")\n",
    "print(\"Temperaturas:\")\n",
    "for t in temperaturas:\n",
    "    print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El output esperado es:\n",
    "\n",
    "    Temperaturas:\n",
    "    17\n",
    "    20\n",
    "    20\n",
    "    21\n",
    "    20\n",
    "    22\n",
    "    18"
   ]
  }
 ],
 "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
}