El almacenamiendo de datos en general se refiere a la persistencia en el tiempo de la información dentro de la computadora luego terminada la ejecución de un programa o incluso cortando la energía del equipo apagándolo por completo evitando la pérdida de los datos. Este almacenamiento se puede realizar en archivos externos o en bases de datos.
Los archivos externos pueden ser planos o binarios. De momento vamos a guardar texo en archivos de texto plano y los pasos para guardar la información en estos archivos, o lo que es lo mismo abrir un archivo en modo escritura. Los pasos para guardar información en un archivo de texto son:
1.- Crear el archivo externo.
2.- Abrir el archivo externo
3.- Manipular el archivo externo, ya sea para leer o escribir datos en él
4.- Cerrar el archivo una vez finalizada las operaciones de manipulación del archivo
Para ilustrar lo antes mencionado vamos a mostrar un ejemplo en Python, para ello vamos a valernos del módulo estándard de Python IO.SYS. De momento vamos a importar del módulo IO.SYS el método open. La sintaxis del método open es <variable archivo>=open('<nombre del archivo>',<modo de <acceso>), en donde el modo de acceso puede ser: r/w/x/a/b/t/+. Veamos el código:
from io import open
archivo_texto = open('archivo.txt','w')
sCadenadeTexto ='Esta es una prueba de ingreso de texto a un archivo\ndesde Python.'
archivo_texto.write(sCadenadeTexto)
archivo_texto.close()
Resultado:
Podemos comprobar como se ha creado un archivo llamado archivo.txt que contiene el texto:
Esta es una prueba de ingreso de texto a un archivo
desde Python.
Como podemos comprobar incluso ha escrito el salto de línea (\n).
Tambien es posible abrir un archivo en modo lectura. Para ello basta con usar el método open() con la opción 'r' de lectura (read). Veamos el ejemplo en la práctica:
from io import open
archivo_texto = open('archivo.txt','r')
sCadenaTexto = archivo_texto.read()
archivo_texto.close
print(f'''
El contenido del archivo de texto es:
*********************************************************************
{sCadenaTexto}
*********************************************************************
''')
Resultado:
El contenido del archivo de texto es:
*********************************************************************
Esta es una prueba de ingreso de texto a un archivo
desde Python.
*********************************************************************
Como podemos comprobar se ha recuperado el contenido del archivo archivo.txt y se ha mostrado su contenido exitosamente. Es importante siempre recordar cerrar el archivo una vez terminado su uso.
Lectura de lineas enteras de texto
Es posible al leer un archivo de texto extraer su contenido línea a línea. Esto gracias al método readlines(). Este método extrae las líneas del archivo de texto una a una y devuelve una lista en donde cada item es una línea del archivo de texto. Veamos como sería en la práctica:
from io import open
archivo_texto = open('archivo.txt','r')
linea_texto= archivo_texto.readlines()
archivo_texto.close
print(type(linea_texto),"\n",linea_texto)
Resultado:
<class 'list'>
['Esta es una prueba de ingreso de texto a un archivo\n', 'desde Python.']
Como podemos comprobar Python ha mostrado el tipo de objeto en que se ha convertido la variable linea_texto y podemos confirmar que es del tipo lista y cada item de ella es una línea del archivo de texto de donde ha sacado la información.
Agregando mas datos a archivo de texto
Es posible agregar nuevas líneas al archivo de texto anterior, se logra usando el método open() con el parámetro 'a' (append). Veamos como quedaría en a práctica:
from io import open
archivo_texto=open('archivo.txt','a')
sNueva_linea='\nEsta es una nueva linea agregada desde Python.'
archivo_texto.write(sNueva_linea)
archivo_texto.close
Resultado:
Esta es una prueba de ingreso de texto a un archivo
desde Python.
Esta es una nueva linea agregada desde Python.
De esta manera podemos comprobar que el código está agregando nuevas líneas al archivo creado anteriormente.
Puntero dentro de un fichero de texto
Dentro de un archivo de texto se conoce como puntero la ubicación de un objeto virtual que sirve de guía a modo de marcalibros pero con la precisión de un caracter. Equivale a cursor en un documento de texto. Al abrir un archivo de texto en Python, por defecto la posición inicial del cursor es al inicio, es decir antes del primer caracter y al terminar de leer el archivo su posición final es al final del último caracter, es por esto que si se hace una segunda lectura del archivo no se mostrará nada ya que al quedar el cursor al final Python no encuentra nada a continuación. Comprobemos lo dicho anteriormente:
import os
os.system('cls')
from io import open
archivo_texto = open('archivo.txt','r')
print(archivo_texto.read())
print(archivo_texto.read())
Resultado:
Esta es una prueba de ingreso de texto a un archivo
desde Python.
Como podemos comprobar se ha impreso el contenido del archivo una sola vez. Esto debido a que el cursor del archivo quedó luego del último caracter y el método de lectura del archivo es siempre a partir del cursor en adelante. Si deseamos mover el puntero a una nueva posición necesitamos valermos del método .SEEK(). Su sintaxis es como sigue:
<objeto de archivo>.SEEK(<posición en el archivo>)
Veamos el método SEEK() en acción:
import os
os.system('cls')
from io import open
archivo_texto = open('archivo.txt','r')
print(archivo_texto.read())
archivo_texto.seek(0)
print(archivo_texto.read())
Resultado:
Esta es una prueba de ingreso de texto a un archivo
desde Python.
Esta es una prueba de ingreso de texto a un archivo
desde Python.
Como podemos comprobar ahora si se imprime 2 veces el contenido del archivo, esto por que a través del método .SEEK() se ha movido el cursor al inicio del archivo ubicando el puntero en la posición 0 y ahora Python puede leer algo despues de la posición de cursor.
Tambien existe a posibilidad a través del método ya visto .READ() que lea el contenido de un archivo hasta una posición determinada, pasando la posición en donde el puntero se va a detener. Veamos un ejemplo:
import os
os.system('cls')
from io import open
archivo_texto=open('archivo.txt','r')
print(archivo_texto.read(15))
Resultado:
Esta es una pru
Como podemos comprobar, a través del método .READ() se han extraído únicamente los primeros 15 caracteres del objeto archivo. Es importante destacar que el puntero queda en esta posición hasta que se realice una nueva lectura o se mueva especificamente hasta otra posición. Podemos comprobar que el puntero quedó en la posición 15 si repetimos la operación con el método .READ() y la lectura se inicia desde el punto anterior donde había quedado el puntero. Comprobemos el planteamiento anterior:
import os
os.system('cls')
from io import open
archivo_texto=open('archivo.txt','r')
print(archivo_texto.read(15))
print(archivo_texto.read())
Resultado:
Esta es una pru
eba de ingreso de texto a un archivo
desde Python.
Como podemos observar en la primera ejecución del método .READ(15), extrajo los primeros 15 caracteres del archivo, mientras que en la segunda ejecución extrajo todo el contenido del archivo desde la posición actual del puntero, que en este caso es la posición 15 como podemos comprobar al ver el texto impreso por pantalla.
Un punto importante a tomar en cuenta es que a través de la función LEN(), podemos determinar la longitud en caracteres de un archivo. Veamos el siguiente código:
import os
os.system('cls')
from io import open
archivo_texto=open('archivo.txt','r')
nCaracteres = len(archivo_texto.read())
archivo_texto.seek(0)
print(f'''
**********************************************************************************
Contenido del archivo de texto {archivo_texto.name} : Longitud: {nCaracteres} caracteres
{archivo_texto.read()}
**********************************************************************************
''')
Resultado:
**********************************************************************************
Contenido del archivo de texto archivo.txt : Longitud: 65 caracteres
Esta es una prueba de ingreso de texto a un archivo
desde Python.
**********************************************************************************
Como podemos comprobar la función LEN() ha devuelto la cantidad de caracteres que contienen el objeto archivo. Nótese que hubo que mover el cursor a la posición 0, es decir al principio del archivo para poder extraer el texto completo y mostrarlo por pantalla. Tambien es posible aplicar la función LEN() para devolver la cantidad de caracteres que contiene una línea, esto se logra en combinación con el uso del método ya visto .READLINE(). Veamos un ejemplo:
import os
os.system('cls')
from io import open
archivo_texto = open('archivo.txt','r')
print('0 10 20 30 40 50 60')
print('123456789012345678901234567890123456789012345678901234567890')
print(archivo_texto.readline())
archivo_texto.seek(0)
print('La primera línea del archivo ', archivo_texto.name, ' tiene '\
, len(archivo_texto.readline()), ' caracteres')
Resultado:
0 10 20 30 40 50 60
123456789012345678901234567890123456789012345678901234567890
Esta es una prueba de ingreso de texto a un archivo
La primera línea del archivo archivo.txt tiene 52 caracteres
En este caso se ha impreso una serie de número en la cabecera a modo de regla para poder determinar rápidamente la cantidad de caracteres que contiene la línea. Hay que tomar en cuenta que el caracter 52 es el salto de línea (\n).
Mas modos de apertura de archivos
Otra manera de abrir archivos en Python es en el modo lectura y escritura, es decir que permita leer y escribir de manera simultánea. Para ello basta con establecer el método de apertura con la cadena 'r+', esto significa lectura y escritura simultánea. Veamos el siguiente ejemplo:
import os
os.system('cls')
from io import open
archivo_texto= open('archivo.txt','r+')
print(f'''
El archivo "{archivo_texto.name}" originalmente contenía el siguiente texto:
{archivo_texto.read()}
''')
archivo_texto.seek(0)
archivo_texto.write('Texto ingresado en modo lectura/escritura\n')
archivo_texto.seek(0)
print(f'''
El archivo "{archivo_texto.name}" ahora contiene el siguiente texto:
{archivo_texto.read()}
''')
Resultado:
El archivo "archivo.txt" originalmente contenía el siguiente texto:
Esta es una prueba de ingreso de texto a un archivo
desde Python.
El archivo "archivo.txt" ahora contiene el siguiente texto:
Texto ingresado en modo lectura/escritura
archivo
desde Python.
Como podemos comprobar viendo el resultado, se ha podido leer y escribir en el archivo de texto y al ejecutar el método .WRITE() sobreescribe el contenido del archivo a partir de la posición del cursor, que en este caso es 0.
Modificación de lineas enteras de texto
Ya vimos anteriormente que a través del método .READLINES() es posible leer lineas enteras de texto, sin embargo también es posible escribir líneas enteras de texto en un archivo, es el mismo procedimiento pero a la inversa, ya que se usa el método .WRITELINES() que requiere como argumento una lista con los valores de la línea que se desea insertar en el archivo. Veamos el ejemplo en la práctica, supongamos que tenemos un archivo de texto .txt con el primer párrafo de Don Quijote y deseamos sustituir la séptima línea con la icónica frase: "«El miedo es el camino hacia el Lado Oscuro. El miedo lleva a la ira, la ira lleva al odio, el odio lleva al sufrimiento. Percibo mucho miedo en ti»".
A modo de información el primer párrafo de Don Quijote dice así:
"En un lugar de la Mancha, de cuyo nombre no quiero acordarme, no ha mucho tiempo que
vivía un hidalgo de los de lanza en astillero, adarga antigua, rocín flaco y galgo corredor. Una olla
de algo más vaca que carnero, salpicón las más noches, duelos y quebrantos los sábados, lantejas
los viernes, algún palomino de añadidura los domingos, consumían las tres partes de su hacienda.
El resto della concluían sayo de velarte, calzas de velludo para las fiestas, con sus pantuflos de lo
mesmo, y los días de entresemana se honraba con su vellorí de lo más fino. Tenía en su casa una
ama que pasaba de los cuarenta y una sobrina que no llegaba a los veinte, y un mozo de campo y
plaza que así ensillaba el rocín como tomaba la podadera. Frisaba la edad de nuestro hidalgo con
los cincuenta años. Era de complexión recia, seco de carnes, enjuto de rostro, gran madrugador y
amigo de la caza.Quieren decir que tenía el sobrenombre de «Quijada», o «Quesada», que en esto
hay alguna diferencia en los autores que deste caso escriben, aunque por conjeturas verisímiles se
deja entender que se llamaba «Quijana». Pero esto importa poco a nuestro cuento: basta que en la
narración dél no se salga un punto de la verdad."
el primer paso sería abrir el archivo en modo 'r+' y leer las lÍneas del archivo pasándolas a una lista que podemos llamar lLineasQuijote a través del método .READLINES(). Veamos el código:
import os
os.system('cls')
quijote_txt = open('quijote.txt','r+')
lLineasQuijote = quijote_txt.readlines()
print(lLineasQuijote)
quijote_txt.close
Resultado:
['En un lugar de la Mancha, de cuyo nombre no quiero acordarme, no ha mucho tiempo que\n', 'vivía un hidalgo de los de lanza en astillero, adarga antigua, rocín flaco y galgo corredor. Una olla\n', 'de algo más vaca que carnero, salpicón las más noches, duelos y quebrantos los sábados, lantejas\n', 'los viernes, algún palomino de añadidura los domingos, consumían las tres partes de su hacienda.\n', 'El resto della concluían sayo de velarte, calzas de velludo para las fiestas, con sus pantuflos de lo\n', 'mesmo, y los días de entresemana se honraba con su vellorí de lo más fino. Tenía en su casa una\n', 'ama que pasaba de los cuarenta y una sobrina que no llegaba a los veinte, y un mozo de campo y\n', 'plaza que así ensillaba el rocín como tomaba la podadera. Frisaba la edad de nuestro hidalgo con\n', 'los cincuenta años. Era de complexión recia, seco de carnes, enjuto de rostro, gran madrugador y\n', 'amigo de la caza.Quieren decir que tenía el sobrenombre de «Quijada», o «Quesada», que en esto\n', 'hay alguna diferencia en los autores que deste caso escriben, aunque por
conjeturas verisímiles se\n', 'deja entender que se llamaba «Quijana». Pero esto importa poco a nuestro cuento: basta que en la\n', 'narración dél no se salga un punto de la verdad.']
Podemos comprobar hasta ahora que efetivamente Python ha creado una lista compuesta por las líneas del archivo ,txt separadas unas de otras. El siguiente paso sería buscar la línea 7 y sustituirla por la frase solicitada, para ello nos valdremos de la manipulación de listas en el objeto lLineasQuijote con el uso del índice 6, ya que los índices de las listas, como se vió en el apartado respectivo, inician en 0. Veamos el código para lograr esto:
import os
os.system('cls')
quijote_txt = open('quijote.txt','r+')
lLineasQuijote = quijote_txt.readlines()
lLineasQuijote[6] = "«El miedo es el camino hacia el Lado Oscuro. El miedo lleva a la ira, la ira lleva al odio, el odio lleva al sufrimiento. Percibo mucho miedo en ti»\n"
quijote_txt.seek(0)
quijote_txt.writelines(lLineasQuijote)
quijote_txt.seek(0)
print(quijote_txt.read())
quijote_txt.close
Resultado:
En un lugar de la Mancha, de cuyo nombre no quiero acordarme, no ha mucho tiempo que
vivía un hidalgo de los de lanza en astillero, adarga antigua, rocín flaco y galgo corredor. Una olla
de algo más vaca que carnero, salpicón las más noches, duelos y quebrantos los sábados, lantejas
los viernes, algún palomino de añadidura los domingos, consumían las tres partes de su hacienda.
El resto della concluían sayo de velarte, calzas de velludo para las fiestas, con sus pantuflos de lo
mesmo, y los días de entresemana se honraba con su vellorí de lo más fino. Tenía en su casa una
«El miedo es el camino hacia el Lado Oscuro. El miedo lleva a la ira, la ira lleva al odio, el odio lleva al sufrimiento. Percibo mucho
miedo en ti»
plaza que así ensillaba el rocín como tomaba la podadera. Frisaba la edad de nuestro hidalgo con
los cincuenta años. Era de complexión recia, seco de carnes, enjuto de rostro, gran madrugador y
amigo de la caza.Quieren decir que tenía el sobrenombre de «Quijada», o «Quesada», que en esto
hay alguna diferencia en los autores que deste caso escriben, aunque por conjeturas verisímiles se
deja entender que se llamaba «Quijana». Pero esto importa poco a nuestro cuento: basta que en la
narración dél no se salga un punto de la verdad.
Como podemos comprobar se ha cambiado satisfactoriamente la línea 7 por la frase solicitada.
Comentarios
Publicar un comentario