Módulo de archivo temporal de Python

A menudo, en nuestros programas, necesitamos almacenar información temporal sobre el estado del programa y los objetos que pueden o no vivir más allá del estado del programa en sí. Es posible que los datos que se guardan en estos archivos no estén en un formato legible por humanos o incluso en un formato que pueda ser utilizado por cualquiera, pero algunos programas, algoritmos o piratas informáticos pueden encontrar una manera de obtener información de estos datos, lo que puede sacrificar la seguridad del sistema. Entonces, necesitamos crear una lógica que cree estos archivos, escribir algunos datos y luego eliminar los archivos también. ¿Y si hubiera algo que abstraiga tantas operaciones en nuestro programa?? Parece que hay un módulo en Python para el mismo, el archivo temporal módulo.

Ejemplos con el módulo de archivo temporal

Comenzaremos con ejemplos simples con Python archivo temporal módulo aquí.

Creando archivos temporales

Lo primero que se necesita para guardar datos temporales son los archivos donde podemos almacenar estos datos. Esto se puede hacer usando el Archivo temporal() función. La mayor ventaja de esta función es que cuando se crea un archivo con esta función, no se realizan enlaces a este archivo en el sistema de archivos del sistema y, por lo tanto, no es posible que otros procesos accedan a estos archivos.

Veamos un programa simple que hace uso de la Archivo temporal() función:

importar sistema operativo
importar archivo temporal
# Uso de PID en el nombre del archivo para una mejor identificación
archivo = '/ tmp / linuxhint_% s.txt '% os.getpid ()
# Proporcionar modo de archivo
temp_file = open (archivo, 'w + b')
intentar:
print ('archivo_temp: 0'.formato (archivo_temp))
print ('archivo_temp.nombre: 0 '.formato (archivo_temp.nombre))
finalmente:
temp_file.cerca()
# Eliminando el archivo temporal nosotros mismos
os.Remover archivo)
print ('Metadatos del archivo temporal:')
temp_file = tempfile.Archivo temporal()
intentar:
print ('archivo_temp: 0'.formato (archivo_temp))
print ('archivo_temp.nombre: 0 '.formato (archivo_temp.nombre))
finalmente:
# Limpia el archivo cuando se llama a cerrar
temp_file.cerca()

Esto es lo que obtenemos con este comando:

Creando archivo temporal

Este archivo se elimina tan pronto como cerca() la función se llama en el archivo temporal referencia.

Leyendo desde archivo temporal

Incluso leer desde un archivo temporal es fácil y se puede hacer con una sola llamada a un método en el mismo módulo. La ventaja de esta función es que nos ayuda a evitar operaciones complejas de IO involucrado si necesitamos hacer estas operaciones manualmente. Aquí hay un programa que muestra esta función en acción:

importar sistema operativo
importar archivo temporal
tempFile = tempfile.Archivo temporal()
intentar:
print ('Escribiendo datos en tempFile:')
tempFile.escribir (b'Acualquier dato puede ir aquí.')
tempFile.buscar (0)
print ('Leyendo datos del formulario tempFile: \ n \ t 0'.formato (tempFile.leer()))
finalmente:
tempFile.cerca()

Veamos el resultado de este comando:

Python leído desde un archivo temporal

Todo el texto de los archivos temporales se devolvió con una única llamada al método.

Escribir texto sin formato en un archivo temporal

En nuestros programas anteriores, todos los datos escritos en archivos no estaban en forma de formato de texto plano simple. Si queremos hacerlo para operaciones de texto simples, podemos simplemente modificar el modo de archivo cuando abrimos el archivo temporal para modificaciones:

importar archivo temporal
fileMode = 'w + t'
con archivo temporal.TemporaryFile (mode = fileMode) como archivo:
expediente.Writelines (['Linux \ n', 'Ubuntu \ n'])
expediente.buscar (0)
para el artículo en el archivo:
imprimir (artículo.rstrip ())

Esto es lo que obtenemos con este comando:

Escribir texto sin formato en el archivo

Creación de archivos temporales con nombre

Los archivos que deben distribuirse en varios procesos deben tener un nombre para que un proceso no los elimine cuando se completa. Así es como podemos crear un archivo temporal con nombre:

importar sistema operativo
importar archivo temporal
tempFile = tempfile.NamedTemporaryFile ()
intentar:
print ('tempFile: 0'.formato (tempFile))
imprimir ('temp.tempFile: 0 '.formato (tempFile.nombre))
finalmente:
# Eliminando el archivo también
tempFile.cerca()
print ('¿Existe? : 0 '.formato (os.camino.existe (tempFile.nombre)))

Veamos el resultado de este comando:

Archivo temporal con nombre

Si no eliminamos el archivo, podemos verificar su existencia en otro programa y usarlo si existe en la ubicación especificada.

Proporcionar el sufijo y el prefijo del nombre de archivo

Para identificar fácilmente los archivos que pertenecen a nuestros propios procesos en el sistema de archivos, también podemos aplicar Sufijo y Prefijo al nombre del archivo:

importar archivo temporal
tempFile = tempfile.NamedTemporaryFile (sufijo = '_ ubuntu',
prefijo = 'linuxhint_',
dir = '/ tmp',)
intentar:
imprimir ('tempFile:', tempFile)
print ('tempFile.nombre: ', tempFile.nombre)
finalmente:
tempFile.cerca()

Esto es lo que obtenemos con este comando:

Aplicar prefijo y sufijo al nombre de archivo

Proporcionamos tres parámetros al método que actúa como sufijo y prefijo para el nombre del archivo que se hará en la ubicación que especificamos.

Conclusión

En esta lección, vimos cómo podemos hacer uso del módulo de archivo temporal de Python para administrar archivos temporales en nuestro código. Lea más publicaciones basadas en Python aquí.