Dicionários aninhados em Python

14jun14

Estava desenvolvendo um script e precisava de alguma estrutura que permitisse-me fazer manipulações da seguinte forma:

dicionario[dia][hora][chave1] = x
dicionario[dia][hora][chave2] = y

Ou seja, basicamente criar dicionários aninhados. Eu poderia manipular de forma mais espartana um dicionário e criar uma estrutura aninhada, porém eu queria fazer isso de uma forma mais direta. Queria que essa criação fosse invisível a mim. Dessa forma, eu encontrei o defaultdict. O defaultdict é uma classe do módulo collections em python que faz exatamente o que queria. Infelizmente pra meu azar, essa classe só foi inserida na versão 2.5 da linguagem e a versão que eu tinha disponível no servidor era apenas a 2.4 – old but gold.

Depois de uma pesquisada na internet, encontrei uma implementação da classe defaultdict no qual venho usando desde então nos meus scripts. Abaixo segue a implementação e um exemplo de uso.

CODE

http://pastebin.com/8LDaqW4G
#!/usr/bin/python

class defaultdict(dict):
    def __init__(self, default_factory=None, *a, **kw):
        if (default_factory is not None and
            not hasattr(default_factory, '__call__')):
            raise TypeError('first argument must be callable')
        dict.__init__(self, *a, **kw)
        self.default_factory = default_factory
    def __getitem__(self, key):
        try:
            return dict.__getitem__(self, key)
        except KeyError:
            return self.__missing__(key)
    def __missing__(self, key):
        if self.default_factory is None:
            raise KeyError(key)
        self[key] = value = self.default_factory()
        return value
    def __reduce__(self):
        if self.default_factory is None:
            args = tuple()
        else:
            args = self.default_factory,
        return type(self), args, None, None, self.items()
    def copy(self):
        return self.__copy__()
    def __copy__(self):
        return type(self)(self.default_factory, self)
    def __deepcopy__(self, memo):
        import copy
        return type(self)(self.default_factory,
                          copy.deepcopy(self.items()))
    def __repr__(self):
        return 'defaultdict(%s, %s)' % (self.default_factory,
                                        dict.__repr__(self))

def recursively_default_dict():
    return defaultdict(recursively_default_dict)

if __name__ == '__main__':
    dic = recursively_default_dict()
    dic['a']['b']['c'] = 3
    dic['a']['b']['d'] = 4

    print "dic['a']['b']['d']", dic['a']['b']['c']
    print "dic['a']['b']['d']", dic['a']['b']['d']
Anúncios


No Responses Yet to “Dicionários aninhados em Python”

  1. Deixe um comentário

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


%d blogueiros gostam disto: