scipy.io.loadmat verschachtelte Strukturen (d. h. Wörterbücher)

Verwendung der angegebenen Routinen (wie load Matlab .mat-Dateien mit scipy), ich konnte nicht auf tiefer verschachtelte Strukturen zu erholen, Sie in Wörterbücher

Präsentieren das problem, das ich laufen in mehr detail, ich gebe das folgende Spielzeug-Beispiel:

load scipy.io as spio
a = {'b':{'c':{'d': 3}}}
# my dictionary: a['b']['c']['d'] = 3
spio.savemat('xy.mat',a)

Nun will ich Lesen Sie die mat-Datei wieder in python. Ich habe versucht, die folgenden:

vig=spio.loadmat('xy.mat',squeeze_me=True)

Wenn ich jetzt zugreifen will, die Felder die ich bekomme:

>> vig['b']
array(((array(3),),), dtype=[('c', '|O8')])
>> vig['b']['c']
array(array((3,), dtype=[('d', '|O8')]), dtype=object)
>> vig['b']['c']['d']
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)

/<ipython console> in <module>()

ValueError: field named d not found.

Jedoch mithilfe der option struct_as_record=False Bereich zugegriffen werden konnte:

v=spio.loadmat('xy.mat',squeeze_me=True,struct_as_record=False)

Nun war es möglich, um es von

>> v['b'].c.d
array(3)

InformationsquelleAutor der Frage mergen | 2011-08-10

Hier sind die Funktionen, die rekonstruiert die Wörterbücher nutzen Sie einfach dieses loadmat anstelle von scipy.io ' s loadmat:

import scipy.io as spio

def loadmat(filename):
    '''
    this function should be called instead of direct spio.loadmat
    as it cures the problem of not properly recovering python dictionaries
    from mat files. It calls the function check keys to cure all entries
    which are still mat-objects
    '''
    data = spio.loadmat(filename, struct_as_record=False, squeeze_me=True)
    return _check_keys(data)

def _check_keys(dict):
    '''
    checks if entries in dictionary are mat-objects. If yes
    todict is called to change them to nested dictionaries
    '''
    for key in dict:
        if isinstance(dict[key], spio.matlab.mio5_params.mat_struct):
            dict[key] = _todict(dict[key])
    return dict        

def _todict(matobj):
    '''
    A recursive function which constructs from matobjects nested dictionaries
    '''
    dict = {}
    for strg in matobj._fieldnames:
        elem = matobj.__dict__[strg]
        if isinstance(elem, spio.matlab.mio5_params.mat_struct):
            dict[strg] = _todict(elem)
        else:
            dict[strg] = elem
    return dict

InformationsquelleAutor der Antwort mergen

Nur eine Erweiterung zu mergen Antwort, die leider aufhören wird recursing, wenn es erreicht ein cell array von Objekten. Die folgende version machen wird, die Listen von Ihnen statt, und die Fortsetzung der Rekursion in der Zell-array-Elemente, wenn möglich.

import scipy
import numpy as np


def loadmat(filename):
    '''
    this function should be called instead of direct spio.loadmat
    as it cures the problem of not properly recovering python dictionaries
    from mat files. It calls the function check keys to cure all entries
    which are still mat-objects
    '''
    def _check_keys(d):
        '''
        checks if entries in dictionary are mat-objects. If yes
        todict is called to change them to nested dictionaries
        '''
        for key in d:
            if isinstance(d[key], spio.matlab.mio5_params.mat_struct):
                d[key] = _todict(d[key])
        return d

    def _todict(matobj):
        '''
        A recursive function which constructs from matobjects nested dictionaries
        '''
        d = {}
        for strg in matobj._fieldnames:
            elem = matobj.__dict__[strg]
            if isinstance(elem, spio.matlab.mio5_params.mat_struct):
                d[strg] = _todict(elem)
            elif isinstance(elem, np.ndarray):
                d[strg] = _tolist(elem)
            else:
                d[strg] = elem
        return d

    def _tolist(ndarray):
        '''
        A recursive function which constructs lists from cellarrays
        (which are loaded as numpy ndarrays), recursing into the elements
        if they contain matobjects.
        '''
        elem_list = []
        for sub_elem in ndarray:
            if isinstance(sub_elem, spio.matlab.mio5_params.mat_struct):
                elem_list.append(_todict(sub_elem))
            elif isinstance(sub_elem, np.ndarray):
                elem_list.append(_tolist(sub_elem))
            else:
                elem_list.append(sub_elem)
        return elem_list
    data = scipy.io.loadmat(filename, struct_as_record=False, squeeze_me=True)
    return _check_keys(data)

InformationsquelleAutor der Antwort jpapon

2

Lösung gefunden, kann man den Zugriff auf den Inhalt von "scipy.io.matlab.mio5_params.mat_struct Objekt" kann ermittelt werden über:
```
v['b'].__dict__['c'].__dict__['d']
```
InformationsquelleAutor der Antwort mergen
0

Mir wurde geraten, auf der scipy-mailing-Liste (https://mail.python.org/pipermail/scipy-user/) , gibt es zwei weitere Möglichkeiten, auf diese Daten zuzugreifen.

Dies funktioniert:
```
import scipy.io as spio
vig=spio.loadmat('xy.mat')
print vig['b'][0, 0]['c'][0, 0]['d'][0, 0]
```
Ausgabe auf meinem Rechner:
3

Den Grund für diese Art des Zugangs: "aus historischen Gründen, in Matlab-alles ist mindestens eine 2D-array, auch Skalare."
So scipy.io.loadmat imitiert Matlab-Verhalten standardmäßig.

InformationsquelleAutor der Antwort Nenad Propadović
0

Andere Methode, die funktioniert:
```
import scipy.io as spio
vig=spio.loadmat('xy.mat',squeeze_me=True)
print vig['b']['c'].item()['d']
```
Ausgabe:

3

Habe ich gelernt, diese Methode auf die scipy-mailing-Liste zu. Ich sicherlich nicht verstehen, (noch) warum.Element()' Hinzugefügt, und:
```
print vig['b']['c']['d']
```
wirft eine Fehlermeldung statt:

IndexError: nur ganze zahlen, Scheiben (:), Ellipse (...), numpy.newaxis (None) und integer-oder boolean-arrays der gültigen Indexpositionen, die

aber ich werde wieder zur Ergänzung der Erklärung, wenn ich es wissen. Erklärung von numpy.ndarray.Element (aus thenumpy Referenz):
Kopieren Sie ein element eines Arrays zu einem standard-Python-Skalare und gibt es zurück.

(Bitte beachten Sie, dass diese Antwort ist im Grunde das gleiche wie der Kommentar von hpaulj auf die ursprüngliche Frage, aber ich fühlte, dass der Kommentar ist nicht 'sichtbar' oder verständlich genug. Ich sicherlich nicht bemerken, wenn ich suchte nach einer Lösung für die erste Zeit, vor einigen Wochen).

InformationsquelleAutor der Antwort Nenad Propadović

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.