2-lectura-escritura.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lectura y escritura de archivos\n",
    "\n",
    "Siempre necesitamos leer y escribir archivos. Es la forma básica de interactuar con el resto del sistema, introducir y exportar datos para la \"computación\". Como en Python todo es un objeto, lo que tenemos es un \"objeto manejador de archivos\" . La forma más básica de obtener uno es con la función `open()` que se le dice la ruta al archivo y modo/s, que se especifican con \n",
    "\n",
    "\n",
    "       'r': lectura (default)\n",
    "       'w': (sobre)escritura\n",
    "       'a': agregar contenido al final \n",
    "       'x': para escribir, pero no sobreescribe si existe el path\n",
    "       'b': modo binario\n",
    "       't': modo texto (default)\n",
    "       '+':\tactualizar contenido\n",
    "       \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos a leer un archivo de coordenadas en formato `.xyz`. La forma de estos archivos es:\n",
    "\n",
    "`natoms`\n",
    "\n",
    "`El1   x1   y1   z1`\n",
    "\n",
    "`El2   x2   y2   z2`\n",
    "\n",
    "`El3   x3   y3   z3`\n",
    "\n",
    "`El4   x4   y4   z4`\n",
    "\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Abrimos el archivo en modo lectura:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "coords = open('benceno.xyz', 'r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero `coords` es un **objeto**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(coords)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para leer las líneas hay varias opciones. Si el archivo no es muy pesado se puede cargar completamente en la memoria RAM, con el método `readlines()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "lines = coords.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines #es una lista, cada elemento es una línea completa del archivo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(lines) #número de líneas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviamente la primera línea no es el número de átomos directamete, hay que hacerle unos cambios para poder leer de ahí el número. En primer lugar quitar el \\n del final, esto se hace con el método `strip()`. También hay que convertirlo a entero, con la función `int`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines[0].strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "natoms = int(lines[0].strip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "natoms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Luego sabemos que la línea 1 no contiene información útil. A partir de la línea 2, queremos guardar en listas el símbolo del elemento y las coordenadas. Aquí deberemos usar el método `split()`, que genera una lista separando todos los strings separados por espacios en la línea.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "linea2 = lines[2].strip().split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "linea2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "linea2[0],float(linea2[1]),float(linea2[2]),float(linea2[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método más fácil es generar listas vacías e ir guardando sucesivamente la información que se lea del archivo usando `append`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "names = []\n",
    "x = []\n",
    "y = []\n",
    "z = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for idx in range(2,natoms+2):\n",
    "    linea = lines[idx].strip().split()\n",
    "    names.append(linea[0])\n",
    "    x.append(float(linea[1]))\n",
    "    y.append(float(linea[2]))\n",
    "    z.append(float(linea[3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A todo esto lo podemos encapsular en una función a la que le demos el archivo y nos devuelva las listas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def readCoords(filename):\n",
    "    coords = open(filename, 'r')\n",
    "    lines = coords.readlines()\n",
    "    natoms = int(lines[0].strip())\n",
    "    names = []\n",
    "    x = []\n",
    "    y = []\n",
    "    z = []\n",
    "    for idx in range(2,natoms+2):\n",
    "        linea = lines[idx].strip().split()\n",
    "        names.append(linea[0])\n",
    "        x.append(float(linea[1]))\n",
    "        y.append(float(linea[2]))\n",
    "        z.append(float(linea[3]))\n",
    "    return names, x, y, z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Bname, Bx, By, Bz = readCoords('benceno.xyz')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------------------------\n",
    "Ahora supongamos que queremos **escribir** un archivo de coordenadas. Para eso abrimos un archivo en modo \"write\" y usamos el método `write` para escribir línea a línea, recordando introducir un salto de línea `\\n` cuando corresponda.\n",
    "\n",
    "Algo importante es saber escribir cadenas con números dándoles un formato. Esto se hace colocando llaves donde van los números, dentro de las cuales se indica el formato, y al final usando el método `format()` de las cadenas, rellenar esas llaves con los valores adecuados. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ejemplo = 'El número pi con 10 cifras decimales es {:.10f}'.format(math.pi)\n",
    "print(ejemplo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora vamos a la escritura del archivo en sí:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "outcoords = open('out_benceno.xyz', 'w')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "outcoords.write('{}\\n'.format(natoms))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "outcoords.write('\\n') # linea en blanco"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for idx in range(natoms):\n",
    "    outcoords.write('{} \\t {:.15f} \\t {:.15f} \\t {:.15f} \\n'.format(names[idx],2*x[idx],y[idx],z[idx]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(`\\t` quiere decir `<TAB>` )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "outcoords.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cat out_benceno.xyz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}