11. Manejo de archivos en Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manejo de archivos en python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hasta ahora hemos leído por teclado las entradas de los programas. Ahora se leerán y se escribirá de archivos. En python no se requiere importar ningún módulo especial para un manejo básico de archivos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## usando ```with```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hace del manejo de archivos un proceso más sencillo. Permite tener un código más legible. With asegura un uso propio y liberación de recursos.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```open()``` toma un nombre de archivo y modo como argumentos. ```r``` abre el archivo en modo de lectura (read). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola amigos!!!\n"
     ]
    }
   ],
   "source": [
    "with open('files/data.txt', 'r') as f:\n",
    "    data = f.read()\n",
    "    print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Para escribir información en un archivo se para el argumento ```w``` (write):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('files/wdata.txt', 'w') as f:\n",
    "    data = 'estamos escribiendo en el archivo'\n",
    "    f.write(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible trabajar con direccionamiento absoluto o relativo en python. En los ejemplos anteriores se realizó direccionamiento relativo a partir de la carpeta donde se descargó este notebook. En esta carpeta hay una carpeta llamada files y allí se encuentra el archivo 'data.txt'.\n",
    "\n",
    "Para dar soporte a los diferentes sistemas operativos como windows y trabajar con direccionamiento absoluto se tienen las siguientes opciones:\n",
    "\n",
    "\n",
    "- ```\"C:\\\\ThisFolder\\\\workData.txt\"```\n",
    "- ```\"C:/ThisFolder/workData.txt\"```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otros modos de abrir archivos en python son:\n",
    "\n",
    "- 'a' – (append): Agrega información al final del archivo automáticamente.\n",
    "- 'r+' – (read/write): Este modo es usado cuando se desean hacer cambios al archivo y a la vez leer información. El puntero del archivo se ubica al principio del archivo.\n",
    "- 'a+' – (append and Read): Se abre el archivo para escribir y leer del archivo. El puntero del archivo se ubica al final del archivo.\n",
    "- x (exclusive creation): usado exclusivamente para crear un archivo. Si existe un archivo con el mismo nombre la función fallará.\n",
    "\n",
    "Para leer archivos binarios se agrega la letra b al final del modificador. Por ejemplo para leer ```wb``` y los otros serían ```rb```, ```ab```, ```r+b``` y ```a+b```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Archivos binarios y de texto en python\n",
    "\n",
    "La mayoría de archivos que se utilizan en un computador son binarios. Entre ellos:\n",
    "\n",
    "- archivos de documentos .doc, .pdf, xls\n",
    "- imágenes en formatos .jpg, .png, .bmp, .gif\n",
    "- archivos de bases de datos .mdb, .sqlite\n",
    "\n",
    "Para poder leer estos archivos, se requiere un software específico.\n",
    "\n",
    "Un archivo de texto se puede abrir con cualquier editor. Estos archivos están organizados por líneas. Los archivos de tecto tienen un caracter que identifica el final de cada línea. En python están notados por ```\\n```.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lectura de datos\n",
    "\n",
    "Para leer el contenido de un archivo se puede usar ```read()```. Sin parámetros leerá el archivo entero y almacenará el contenido la salida como un string si es un archivo de texto o como objetos en bytes si se trata de un archivo binario. \n",
    "\n",
    "Si se trata de leer un archivo más grande que la memoria disponible. No se podrá leer todo el archivo de una vez. En este caso se puede leer el archivo por bytes.\n",
    "\n",
    "Si se tiene el siguiente archivo llamado ```datos1.txt``` con el siguiente contenido:\n",
    "\n",
    "```\n",
    "    Esta es la línea 1: abcabcabc\n",
    "    Esta es la línea 2: abcabcabc\n",
    "    Esta es la línea 3: abcabcabc\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esta es la lÃ­nea 1: abcabcabc\n",
      "Esta es la lÃ­nea 2: abcabcabc\n",
      "Esta es la lÃ­nea 3: abcabcabc\n"
     ]
    }
   ],
   "source": [
    "with open('files/data1.txt', 'r') as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para no tener problemas de codificación se puede agregar el siguiente parámetro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esta es la línea 1: abcabcabc\n",
      "Esta es la línea 2: abcabcabc\n",
      "Esta es la línea 3: abcabcabc\n"
     ]
    }
   ],
   "source": [
    "with open('files/data1.txt', 'r', encoding=\"utf-8\") as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora si se desean leer solamente los primeros 6 bytes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esta e\n",
      "s la l\n"
     ]
    }
   ],
   "source": [
    "with open('files/data1.txt', 'r', encoding=\"utf-8\") as f:\n",
    "    line = f.read(6)\n",
    "    line2 = f.read(6)\n",
    "\n",
    "print(line)\n",
    "print(line2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible leer un archivo línea por línea utilizando ```readline()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esta es la línea 1: abcabcabc\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open('files/data1.txt', 'r', encoding=\"utf-8\") as f:\n",
    "    line = f.readline()\n",
    "\n",
    "print(line)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre del archivo:  files/data1.txt\n",
      "Esta es la línea 1: abcabcabc\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open(\"files/data1.txt\", \"r\", encoding='utf-8') as f:\n",
    "     print(\"Nombre del archivo: \", f.name)\n",
    "     line = f.readline()\n",
    "     print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible cargar todas las lineas del archivo como una lista si se utiliza:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre del archivo:  files/data1.txt\n",
      "['Esta es la línea 1: abcabcabc\\n', 'Esta es la línea 2: abcabcabc\\n', 'Esta es la línea 3: abcabcabc']\n"
     ]
    }
   ],
   "source": [
    "with open(\"files/data1.txt\", \"r\", encoding='utf-8') as f:\n",
    "     print(\"Nombre del archivo: \", f.name)\n",
    "     lista = f.readlines()\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La forma más sencilla y eficiente de abrir y procesar un archivo de texto es: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esta es la línea 1: abcabcabc\n",
      "Esta es la línea 2: abcabcabc\n",
      "Esta es la línea 3: abcabcabc"
     ]
    }
   ],
   "source": [
    "with open(\"files/data1.txt\", \"r\", encoding='utf-8') as work_data:\n",
    "    for line in work_data:\n",
    "        print(line, end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La anterior es la mejor forma de procesar archivos. Pues nunca carga el contenido del archivo por partes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 1\n",
    "\n",
    "Dado el archivo de texto ```files/SalesJan2009.csv```, procese el archivo para obtener las compras realizadas en un país dado:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transaction_date,Product,Price,Payment_Type,Name,City,State,Country,Account_Created,Last_Login,Latitude,Longitude\n",
      "\n",
      "1/2/2009 6:17,Product1,1200,Mastercard,carolina,Basildon,England,United Kingdom,1/2/2009 6:00,1/2/2009 6:08,51.5,-1.1166667\n",
      "\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table>\n",
    "    <tr>\n",
    "        <td>Input</td><td>Output</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>United Kingdom</td><td>100</td>\n",
    "    </tr>\n",
    " </table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Ejercicio 2\n",
    "\n",
    "Dado el archivo de texto files/SalesJan2009.csv, procese el archivo para obtener las compras realizadas con un medio de pago dado:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>Input</td><td>Output</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>Visa</td><td>521</td>\n",
    "    </tr>\n",
    " </table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escritura de archivos\n",
    "\n",
    "A menudo se prefiere utilizar ```a+``` como el modo de apertura para escribir un archivo porque permite añadir datos al final del mismo. Utilizar ```w+``` borrará cualquier dato que existe en el archivo y pues producirá un archivo en límpio para trabajar.\n",
    "\n",
    "El método por defecto para añadir datos en un archivo es ```write```:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"files/data2.txt\", \"a+\", encoding='utf-8') as work_data:\n",
    "    work_data.write(\"\\nEsta es la línea 4: abcabcabc\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esta es la línea 1: abcabcabc\n",
      "Esta es la línea 2: abcabcabc\n",
      "Esta es la línea 3: abcabcabc\n",
      "Esta es la línea 4: abcabcabc\n",
      "Esta es la línea 4: abcabcabc"
     ]
    }
   ],
   "source": [
    "with open(\"files/data2.txt\", \"r\", encoding='utf-8') as work_data:\n",
    "    for line in work_data:\n",
    "        print(line, end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se desean escribir datos que no son cadenas de texto en un archivo es necesario convertir cada dato a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = [1234, 5678, 9012]\n",
    "\n",
    "with open(\"files/data3.txt\", \"a+\") as work_data:\n",
    "    for value in values:\n",
    "        str_value = str(value)\n",
    "        work_data.write(str_value)\n",
    "        work_data.write(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1234\n",
      "5678\n",
      "9012\n"
     ]
    }
   ],
   "source": [
    "with open(\"files/data3.txt\", \"r\", encoding='utf-8') as work_data:\n",
    "    for line in work_data:\n",
    "        print(line, end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Seek: moviendo el puntero de lectura y escritura\n",
    " \n",
    "A veces es necesario moverse al principio del archivo o a alguna posición específica en un archivo dado. La forma más fácil de hacerlo es es utilizar ```fileobject.seek(offset, from_what)```.\n",
    "\n",
    "```offset``` es el número de caracteres desde la posición ```from_what```.\n",
    "\n",
    "Hay algunos valores por defecto para la posición ```from_what```:\n",
    "\n",
    "* 0 – Al principio del archivo\n",
    "* 1 – posición actual\n",
    "* 2 – al final del archivo\n",
    "\n",
    "Con archivos de texto 0 ó seek(0, 2), lo llevarán al final del archivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "letras\n",
      "\n",
      "1234\n",
      "\n",
      "5678\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open(\"files/data4.txt\", \"r\", encoding='utf-8') as work_data:\n",
    "    work_data.seek(11,0)\n",
    "    for line in work_data:\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para obtener la longitud de un archivo o la posición en donde se encuentra en un archivo se puede usar ```fileobject.tell()```. Para determinar el tamaño de un archivo en bytes se puede utilizar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31\n"
     ]
    }
   ],
   "source": [
    "with open(\"files/data4.txt\", \"a+\") as work_data:\n",
    "    print(work_data.tell())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Editando un archivo de python\n",
    "\n",
    "La forma más facil de editar un archivo dado es guardar el archivo entero en una lista y utilizar list.insert(i, x) para insertar los datos nuevos. Una vez creada la lista se puede unir (join) de nuevo y escribir esto en el archivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open the file as read-only\n",
    "with open(\"files/data5.txt\", \"r\", encoding='utf-8') as f:\n",
    "    list_content = f.readlines()\n",
    "\n",
    "list_content.insert(1, \"Esta es la línea 1.5 jajajaj\\n\")\n",
    "\n",
    "# Re-open in write-only format to overwrite old file\n",
    "with open(\"files/data5.txt\", \"w\", encoding='utf-8') as f:\n",
    "    contenido = \"\".join(list_content)\n",
    "    f.write(contenido)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esta es la línea 1: abcabcabc\n",
      "\n",
      "Esta es la línea 1.5 jajajaj\n",
      "\n",
      "Esta es la línea 2: abcabcabc\n",
      "\n",
      "Esta es la línea 3: abcabcabc\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open(\"files/data5.txt\", \"r\", encoding='utf-8') as work_data:\n",
    "    for line in work_data:\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listando archivos y directorios:\n",
    "\n",
    "En las versiones modernas de python una alternativa a ```os.listdir()``` es utilizar ```os.scandir()``` (desde python 3.5) y ```pathlib.Path()```. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data.txt\n",
      "data1.txt\n",
      "data2.txt\n",
      "data3.txt\n",
      "data4.txt\n",
      "data5.txt\n",
      "SalesJan2009.csv\n",
      "wdata.txt\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "entries = os.scandir('files/')\n",
    "for entry in entries:\n",
    "    print(entry.name + )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pickling\n",
    "\n",
    "A veces se desea almacenar información compleja tales como la información que contiene un diccionario ó una lista. Aquí es donde podemos utilizar el módulo ```pickle``` de python para serializar objetos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "name = [\"mohit\",\"bhaskar\", \"manish\"]\n",
    "skill = [\"Python\", \"Python\", \"Java\"]\n",
    "dict1 = dict([(k,v) for k,v in zip(name, skill)])\n",
    "\n",
    "with open(\"files/programming_powers.pkl\", \"wb\") as pickle_file:\n",
    "    pickle.dump(name, pickle_file)\n",
    "    pickle.dump(skill,pickle_file)\n",
    "    pickle.dump(dict1,pickle_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unpickling\n",
    "\n",
    "Para obtener los datos de vuelta es posible hacer lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['mohit', 'bhaskar', 'manish']\n",
      "['Python', 'Python', 'Java']\n",
      "{'mohit': 'Python', 'bhaskar': 'Python', 'manish': 'Java'}\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "\n",
    "with open(\"files/programming_powers.pkl\", \"rb\") as pickle_file:\n",
    "    list1 = pickle.load(pickle_file)\n",
    "    list2 = pickle.load(pickle_file)\n",
    "    dict1 = pickle.load(pickle_file)\n",
    "print(list1)\n",
    "print(list2)\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pickle obtiene los datos de forma secuencial. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias\n",
    "\n",
    "- Das, B. N. (2017). Learn Python in 7 Days. Packt Publishing Ltd.\n",
    "- https://support.spatialkey.com/spatialkey-sample-csv-data/\n",
    "- https://www.geeksforgeeks.org/with-statement-in-python/\n",
    "- https://stackoverflow.com/questions/40918503/how-to-read-a-utf-8-encoded-text-file-using-python/40918636\n",
    "- https://dbader.org/blog/python-file-io"
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}