Modulo08_Archivos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">Pensamiento Algorítmico</h1>\n",
    "<h1 align=\"center\">Módulo 08: Archivos</h1>\n",
    "<h1 align=\"center\">2024/01</h1>\n",
    "<h1 align=\"center\">MEDELLÍN - COLOMBIA </h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*** \n",
    "|[![Gmail](https://img.shields.io/badge/Gmail-D14836?style=plastic&logo=gmail&logoColor=white)](mailto:carlosalvarezh@gmail.com)|<carlosalvarezh@gmail.com>|[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/carlosalvarezh/Pensamiento_Algoritmico/blob/main/Modulo08_Archivos.ipynb)\n",
    "|-:|:-|--:|\n",
    "|[![LinkedIn](https://img.shields.io/badge/linkedin-%230077B5.svg?style=plastic&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/carlosalvarez5/)|[![@alvarezhenao](https://img.shields.io/twitter/url/https/twitter.com/alvarezhenao.svg?style=social&label=Follow%20%40alvarezhenao)](https://twitter.com/alvarezhenao)|[![@carlosalvarezh](https://img.shields.io/badge/github-%23121011.svg?style=plastic&logo=github&logoColor=white)](https://github.com/carlosalvarezh)|\n",
    "\n",
    "<table>\n",
    " <tr align=left><td><img align=left src=\"https://github.com/carlosalvarezh/Curso_CEC_EAFIT/blob/main/images/CCLogoColorPop1.gif?raw=true\" width=\"25\">\n",
    " <td>Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license.(c) Carlos Alberto Alvarez Henao</td>\n",
    "</table>\n",
    "\n",
    "***"
   ]
  },
  {
   "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(\"C:\\Users\\Lenovo\\Dropbox\\GitHub\\Covid-19\\Casos_positivos_de_COVID-19_en_Colombia.csv\",\"write\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los archivos son objetos tipo `file` accesados mediante la función `open`.\n",
    "\n",
    "\n",
    "- `ruta_archivo`: string indicando la ubicación del archivo con el nombre y la extensión.\n",
    "\n",
    "\n",
    "- `modo_acceso` : string, opcional, que indica el modo de acceder al archivo:\n",
    "\n",
    "  - `r`: `read`, lectura. Abre el archivo en modo lectura. **El archivo tiene que existir previamente**, de lo contrario se tiene un error del tipo `IOError`.\n",
    "\n",
    "  - `w`: `write`, escritura. Abre el archivo en modo escritura. Si el archivo no existe se crea. **Si existe, SOBREESCRIBIRÁ TODO!!!** el contenido.\n",
    "\n",
    "  - `a`: `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",
    "  - `b`: binary, binario.\n",
    "\n",
    "  - `+`: Lectura y Escritura simultáneas.\n",
    "\n",
    "  - `U` 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(\"archivoxyz1.csv\")\n",
    "print(fhola)\n",
    "\n",
    "fhola.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***siempre que se finalice el trabajo de lectura y/o escritura sobre el archivo deberá cerrarse.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fhola.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lectura y Escritura (I/O)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `read()` : Leyendo el contenido completo del archivo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fobj = open(\"ofortuna.txt\")\n",
    "todo = fobj.read()\n",
    "print(todo)\n",
    "print(type(todo))\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(\"ofortuna.txt\")\n",
    "parte = fobj.read(50)\n",
    "print(parte)\n",
    "fobj.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `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, `\\n`, incluyendo este carácter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fobj = open(\"ofortuna.txt\", \"r\")\n",
    "linea = fobj.readline()\n",
    "print(linea)\n",
    "print(type(linea))\n",
    "fobj.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora leer todo el contenido del archivo línea por línea"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fobj = open(\"ofortuna.txt\", \"r\")\n",
    "\n",
    "for i in range(33):\n",
    "    linea = fobj.readline()\n",
    "print(linea)\n",
    "\n",
    "fobj.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `readlines()`: lee todas las líneas del archivo y devuelve una lista con las líneas leídas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fobj = open(\"ofortuna.txt\", \"r\")\n",
    "lineas = fobj.readlines()\n",
    "print(lineas)\n",
    "print(type(lineas))\n",
    "fobj.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(lineas)"
   ]
  },
  {
   "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": [
    "lineas[28]"
   ]
  },
  {
   "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(\"numeros.txt\")\n",
    "numeros = float(fnumeros.readline())\n",
    "print(type(numeros))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(numeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede hacer de una forma más \"corta\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "masnumeros = open(numeros.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(\"numeros.txt\").readlines()\n",
    "masnumeros = [float(i.rstrip()) for i in masnumeros]\n",
    "print(masnumeros)\n",
    "print(type(masnumeros[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 that is the question!\")\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. Realice un programa que separe cada una de las estrofas del archivo *O Fortuna* en archivos independientes. El único dato que debe ingresar el usuario es el nombre del archivo de datos, el resto, la generación del nombre de cada uno de los archivos de salida así como su contenido, deberá ser generado de forma automática por el programa.\n",
    "\n",
    "\n",
    "2. 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",
    "\n",
    "3. Haga un programa que calcule el plan de pagos de un préstamo bancario. El plan de pagos (una tabla) deberá ser presentada en un archivo de salida."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Tabla de Contenidos",
   "title_sidebar": "Contenidos",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}