Archivos de texto

En esta entrada veremos como trabajar con archivos simples en python.  El tipo más simple de archivos es sin duda el archivo de texto.  Un archivo de texto es una sucesión de caracteres organizada en secuencias de líneas que reside en "algún lugar" de un dispositivo de almacenamiento secundario (disco duro, pen drive, cd rom, etc.) y al cual podemos acceder mediante su ruta.  La ruta es el camino en la jerarquía de directorios que indica de manera univoca en que parte de cual dispositivo de almacenamiento secundario reside el archivo. 

Un poco sobre las rutas de archivos

En linux, la raiz de toda ruta es "/". A partir de allí se indican los directorios y subdirectorios sucesivos separando los mismos mediante la barra diagonal "/". Por ejemplo,

/home/jlaurentum/Documentos/nota.txt

sería la ruta completa de un archivo llamado "nota.txt" que reside en el disco duro de mi computadora.  Notese que el elemento final de la ruta es el nombre del archivo en sí y que los archivos tienen terminaciones o sufijos que se indican despues del punto "." en su nombre.  Así, algunas terminaciones comunes son ".tex", ".odt", ".bin" que van asociadas a los archivos de LaTeX, Libre Office Writer y programas ejecutables en Linbux respectivamente.  Un sufijo de nombre de archivo particularmente importante para nosotros es ".py", el cual denota archivos de código fuente en Python, los cuales por cierto son archivos de texto tambien.

En Güindou$, el caracter separador de directorio en las rutas es la barra diagonal invertida "\".  Para especificar la raiz, hay que identificar el dispositivo de almacenamiento o la partición del disco duro mediante una letra seguida de ":".  Así por ejemplo, en la computadora de mis esposa (que es Guindou$-dependiente), tengo un archivo cuya ruta es:

C:\Mis documentos\jlaurentum\nota.txt

Yo evito usar espacios y caracteres raros en los nombres de mis directorios o de mis archivos.  Para separar las palabras de un nombre, utilizo el caracter de piso "_" o el guión "-" en vez del espacio " ".  Bueno, con esto estamos listos para ver cómo se trabajan con archivos en python.

El protocolo de trabajo con archivos de texto: abrir, leer/escribir y cerrar

Desde el punto de vista de programación en Python, podemos ver los archivos como objetos.  Cuando creamos una instancia de tipo archivo (mediante la sentencia open), indicamos la ruta del archivo y el modo de acceso al archivo, siendo este:

• de escritura, indicado por "w" en el argumento modo de open.  Sólo será posible escribir al archivo.  Si no existe el archivo en la ruta, al abrirlo se crea.
• de lectura, indicado por "r" en el argumento modo de open.  Sólo será posible leer el arhivo.
• para anexar, indicado por "a" en el argumento modo de open.  Se podrá escribir sólo al final del archivo, sin modificar el contenido existente.
• de lectura/escritura, indicado por "r+" en el argumento modo de open.  Se podrá leer y escribir al archivo.

Existen otros argumentos para modo, pero con estos basta.  Si abrimos un archivo para lectura pero este no existe en la ruta proporcionada, se genera un error.  Por ejemplo, vamos a suponer que me equivoco al escribir el nombre de nota.txt y escribo nata.txt (el cual no existe). Entonces, al abrir el archivo en Python, tendría un error:

>>> mi_archivo = open("/home/jlaurentum/Documentos/nata.txt","r")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IOError: [Errno 2] No existe el archivo o el directorio: '/home/jlaurentum/Documentos/nata.txt'
>>>

En otro post veremos como acceder a algunas funciones del sistema operativo verificar si un archivo existe, obtener un listado de archivos en un directorio, etc.  Supóngase pues, que "nota.txt" es un archivo de texto que contiene lo siguiente (puedes copiar y pegar este archivo y guardarlo en tu computadora para hacer las pruebas):

Este es un archivo de prueba.
Esta es la segunda línea.
Y esta es la tercera línea.

Intentamos una vez más abrir el archivo (habiendolo guardado previamente en la ruta que indicamos):

>>> mi_archivo = open("/home/jlaurentum/Documentos/nota.txt","r")
>>>

¡Éxito!  Notese que el método open, cuando es exitoso, crea una instancia nueva de la clase file (archivo). Así, mi_archivo es un objeto tipo file:

>>> type(mi_archivo)
<type 'file'>
>>>

Una vez que abrimos un archivo para lectura, estamos listos para acceder a él.  Vamos a visualizar el contenido de "nota.txt" con el siguiente script:

>>> for linea in mi_archivo:
...     print linea
...
Este es un archivo de prueba.

Esta es la segunda línea.

Y esta es la tercera línea.

>>>

Observen la sentencia for- es bastante elocuente para entender que python "vé" los archivos de texto como una secuencia de líneas.  Sin darnos cuenta, ya hemos leido todas estas líneas e inclusive las hemos imprimido. Pero ... algo anda mal. ¿Porqué hay un espacio adicional entre las líneas?  Resulta que cada línea en el archivo original termina en "\n", que es el caracter invisible que indica una nueva línea.  Cuando se imprime el "\n" al final de cada línea, se imprime un salto de línea adicional al salto de línea que imprime la sentencia print.  Por eso tenemos el interlineado de arriba.  Para corregir esto, lo que tenemos que hacer es eliminar el caracter final de cada línea cuando este es un "\n".  Sin embargo, tenemos que volver a abrir el archivo nuevamente porque en el último for lo leimos todo hasta el final:

>>> mi_archivo=open("/home/jlaurentum/Documentos/nota.txt","r")
>>> for linea in mi_archivo:
...     if linea[-1]=="\n":
...             linea=linea[:-1]
...     print linea
...
Este es un archivo de prueba.
Esta es la segunda línea.
Y esta es la tercera línea.
>>>

¡Qué éxito! Pero se nos ha olvidado algo muy importante: cerrar el archivo tras haber trabajado con él:

>>> mi_archivo.close()
>>>

No se puede repetir lo suficiente lo importante que es cerrar los archivos al final.  Si no lo hacemos, los cambios que hacemos al archivo en modo escritura se pueden perder o peor aún, el archivo puede corromperse y quedar inservible.

Ahora vamos a probar la escritura de archivos.  Normalmente, cuando yo quiero procesar el contenido de un archivo, lo que hago es abrir una copia en modo lectura y crear otro archivo en modo escritura al cual voy a escribir el contenido del primer archivo procesado.  Por ejemplo, supóngase que quiero recorrer todo el archivo "nota.txt" para cambiar la palabra "la" por "su":

>>> mi_archivo.close()
>>> mi_archivo=open("/home/jlaurentum/Documentos/nota.txt","r")
>>> otro_archivo=open("/home/jlaurentum/Documentos/nota2.txt","w")
>>> for linea in mi_archivo:
...     linea=linea.replace("la","su")
...     otro_archivo.write(linea)
...
>>> otro_archivo.close()
>>> mi_archivo.close()
>>>


Entonces, buscamos el archivo "nota2.txt" y lo abrimos con el editor de texto, verificando su contenido:


Este es un archivo de prueba.
Esta es su segunda línea.
Y esta es su tercera línea.

Para este ejemplo, tuvimos suerte.  El método replace sustituye todas las ocurrencias de su primer argumento por la cadena suministrada en su segundo argumento.  Si hubiesemos tenido una palabra como "reemplazarla", se hubiese cambiado a "reemplazarsu", lo cual seguramente no hubiesemos querido.  En otra entrada de este blog hablaremos de expresiones regulares, que nos permitirán hacer un procesamiento más avanzado con data de texto.

Exiten otras formas de leer un archivo, por ejemplo, podemos leer el archivo caracter por caracter.  El siguiente script cuenta el número de caracteres de nuestro archivo de ejemplo:

>>> mi_archivo=open("/home/jlaurentum/Documentos/nota.txt","r")
>>> contador=0
>>> caracter=mi_archivo.read(1)
>>> while caracter!="":
...     contador+=1
...     caracter=mi_archivo.read(1)
...
>>> print contador
87
>>> mi_archivo.close()
>>>

Este archivo contiene 87 caracteres, es decir, su tamaño es de 87 bytes.  Observen que esto concuerda con lo que nos reporta la consulta de las propiedades de ese archivo.  Tambien podemos leer el archivo de un sólo trancazo en memoria, como una lista de cadenas:

>>> mi_archivo=open("/home/jlaurentum/Documentos/nota.txt","r")
>>> lineas=mi_archivo.readlines()
>>> print lineas
['Este es un archivo de prueba. \n', 'Esta es la segunda l\xc3\xadnea.\n', 'Y esta es la tercera l\xc3\xadnea.\n']
>>> mi_archivo.close()
>>>

Los elementos raros en esta lista de cadenas se corresponden a caracteres especiales, como la "í" con acento en "línea", cuya codificación  utf-8, en 2 bytes, es c3ad.

Finalmente, hasta las páginas web se pueden leer como archivos de texto.  Por ejemplo, el siguiente script abre la página de la primera entrada de este blog:

from urllib import *

pagina=urlopen("http://mont-epython.blogspot.com/2011/06/como-primera-entrada-de-este-blog.html")

for linea in pagina:
    print linea[:-1]
pagina.close()

No se indicó la salida del interprete python en rojo porque este script imprime muchas líneas.  Observen que el tratamiento de una página web es virtualmente idéntico al de un archivo de texto: lo abrimos, lo leemos y lo cerramos.  La ruta del archivo es simplemente la dirección URL de la página, pero al abrir esta página y leerla, no vemos lo que veriamos en el navegador, vemos otra cosa.  ¿Qué exactamente? ¡Corran el script y averigüenlo!

Referencias

• Marzal, A., Gracia, I. (2006). Introducción a la programación con Python. Universitat Jaume I.
• "7.2 Reading and Writing Files", Página web disponible en: http://docs.python.org/release/1.5/tut/node46.html.