Blog
Para leer y escribir archivos en Python, no es necesario importar ninguna librería. El lenguaje lo maneja nativamente aunque en una manera única. Para esto debemos usar la función predeterminada de Python open()
para obtener un objeto file
.
La función open()
abre un archivo, así de simple.
Cuando usamos la función open()
, esta retorna un objeto file. Los objetos file contienen métodos y atributos que se usan para recolectar información sobre el archivo que acabamos de abrir, así como también para manipular dicho archivo.
Por ejemplo, el atributo mode
de un objeto file
permite saber el modo en el que el archivo ha sido abierto. El atributo name
nos da a conocer el nombre del archivo que el objeto file
.
Tipos de archivos en Python
El concepto popular de “archivo” es un poco diferente en Python.
En Windows por ejemplo, un archivo puede ser un elemento manipulado, editado o creado por el usuario o sistema operativo. Esto quiere decir que los archivos pueden ser imágenes, documentos de texto, archivos ejecutables y mucho más. La mayoría de los archivos están organizados en carpetas individuales.
Los archivos en Python están categorizados en archivos de texto o archivos binarios, la diferencia entre estos dos tipos de archivos es de vital importancia al momento de manipularlos.
Los archivos de texto están formados por una secuencia de líneas, donde cada línea incluye una secuencia de carácteres. Esto es lo que se conoce como código o sintaxis.
Cada línea finaliza con un carácter especial, llamado EOL(End of Line) o carácter de fin de línea. Hay varios tipos de carácteres de fin de línea pero los más comunes son la coma (,) o el carácter de salto de línea (\n).
Un archivo binario es cualquier tipo de archivo que no es un archivo de texto. A causa de su naturaleza, los archivos binarios solo pueden ser procesados por una aplicación que conozca o entienda la estructura del mismo. En otras palabras, deben ser aplicaciones que puedan leer e interpretar binario.
Función open() para leer y escribir archivos en Python
Si queremos abrir un archivo para usarlo o escribir en el con Python, podemos usar la función predeterminada open()
.
Esta función creará un objeto file, el cual será utilizado para llamar a otros métodos asociados con el archivo.
Tiene la siguiente sintaxis:
archivo = open(nombre_archivo, modo, buff)
Detallemos un poco los parámetros:
- nombre_archivo: este argumento es un objeto string que contiene el nombre del archivo al que queremos acceder.
- modo: el modo de acceso determina el modo en el que el archivo ha sido abierto, por ejemplo, leer, escribir, anexar etc. Una lista completa de todos los valores posibles se especifica más adelante.
- buff: si el valor de buff(buffering) es 0 no se realiza ningún buffering. Si el valor es 1, se ejecuta un buffer de línea.
Veamos algunos de los modos más usados con los que un archivo puede ser abierto en Python:
- r -> abre un archivo solo para lectura. El puntero al archivo esta localizado al comienzo del archivo. Este es el modo predeterminado de la función.
- rb -> abre un archivo solo para lectura en formato binario. El puntero al archivo esta localizado al comienzo del archivo. Este es el modo predeterminado de la función.
- r+ -> abre un archivo para escritura y lectura. El puntero del archivo está localizado al comienzo del archivo.
- w -> abre un archivo solo para escritura. Sobreescribe el archivo si este ya existe. Si el archivo no existe, crea un nuevo archivo para escritura.
- wb -> abre un archivo solo para escritura en formato binario. Sobreescribe el archivo si este ya existe. Si el archivo no existe, crea un nuevo archivo para escritura.
- w+ -> abre un archivo para escritura y lectura. Sobreescribe el archivo si este ya existe. Si el archivo no existe, crea un nuevo archivo para escritura.
- a -> abre un archivo para anexo. El puntero del archivo esta al final del archivo si este existe. Es decir, el archivo está en modo anexo. Si el archivo no existe, crea un nuevo archivo para escritura.
>>> f = open('archivo1.txt', 'w+') >>> f.read() 'texto'
Atributos de un objeto file
Una vez que un archivo está abierto y tienes un objeto file
puedes obtener mucha información relacionada con ese archivo.
Veamos una lista de los atributos relacionados con el objeto file:
- f.closed : retorna True si el archivo está cerrado, si no, False.
- f.mode : retorna el modo de acceso con el que el archivo ha sido abierto.
- f.name : retorna el nombre del archivo.
Ejemplo:
# Abre un archivo fo = open('foo.txt', 'wb') # Abrimos el archivo llamado foo.txt en modo escritura binaria print('Nombre del archivo: ', foo.name) print('Cerrado o no: ', foo.closed) print('Modo de acceso: ', foo.mode)
Creando un archivo de texto
Para familiarizarnos con los archivos de texto en Python, vamos a crear un archivo propio y a hacer algunos ejemplos.
Utilizando el editor de texto de nuestra preferencia, creemos un archivo. Para el propósito de este tutorial vamos a llamarlo “archivoPrueba.txt”.
Ingresemos el siguiente código:
f = open('archivoPrueba.txt', 'w') f.write('Hola mundo') f.write('Este es nuestro archivo de texto') f.write('Esta es otra linea') f.close()
Cuando abrimos este archivo usando Python solo veremos el texto que le dijimos al intérprete que ingresara.
Leyendo un archivo en Python
En la práctica existen muchos modos de leer un archivo en Python, no solo uno.
Si necesitamos extraer una string que contenga todos los carácteres del archivo, podemos hacerlo usando el siguiente método:
f.read()
El método file.read()
lee una string de un archivo abierto. Es importanten tener en cuenta que las strings en Python pueden contener datos binarios aparte de datos en texto.
Veamos un ejemplo con el archivo foo.txt que creamos anteriormente:
# Abrimos el archivo fo = open('foo.txt', 'r+') # Archivo abierto en modo lectura y escritura str = fo.read(10) print('La string del archivo es: ' + str) # Cerramos el archivo fo.close()
Otra manera de leer un archivo es llamar a cierto número de carácteres. Por ejemplo, con el siguiente código el intérprete leerá los primeros cinco carácteres y los retornará como una string:
f = open('archivoPrueba.txt', 'r') print(f.read(5))
Tengamos en cuenta que estamos utilizando el mismo método file.read()
solo que esta vez especificamos el número de carácteres que queremos.
Si queremos leer un archivo línea por línea (en lugar de sacar todo el contenido del archivo de una sola vez) entonces podemos usar la función readline()
. Existen muchas razones por las cuales pudieramos querer solo una línea de un archivo de texto, tal vez solo necesitamos la primera o la última línea o una a mitad del archivo.
Pero ¿que si quisieramos todas las líneas que contiene el archivo pero separadas? Podemos usar la misma función solo que en una nueva forma. Esta es la función readlines()
. Ejemplo:
>>> archivoPrueba.readlines() ['Hola mundo', 'Este es nuestro archivo de texto', 'Esta es otra linea']
Este puede ser un modo bastante extraño de presentar información a un usuario. Pero es muy útil cuando se quiere recolectar información rápidamente para el desarrollo de programas.
Iterando a traves de un archivo
Cuando queremos leer o retornar todas las línaes de un archivo en una forma más eficiente en cuestiones de memoria y rapidez podemos utilizar el método de iterar sobre un archivo. La ventaja de usar este método es que el código que se utiliza es simple y fácil de leer.
f = open('archivoPrueba.txt', 'r') for line in f: print(line)
Este pequeño trozo de código itera a traves de todas las líneas del archivo que abrimos en modo lectura.
Utilizando el método write() de los objetos file
Una de las cosas que se harán obvias a medida que vayamos trabajando con archivos en Python, es que el método write()
solo requiere un parámetro, el cual es la string que queremos que sea escrita en el archivo.
Este método es usado para agregar información o contenido a un archivo existente. Para agregar una nueva línea después de que escribas texto en un archivo, podemos agregar un carácter de fin de línea.
f = open('archivoPrueba.txt', 'w') f.write('Esto es una prueba') f.write('Para agregar más líneas.') f.close()
Obviamente esto modificará nuestro archivo actual para incluir las dos líneas de texto.
Cerrando archivos en Python
Cuando hayamos terminado de trabajar con un archivo en Python podemos usar el método file.close()
para completar nuestro trabajo. Lo que este método hace es cerrar completamente el archivo, liberar los recursos en uso, que a su vez libera memoria para que el sistema la utilice en otro programa.
Es importante tener en cuenta que luego de que se llame al método file.close(), cualquier otro intento de usar el archivo resultará en un error.
Como pueden darse cuenta, hemos utilizado el método close() en casi todos nuestros ejemplos de código. Esta es una buena práctica.
Manejo de archivos en Python
Para ayudarles a afianzar todos estos métodos de lectura y escritura de archivos en Python, vamos a realizar algunos ejemplos de como pueden ser usados en situaciones verdaderas. Tengan la libertad de copiar el código y ejecutarlo en su intérprete de Python.
Abrir un archivo:
archivo = open('hola.txt', 'r') # Abrimos el archivo en modo lectura
Leer desde el archivo:
archivo = open('hola.txt', 'r') print(archivo.read()) # Imprimimos todo el texto del archivo en una string
Leer una línea del archivo a la vez:
archivo = open('hola.txt', 'r') print(archivo.readline())
Mostrar las líneas del archivo separadas en una lista:
archivo = open('hola.txt', 'r') print(archivo.readlines())
Escribir nuevo contenido en el archivo:
archivo = open('hola.txt', 'r') lineas_texto = ['Una linea de texto', 'y otra linea de texto', 'una mas', 'y la ultima linea de texto'] archivo.writelines(lineas_texto) archivo.close()
Anexar un archivo:
archivo = open('hola.txt', 'a') archivo.read('Hola mundo de nuevo') archivo.close()
Para cerrar completamente un archivo después de su uso:
archivo = open('hola.txt', 'r') print(archivo.read()) archivo.close()
Sentencia with
La sentencia with
en Python fue introducida por primera vez en la versión 2.5. Esta sentencia se usa para el manejo de errores, similar a la sentencia try
. La sentencia with
se usa para limpiar objetos automáticamente. Esto ayuda a reducir la cantidad de código que se necesita escribir, ya que la sentencia finally
y la limpieza manual del objeto es omitida. Podemos usar esta sentencia para abrir archivos en Python y dejar que el intérprete se encargue de cerrar el mismo.
Para usar esta sentencia, necesitaremos especificar un objeto que queramos usar seguido por la sentencia as
, la cual termina con el nombre de la variable de ese objeto que queremos usar. Ejemplo:
with open('archivo.txt', 'w') as archivo: archivo.write('Texto agregado')
En nuestro ejemplo, definimos un objeto file
seguido por la sentencia as
y el nombre con el que nos queremos referir a este objeto. El código que escribamos dentro de este bloque dependerá de nuestras necesidades. Podemos iterar a traves del objeto archivo que hemos creado o escribir en el, luego de que el intérprete termine con el bloque dentro de la sentencia with
, este cerrará automáticamente el archivo por nosotros así que nos podemos ahorrar esas líneas de código. Ejemplo:
with open('hola.txt', 'r') as archivo: print(archivo.readlines()) # No es necesario hacer una llamada al método file.close() ya que # la sentencia with se encargara de cerrar el archivo por nosotros print('Ya hemos terminado con el archivo')
Dividiendo las líneas de los archivos en Python
Como un ejemplo final, exploremos una de las funciones únicas que nos permiten dividir las líneas tomadas de un archivo de texto. El siguiente programa está diseñado para dividir la string contenida en la variable data cuando sea que el intérprete encuentre un carácter espacio.
El hecho de que este ejemplo solo divida las líneas en donde se encuentre un espacio no significa que este sea el único método para realizar algo así. En realidad un texto puede dividirse por cualquier carácter que se desee.
Veamos el código:
with open('texto1.txt', 'r') as archivo: contenido = archivo.readlines() # Separamos el contenido del archivo en lineas for linea in contenido: # Iteramos a traves de las lineas palabras = line.split() # Dividimos la linea en palabras print(palabras)
El método str.split(sep)
devuelve una lista de todas las palabras en la string original, usando el argumento sep
como separador (usando el espacio como separador predeterminado).
Ejemplo de uso
Veamos como hacer uso de todo esto que hemos discutido en un script real en Python.
def indice(nombre_archivo, bag_of_words): '''Toma el nombre de un archivo de texto y una lista de palabras. Por cada palabra en la lista, buscara las lineas en el archivo de texto donde la palabra aparezca e imprimira el numero de linea correspondiente''' paginas_palabras = {} with open(nombre_archivo) as f: lineas = f.readlines() for linea in range(0, len(lineas)-1): for palabra in lineas[linea].split(): # paginas_palabras.update({palabra:linea for palabra in linea if palabra in bag_of_words}) palabra = palabra.strip(string.punctuation) if palabra in paginas_palabras.keys(): paginas_palabras[palabra].append(linea+1) elif palabra in bag_of_words: paginas_palabras[palabra] = [linea+1] else: continue for k in paginas_palabras.keys(): print('{0:4} {1}'.format(k, paginas_palabras[k])) indice( 'texto.txt' , ['raven', 'mortal', 'dying', 'ghost', 'ghastly', 'evil', 'demon'])
hola yo necesito separar un txt de muchas lineas de comandos de cnc en distintos archivos y el separador es un caracter espesifico como lo logro?
Hola Nash, te recomiendo realizar nuestro curso gratuito de python https://unipython.com/cursos/curso-python-desde-0/ con este curso podrás programar los que necesitas. Saludos!