Serialização de Objetos em Python

Sumário

Vez por outra precisamos enviar dados via rede, seja através de uma já tradicional conexão HTTP, ou até mesmo através de um socket UDP cruzão, e é bem comum que esses dados estejam representados em nosso programa através de uma instância de uma classe por nós mesmos definida. No entanto, na hora de enviar esse objeto pela rede, é preciso que tenhamos esses dados representados de forma contínua (diferentemente de simples referências a posições de memória) e, muitas vezes, de uma forma que possa ser lida por um sistema diferente do sistema no qual o objeto foi criado. Para atender a esses requisitos, é necessária a serialização de dados, que trata da representação de objetos ou estruturas de dados em um formato que permita que estas sejam armazenado em um disco (ou enviadas pela rede) para posterior recriação do objeto em memória.

Veja mais sobre serialização no artigo da Wikipedia sobre o assunto.

Como serializar?

Em Python, existem diversos mecanismos disponíveis para serialização de dados. A escolha vai depender do tipo de aplicação exigida. Veremos a seguir alguns mecanismos para serialização de objetos:

Pickle

pickle é um módulo que provê a serialização de objetos Python, transformando objetos quaisquer em sequências de bytes. No exemplo a seguir, vamos serializar uma lista:

>>> import pickle
>>> lista = [1, 'hello!', [1, 2, 3]]
>>> s = pickle.dumps(lista)
>>> print s
"(lp0\nI1\naS'hello!'\np1\na(lp2\nI1\naI2\naI3\naa."
>>> type(s)
<type 'str'>

O método dumps() é o responsável por pegar os dados do objeto em questão e gerar uma sequência de bytes capaz de representar tais dados, de forma que estes possam ser transmitidos pela rede, armazenados em um arquivo, e depois, recuperados para o seu formato original (em nosso caso, um objeto list).

>>> print s
"(lp0\nI1\naS'hello!'\np1\na(lp2\nI1\naI2\naI3\naa."
>>> lista_recuperada = pickle.loads(s)
>>> print lista_recuperada
[1, 'hello!', [1, 2, 3]]
>>> type(lista_recuperada)
<type 'list'>

Já o método loads() é responsável por pegar uma sequência de bytes (representada por uma string) e convertê-la de volta para o objeto Python que originalmente representava (veja o exemplo acima).

O dumps() e o loads() serializam e de-serializam os objetos para strings e a partir de strings, respectivamente. Existem também as versões dos mesmos métodos que lidam com dados serializados que estão armazenados em arquivos. São eles os métodos dump() e load() (sem o s no final do nome).

Para serializar um objeto usando a função dump(), é preciso passar a ela o arquivo no qual queremos que o objeto serializado seja gravado:

>>> pickle.dump(lista, open('data.pkl', 'wb'))

(Repare que passamos uma referência ao arquivo já aberto, não somente o nome do arquivo)

Podemos agora verificar o conteúdo do arquivo data.pkl pelo shell do sistema operacional:

user@host$ cat data.pkl
(lp0
I1
aS'hello!'
p1
a(lp2
I1
aI2
aI3
aa.

Para reconstruir as informações contidas no arquivo em um objeto Python, vamos usar o método load():

>>> recuperada = pickle.load(open('data.pkl'))
>>> print recuperada
[1, 'hello!', [1, 2, 3]]

Barbada, não? Ainda existe também uma implementação do mesmo protocolo no módulo cPickle, que, por ser implementado em C, possui um desempenho muito superior ao do Pickle (de acordo com a documentação, pode ser até 1000 vezes mais rápido). Porém, por não se tratar de código Python, existem algumas restrições nele, como não podermos subclasseá-lo (estendê-lo).

Apesar de ser fácil de utilizar, o pickle serializa os dados em um formato próprio (não-popular com outras linguagens). Sendo assim, o pickle será uma boa opção para serializar objetos para envio/gravação somente para outros programas também escritos em Python.

Serializando objetos customizados

É comum criarmos classes novas em nossos projetos e muitas vezes é necessário serializar instâncias dessas classes. O Pickle pode ser usado para isso também. Veja o exemplo abaixo, onde criamos uma classe Objeto, e em seguida serializamos uma instância dela:

>>> class Objeto(object):
....:
....:    def __init__(self):
....:        self.x = 42
....:        self.s = 'hello, world'
....:        self.l = [1, 2, 3]
>>> o = Objeto()
>>> s = pickle.dumps(o)
>>> print s
ccopy_reg
_reconstructor
p0
(c__main__
Objeto
p1
c__builtin__
object
p2
Ntp3
Rp4
(dp5
S'x'
p6
I42
sS's'
p7
S'hello, world'
p8
sS'l'
p9
(lp10
I1
aI2
aI3
asb.
>>> obj = pickle.loads(s)
>>> print obj
<__main__.Objeto object at 0x1c12790>

Marshal

O módulo marshal tem uma interface bem semelhante ao pickle, com seus métodos load, loads, dump e dumps. Porém, não é recomendado o seu uso para serialização de objetos em aplicações, por não ser garantida a compatibilidade entre versões do interpretador Python (de acordo com a documentação, esse módulo existe para uso interno no interpretador).

Exemplos de uso:

>>> import marshal
>>> print marshal.dumps(lista)
[ishello![iii
>>> print marshal.loads(s)
[1, 'hello!', [1, 2, 3]]

As informações são serializadas para um formato binário. Não vamos nos alongar muito nesse módulo, visto que ele não deve ser usado em aplicações do dia-a-dia.

Struct

struct é um módulo que faz o meio de campo entre objetos Python e estruturas em C. Agora, ao invés dos métodos dump e load, temos pack e unpack.

>>> import struct
>>> p = struct.pack('i5s', 42, 'hello')
>>> p
'*\x00\x00\x00hello'

O seu uso é mais complicado do que o pickle ou o marshall. Vamos rever a chamada à função pack na linha 2 do trecho de código acima:

pack('i5s', 42, 'hello')

O primeiro argumento passado para a função pack deve ser o formato que irá definir como será a estrutura C que irá armazenar os dados dos nossos objetos Python. No exemplo acima, informamos através da string 'i5s' que a estrutura possui 2 campos:

  • um int (representato por i);
  • uma string (char * em C) com 5 posições ('5s');

Para recriar os objetos Python através do dado serializado em forma de struct, vamos usar a função unpack:

>>> num, s = struct.unpack('i5s', p)
>>> print num
42
>>> print s
'hello'
>>> struct.unpack('i5s', p)
(42, 'hello')

Perceba que a função unpack retorna uma tupla contendo os dados que estavam empacotados dentro da estrutura.

Esse formato também não é o melhor para transporte de dados, pois é dependente da arquitetura do computador. Assim sendo, um pacote empacotado em uma máquina poderia ter problemas para ser desempacotado em uma máquina de arquitetura diferente. Além disso, ele só é capaz de empacotar dados dos tipos mais simples, como os tipos numéricos, strings e booleanos.

JSON

O JSON talvez seja hoje o formato para dados intercambiáveis mais utilizado. Esse formato de dados é muito usado em serviços web, e também para o transporte de dados usando outros protocolos. Como ele já foi visto em outros posts (aqui e aqui), não vamos nos aprofundar muito na sua utilização. Vamos ver somente um exemplo simples:

>>> import json
>>> lista = [1, 'hello!', [1, 2, 3]]
>>> s = json.dumps(lista)
>>> s
'[1, "hello!", [1, 2, 3]]'
>>> print type(s)
<type 'str'>
>>> l = json.loads(s)
>>> l
'[1, u'hello!', [1, 2, 3]]'
>>> print type(l)
<type 'list'>

Como já foi visto nos posts anteriormente referidos, JSON pode ser usado para trafegar estuturas de dados mais complexas, em um formato parecido com o de dicionários Python. Assim, esse post aqui mostra praticamente nada da capacidade desse formato (se quiser saber mais, veja os posts anteriores).

Caso você não conheça o JSON, sugiro fortemente que procure documentação sobre ele, pois é um formato muito bom para tráfego de dados entre ambientes heterogêneos.

Shelve

O shelve é um módulo que provê um tipo de dados com uma interface similar a de um dicionário (chamado de shelf), e que agrega a funcionalidade de persistir esse dicionário em um arquivo para uso posterior. Ou seja, o shelve nos provê dicionários persistentes.

Vamos ver um exemplo:

>>> import shelve
>>> user = shelve.open('data.txt')
>>> user['nickname'] = 'stummjr'
>>> user['city'] = 'Blumenau'
>>> user['twitter'] = 'stummjr'
>>> print user
{'city': 'Blumenau', 'twitter': 'stummjr', 'nickname': 'stummjr'}
>>> user.close()

Perceba que a chamada a shelve.open() abre um shelf (se ainda não existir, ele é criado). Depois, podemos manipular o objeto retornado por esta chamada como se fosse um dicionário. Para persistir os dados no arquivo data.txt, é necessário fechar o shelf em questão (user.close()).

Em outro momento, poderíamos recuperar os dados da seguinte forma:

>>> import shelve
>>> user = shelve.open('data.txt')
>>> print user
{'city': 'Blumenau', 'twitter': 'stummjr', 'nickname': 'stummjr'}
>>> user['blog'] = 'pythonhelp.wordpress.com'
>>> user.close()

Legal, né? O shelve nos dá uma forma bem prática de persistir dados. O exemplo acima mostra um caso bem simplificado, mas poderíamos usar um shelf para armazenar dados de várias pessoas, por exemplo:

>>> users = shelve.open('users.dat')
>>> users['stummjr'] = {'nickname': 'stummjr', 'blog': 'pythonhelp.wordpress.com', 'city': 'Blumenau'}
>>> users['eliasdorneles'] = {'nickname': 'eliasdorneles', 'blog': 'eljunior.wordpress.com', 'city': 'Floripa'}
>>> print users
{
    'eliasdorneles': {
        'blog': 'eljunior.wordpress.com',
        'city': 'Floripa',
        'nickname': 'eliasdorneles'
    },
    'stummjr': {
        'blog': 'pythonhelp.wordpress.com',
        'city': 'Blumenau',
        'nickname': 'stummjr'
    }
}

>>> users.close()
>>> users = shelve.open('users.dat')
>>> print users['stummjr']['blog']
pythonhelp.wordpress.com

Então, qual devemos usar?

Antes de mais nada, fique atento às restrições que cada abordagem possui. Por exemplo, dentro das opções apresentadas acima, a única que possui implementação em uma ampla variedade de linguagens é o JSON. Por outro lado, o shelve nos provê essa facilidade de manipular dados em dicionários e persistí-los no disco depois. Tudo irá depender do seu objetivo ao serializar os dados.

Interoperabilidade é importante? Então vá no JSON de olhos fechados. Quer uma forma de serializar dados para uma única plataforma e que seja econômica no tamanho dos dados? Talvez struct seja a sua escolha. Enfim, leia a documentação e descubra qual das alternativas acima melhor se encaixa em suas necessidades.

5 comentários sobre “Serialização de Objetos em Python

  1. Pingback: Dicas para lidar com JSON | Python Help

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s