Transformez les touches du dictionnaire en noms de variables avec les mêmes valeurs en python à partir de fichiers .mat matlab à l'aide de scipy.io.loadmat

Question

J'essaie de prendre un dictionnaire de base temp = {'key': array ([1,2])} chargé à partir d'un fichier .mat avec scipy.io.loadmat. Tournez les touches dans le fichier de dictionnaire Python renvoyé par LoadMat () en noms de variables avec des valeurs identiques que les touches représentatives.

Ainsi, par exemple:

temp = {'key':array([1,2])}

transformé en

key = array([1,2])

Je sais comment saisir les clés avec Temp.Keys (). Ensuite, saisir les éléments est facile, mais comment puis-je forcer la liste des chaînes dans Temp.Keys () pour être des noms de variables au lieu des chaînes.

J'espère que cela a du sens, mais c'est probablement vraiment facile, je ne peux pas penser comment le faire.

Acclamations

Answer 1

Dans Python, les paramètres de la méthode peuvent être passés sous forme de dictionnaires avec le ** la magie:

def my_func(key=None):
   print key
   #do the real stuff

temp = {'key':array([1,2])}

my_func(**temp)

>>> array([1,2])

Answer 2

La meilleure chose à faire est d'utiliser temp['key']. Pour répondre à la question, cependant, vous pouvez utiliser le exec fonction. Les avantages de le faire de cette façon est que vous pouvez le faire ne pas avoir à coder dur aucun nom de variable ou à vous confiner pour travailler à l'intérieur d'une fonction.

from numpy import array,matrix

temp = {'key':array([1,2]),'b': 4.3,'c': 'foo','d':matrix([2,2])}

for k in temp:
    exec('{KEY} = {VALUE}'.format(KEY = k, VALUE = repr(temp[k])))

>>> key
array([1, 2])
>>> b
4.3
>>> c
'foo'
>>> d
matrix([[2, 2]])

REMARQUE : Cela ne fonctionnera que si vous avez importé la fonction spécifique des modules. Si vous ne voulez pas le faire en raison de la pratique du code ou du volume de fonction que vous devez importer, vous pouvez écrire une fonction pour concaténer le nom du module devant l'entrée. La sortie est la même que l'exemple précédent.

import numpy as np,numpy

temp = {'key':np.array([1,2]),'b': 4.3,'c': 'foo','d':np.matrix([2,2])}

def exec_str(key,mydict):
    s = str(type(mydict[key]))
    if '.' in s:
        start = s.index("'") + 1
        end = s.index(".") + 1
        v = s[start:end:] + repr(mydict[key])
    else:
        v = repr(mydict[key])     
    return v

for k in temp:
    exec('{KEY} = {VALUE}'.format(KEY = k, VALUE = exec_str(k,temp)))

Bien que ce ne soit pas la meilleure pratique de code, cela fonctionne bien pour tous les exemples que j'ai testés.

Answer 3

Une meilleure façon peut être de fourrer les données à un objet séparé:

class attrdict(dict):
    def __getattr__(self, k): return self[k]
    def __setattr__(self, k, v): self[k] = v

somedict = {'key': 123, 'stuff': 456}

data = attrdict(somedict)
print data.key
print data.stuff

Ceci est à peu près aussi facile à utiliser de manière interactive et ne nécessite aucune magie. Cela devrait également être OK pour Matlab-Users.

ÉDITER: Il s'avère que les choses ci-dessous ne fonctionnent pas la plupart du temps. Dommage, tellement pour la magie.

Si vous voulez vous mêler de magie, vous pouvez faire quelque chose comme

locals().update(somedict)

Cela fonctionnera bien de manière interactive, et vous pouvez même masquer l'accès à locals() à l'intérieur de la fonction de chargeur en jouant avec sys._getframe().f_back.f_locals.

Cependant, cela ne fonctionnera pas dans les fonctions:

def foo():
    locals().update({'a': 4})
    print a 

Le fait est que a Ci-dessus est lié à la variable globale au moment de la compilation, et Python n'essaie donc pas de le rechercher parmi les variables locales.

Answer 4

Alors que je recommanderais simplement d'utiliser le dictionnaire directement et d'accès aux tableaux comme temp['key'], si vous connaissiez tous les noms de variables à l'avance, vous pourriez écrire une fonction pour les extraire en variables individuelles:

def func(**kwargs):
    return kwargs['a'],kwargs['b']


temp = {'a':np.array([1,2]),'b':np.array([3,4])}
a,b = func(**temp)
del temp # get rid of temporary dict