Sesion05_Archivos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">PROGRAMACIÓN DE COMPUTADORES </h1>\n",
    "\n",
    "<h2 align=\"center\">UNIVERSIDAD EAFIT</h2>\n",
    "\n",
    "<h3 align=\"center\">MEDELLÍN - COLOMBIA </h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 align=\"center\">Sesión 05 - Archivos</h2>  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Archivos (Files)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- La mayoría de los programas que hemos visto hasta ahora son transitorios en el sentido de que corren por un corto tiempo y producen alguna salida, pero cuando terminan, sus datos desaparecen. Si ejecuta el programa de nuevo, comienza con una pizarra limpia. \n",
    "\n",
    "\n",
    "- Otros programas son persistentes: funcionan por mucho tiempo (o todo el tiempo); Mantienen al menos algunos de sus datos en un almacenamiento permanente (un disco duro, por ejemplo); Y si cierran y reinician, retoman donde lo dejaron.\n",
    "\n",
    "\n",
    "- Ejemplos de programas persistentes son los sistemas operativos, que se ejecutan casi siempre que un equipo está encendido, y los servidores web, que funcionan todo el tiempo, esperando a que las solicitudes para entrar en la red.\n",
    "\n",
    "\n",
    "- Una de las maneras más simples para que los programas mantengan sus datos es leyendo y escribiendo archivos de texto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Abrir/Cerrar (open/close)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función open() devuelve un objeto archivo, y se usa normalmente con dos argumentos:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "fobj = open(\"ruta_archivo\",\"modo_cceso\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los archivos son objetos tipo *file* accesados mediante la función *open*.\n",
    "\n",
    "\n",
    "- <strong>ruta_archivo:</strong> string indicando la ubicación del archivo con el nombre y la extensión.\n",
    "\n",
    "\n",
    "- <strong>modo_acceso:</strong> string, opcional, que indica el modo de acceder al archivo:\n",
    "\n",
    "  - <strong>*r*:</strong> read, lectura. Abre el archivo en modo lectura. <strong>El archivo tiene que existir previamente</strong>, de lo contrario se tiene un error del tipo IOError.\n",
    "\n",
    "  - <strong>*w*:</strong> write, escritura. Abre el archivo en modo escritura. Si el archivo no existe se crea. <strong>Si existe, SOBREESCRIBIRÁ TODO!!!</strong> el contenido.\n",
    "\n",
    "  - <strong>*a*:</strong> append, añadir. Abre el archivo en modo escritura. Continúa escribiendo sobre el archivo existente a partir de la última línea del contenido inicial. No sobreescribe.\n",
    "\n",
    "  - <strong>*b*:</strong> binary, binario.\n",
    "\n",
    "  - <strong>*+*:</strong> Lectura y Escritura simultáneas.\n",
    "\n",
    "  - <strong>*U*:</strong> universal newline, saltos de línea universales. Permite trabajar con archivos que tengan un formato para los saltos de línea que no coinciden con el de la plataforma actual (Windows usa el caracter CR LF, Unix, LF, y MacOS, CR)\n",
    "\n",
    "\n",
    "Una vez terminado el trabajo sobre el archivo, se debe cerrar utilizando el método *close*."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "fobj.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "un ejemplo rápido de abertura de un archivo (recuerde, debe existir previamente, si no, saca un mensaje *IOerror*). El modo de acceso es opcional. Por defecto se deja listo para lectura, 'r' (read)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fhola = open(\"HolaMundoFile.txt\")\n",
    "print(fhola)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<strong>*siempre que se finalice el trabajo de lectura y/o escritura sobre el archivo deberá cerrarse*.</strong>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fhola.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lectura y Escritura (I/O)\n",
    "\n",
    "\n",
    "#### Generalidades"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Normalmente los archivos se abren en modo texto, lo que significa que podrás leer y escribir cadenas del y al archivo, las\n",
    "cuales se codifican utilizando un código específico. \n",
    "\n",
    "\n",
    "- Si el código no es especificado, el valor predeterminado depende de la plataforma. \n",
    "\n",
    "\n",
    "- Si se agrega *b* al modo el archivo se abre en modo binario: ahora los datos se leen y escriben en forma de objetos bytes. Se debería usar este modo para todos los archivos que no contengan texto (archivos de imágenes, por ejemplo).\n",
    "\n",
    "\n",
    "- Cuando se lee en modo texto, por defecto se convierten los fines de lineas que son específicos a las plataformas (\\n en Unix, \\r\\n en Windows) a solamente \\n. \n",
    "\n",
    "\n",
    "- Cuando se escribe en modo texto, por defecto se convierten los \\n a los finales de linea específicos de la plataforma. \n",
    "\n",
    "\n",
    "- Este cambio automático está bien para archivos de texto, pero corrompería datos binarios como los de archivos JPEG o EXE. Asegurese de usar modo binario cuando leas y escribas tales archivos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lectura"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método read devuelve una cadena con el contenido del archivo o bien el contenido de los primeros $n$ bytes, si se especifica el tamaño máximo a leer.\n",
    "\n",
    "\n",
    "- read()\n",
    "\n",
    "\n",
    "- readline()\n",
    "\n",
    "\n",
    "- readlines()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Leyendo el contenido completo del archivo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fhola = open(\"HolaMundoFile1.txt\")\n",
    "completo = fhola.read()\n",
    "print(completo)\n",
    "fhola.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fobj = open(\"O_Fortuna.txt\")\n",
    "completo = fobj.read()\n",
    "print(completo)\n",
    "fobj.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O una parte de él (en bytes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fobj = open(\"O_Fortuna.txt\")\n",
    "parte = fobj.read()\n",
    "print(parte)\n",
    "fobj.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "El método *readline* sirve para leer las líneas del fichero una por una. Cada vez que se llama a este método, se devuelve el contenido del archivo desde el puntero hasta que se encuentra un carácter de nueva línea, incluyendo este carácter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fobj = open(\"O_Fortuna.txt\")\n",
    "fobj.readline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fobj.readline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fobj.readline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "masnumeros = open(\"masnumeros.txt\")\n",
    "masnumeros.readline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "masnumeros.readline()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método *readlines* lee todas las líneas del archivo y devuelve una lista de las líneas leídas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-*-coding:utf-8-*-\n",
    "fobj = open(\"O_Fortuna.txt\").readlines()\n",
    "print(fobj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El tipo de objeto creado es una Lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(fobj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y como tal, se pueden realizar todas las operaciones de Lista vistas anteriormente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fobj[28]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fobj = open(\"O_Fortuna.txt\")\n",
    "completo = fobj.read()\n",
    "print(completo)\n",
    "fobj.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Toda la información que se lee desde un archivo plano es de tipo...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fnumeros = open(\"masnumeros.txt\")\n",
    "numeros = float(fnumeros.readline())\n",
    "print(type(numeros))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "masnumeros = open(\"masnumeros.txt\").readlines()\n",
    "print(masnumeros)\n",
    "print(type(masnumeros[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se puede ver, el resultado es una lista de valores str que incluyen los caracteres para salto de línes \"`\\n`\".\n",
    "\n",
    "\n",
    "Resultan dos interrogantes:\n",
    "\n",
    "\n",
    "- Cómo eliminar los caracteres de salto de línea \"`\\n`\"?\n",
    "\n",
    "\n",
    "- Cómo convertir cada elemento tipo str de la lista en float/int (o viceversa)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "masnumeros = open(\"masnumeros.txt\").readlines()\n",
    "masnumeros = [float(i.rstrip()) for i in masnumeros]\n",
    "print(masnumeros)\n",
    "print(type(masnumeros[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La estructura usada para resolver el problema se denomina [List Comprehension](http://www.python-course.eu/python3_list_comprehension.php). Este tema haría parte de un curso de nivel más avanzado que el que estamos asistiendo... pero como adelanto, con esta estructura se resuelve el problema en encontrar los números Pitagóricos propuesto en una clase anterior, de una forma simple y elegante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[(x,y,z) for x in range(1,30) for y in range(x,30) for z in range(y,30) if x**2 + y**2 == z**2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se puede leer el archivo completo iterando sobre el objeto archivo. Esto es eficiente en memoria, rápido, y conduce a un código más simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for linea in masnumeros:\n",
    "    print(linea)\n",
    "type(linea)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Escritura"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para la escritura de archivos se utilizan los métodos *write* y *writelines*. \n",
    "\n",
    "\n",
    "- <strong>write:</strong> Escribe en el archivo una cadena de texto que toma como parámetro.\n",
    "\n",
    "\n",
    "- <strong>writelines:</strong> Toma como parámetro una lista de cadenas de texto indicando las líneas que queremos escribir en el fichero.\n",
    "\n",
    "\n",
    "A diferencia del método read, el archivo sobre el que se va a escribir no necesita estar creado previamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fh = open(\"escritura2.txt\", \"a\")\n",
    "fh.write(\"To write or not to write\\nthat is the question!\\n\")\n",
    "fh.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NO SE LE OLVIDE CERRAR EL ARCHIVO UNA VEZ HA FINALIZADO LA ACCIÓN DE ESCRITURA!!! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El argumento del método write() tiene qué ser un string, entonces es necesario convertir los valores numéricos en cadenas de caracteres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fh = open(\"escritura.txt\", \"w\")\n",
    "x = str(52.8)\n",
    "print(type(x))\n",
    "fh.write(x)\n",
    "fh.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fh = open(\"escritura.txt\", \"w\")\n",
    "x = str(52)\n",
    "print(type(x))\n",
    "fh.write(x)\n",
    "fh.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obsérvese que el método \"w\" sobreescribe el contenido del archivo. <strong>MUY PELIGROSO!!!</strong>\n",
    "\n",
    "\n",
    "En el caso en el que necesitemos acceder a un archivo ya creado, con algún contenido, es mejor utilizar el método \"a\" (append), que escribirá a partir de la última línea del contenido inicial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fh = open(\"escritura.txt\", \"w\")\n",
    "fh.write(\"To write or not to write\\nthat is the question!\\n\")\n",
    "fh.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fh = open(\"escritura.txt\", \"a\")\n",
    "x = str(52)\n",
    "fh.write(x)\n",
    "fh.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Escritura en un archivo con un formato específico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open ('tabla.txt ', 'w')\n",
    "for i in range (1, 11):\n",
    "    f.write (\"%2d x 17 = %4d\\n\" % (i, i * 17))\n",
    "f.close ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lectura / Escritura simultánea"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fobj_in = open(\"O_Fortuna.txt\")\n",
    "fobj_out = open(\"O_Fortuna2.txt\",\"w\")\n",
    "i = 1\n",
    "for line in fobj_in:\n",
    "    print(line.rstrip())\n",
    "    fobj_out.write(str(i) + \": \" + line)\n",
    "    i = i + 1\n",
    "fobj_in.close()\n",
    "fobj_out.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo anterior, cada línea en el archivo de salida es indexado con su número de línea.\n",
    "\n",
    "\n",
    "Por último (por ahora...) si deseamos escribir sobre un archivo ya creado sin que perdamos información del mismo, debemos emplear el modo de acceso \"a\" en vez de \"w\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open ('tabla.txt ', 'a')\n",
    "for i in range (1, 11):\n",
    "    f.write (\"%2d x 18 = %4d\\n\" % (i, i * 18))\n",
    "f.close ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Laboratorio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Haga un programa que calcule la raíz aproximada de una función no lineal en un intervalo $[a,b]$ mediante el [Método de Bisección](https://es.wikipedia.org/wiki/Método_de_bisección). El resultado debe ser un archivo que contenga los datos de las diferentes iteraciones del algoritmo en una tabla con las columnas:\n",
    "\n",
    "    - Número de iteración\n",
    "    - valor de $a$\n",
    "    - valor de $f(a)$\n",
    "    - valor de $b$\n",
    "    - valor de $f(b)$\n",
    "    - valor de $m$\n",
    "    - valor de $f(m)$\n",
    "    - valor del error absoluto, dado por: $E_{abs} = |m_{i}-m_{i-1}|$\n",
    "    - Flag indicando si se cumplió o no el criterio de parada.\n",
    "    \n",
    "En clase se explicará el funcionamiento del algoritmo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}