Si nuestra aplicación sigue el paradigma de la orientación a objetos debemos almacenar el estado del objeto para recuperarlo a posteriori. Un posible enfoque sería almacenar toda esa información en una base de datos y trabajar así con un sistema gestor de base de datos (SGBD) como MySQL. Pero existe un inconveniente en este caso, que la mayoría de SGBD son relacionales y nuestro programa sigue el modelo de la orientación a objetos (OOP) y la conversión entre modelos muchas veces no es obvia.

La alternativa que pretendo explicaros en este post es la serialización de los objetos para que sean almacenados en ficheros de texto, dándo así persistencia a nuestras aplicaciones. Me he decidido a realizar la explicación en Python su excelente mecanismo para la serialización de objetos, Pickle.

Para el post he creado una sencilla clase llamada SFSaludador que se encarga de saludar al usuario imprimiendo un “Hola!” por pantalla. El objeto guardará el total de saludos y esa información se hará persistente en un fichero llamaso “sfsaludador.txt” serializanso mediante Pickle. Os dejo el código a continuación:

import os
import pickle

class SFSaludador(object):
	"""Clase SFSludador"""

	def __init__(self, totalSaludos):
		super(SFSaludador, self).__init__()
		self.__totalSaludos = totalSaludos

	def saluda(self):
		"""Saluda"""
		print "Hola!"
		self.__totalSaludos += 1

	def getTotalSaludos(self):
		"""Devuelve el total de saludos"""
		print "He saludado " + str(self.__totalSaludos) + " veces."

	def load(self):
		"""Obtiene la informacion del archivo"""
		dataFile = open('sfsaludador.txt','r')
		self.__totalSaludos = pickle.load(dataFile)
		dataFile.close()

	def write(self):
		"""Graba los datos en el fichero"""
		dataFile = open('sfsaludador.txt','w')
		pickle.dump( self.__totalSaludos, dataFile)
		dataFile.close()

def main():
	"""Main function"""

	miSaludador = SFSaludador(0)

	if (os.path.exists('sfsaludador.txt')):
		print("Archivos encontrados. Cargando...")
		miSaludador.load()
	else:
		print("Archivos no encontrados...")

	miSaludador.getTotalSaludos()
	miSaludador.saluda()
	miSaludador.getTotalSaludos()

	miSaludador.write()

if __name__ == '__main__':
	main()

Para ejecutar el programa utilizaremos el intérprete de Python por consola de la siguiente forma (en entornos UNIX):

python SFSaludador.py

Dónde SFSaluadador.py es el fichero con el código de nuestro programa de ejemplo.

La primera vez que ejecutamos el programa no encontrará ningún fichero (así nos lo comunicará nuestra aplicación) y será al final de esta ejecución cuando creará el fichero con el estado del objeto para cargarlo en siguiente ejecuciones. Si volvemos a ejecutarlo vemos como esta vez si encuentra el fichero y el total de saludos tiene en cuenta los saludos de ejecuciones anteriores.

A veces Pickle puede llegar a ser un poco lento si necesitamos serializar muchos ficheros. Para solucionar esto existe una implentación de la librería realizada en el lenguaje de programación C, llamada cPickle. Si queremos hacer uso de ella sin tener que realizar modificaciones en nuestro código solo debemos sustituir el import de la librería por:

import cPickle as pickle

Espero que con este breve post haya podido haceros llegar la idea de la persistencia de datos en ficheros y su implementación en el potente lenguaje Python. Como siempre, ¡os espero en los comentarios!