Scheibe pandas DataFrame durch MultiIndex Ebene oder Unterebene

Inspiriert von diese Antwort und der Mangel an eine einfache Antwort auf diese Frage ich fand mich schriftlich ein wenig syntaktischer Zucker, um das Leben einfacher zu filtern MultiIndex Ebene.

def _filter_series(x, level_name, filter_by):
    """
    Filter a pd.Series or pd.DataFrame x by `filter_by` on the MultiIndex level
    `level_name`

    Uses `pd.Index.get_level_values()` in the background. `filter_by` is either
    a string or an iterable.
    """
    if isinstance(x, pd.Series) or isinstance(x, pd.DataFrame):
        if type(filter_by) is str:
            filter_by = [filter_by]

        index = x.index.get_level_values(level_name).isin(filter_by)
        return x[index]
    else:
        print "Not a pandas object"

Aber wenn ich weiß das die pandas development team (und ich fange an, langsam!) dort gibt es bereits einen schönen Weg, dies zu tun, und ich weiß einfach nicht, was es noch!

Habe ich Recht?

Wenn Sie daran interessiert sind, mehr über das schneiden und filtern multiindex DataFrames, werfen Sie bitte einen Blick auf meine post: Wie kann ich die Scheibe oder filter MultiIndex DataFrame Ebenen?. Danke!

InformationsquelleAutor LondonRob | 2014-04-10

pandas python

4

Ich eigentlich von Ihnen positiv bewertet werden joris Antwort... aber leider ist das refactoring, die er erwähnt hat, nicht geschehen 0,14 und ist nicht passiert 0.17 weder. Also für den moment lassen Sie mich vorschlagen, eine quick-and-dirty-Lösung (natürlich abgeleitet von Jeff ist einer):
```
def filter_by(df, constraints):
    """Filter MultiIndex by sublevels."""
    indexer = [constraints[name] if name in constraints else slice(None)
               for name in df.index.names]
    return df.loc[tuple(indexer)] if len(df.shape) == 1 else df.loc[tuple(indexer),]

pd.Series.filter_by = filter_by
pd.DataFrame.filter_by = filter_by
```
... als
```
df.filter_by({'level_name' : value})
```
wo value kann in der Tat ein einzelner Wert, sondern auch eine Liste, eine Scheibe...

(ungetestet mit Platten und höhere dimension der Elemente, aber ich erwarte dass es funktioniert)

InformationsquelleAutor Pietro Battiston

Dies ist sehr einfach mit der neuen multi-index SLICER im master/0.14 (Freigabe in Kürze) finden Sie hier

Es ist eine offene Frage, um diese syntatically einfacher (seine nicht schwer zu tun), siehe hier
e.g so etwas wie dieses: df.loc[{ 'third' : ['C1','C3'] }] ich denke, ist vernünftig,

Hier ist, wie Sie es tun können (erfordert master/0.14):

In [2]: def mklbl(prefix,n):
   ...:     return ["%s%s" % (prefix,i)  for i in range(n)]
   ...: 


In [11]: index = MultiIndex.from_product([mklbl('A',4),
mklbl('B',2),
mklbl('C',4),
mklbl('D',2)],names=['first','second','third','fourth'])

In [12]: columns = ['value']

In [13]: df = DataFrame(np.arange(len(index)*len(columns)).reshape((len(index),len(columns))),index=index,columns=columns).sortlevel()

In [14]: df
Out[14]: 
                           value
first second third fourth       
A0    B0     C0    D0          0
                   D1          1
             C1    D0          2
                   D1          3
             C2    D0          4
                   D1          5
             C3    D0          6
                   D1          7
      B1     C0    D0          8
                   D1          9
             C1    D0         10
                   D1         11
             C2    D0         12
                   D1         13
             C3    D0         14
                   D1         15
A1    B0     C0    D0         16
                   D1         17
             C1    D0         18
                   D1         19
             C2    D0         20
                   D1         21
             C3    D0         22
                   D1         23
      B1     C0    D0         24
                   D1         25
             C1    D0         26
                   D1         27
             C2    D0         28
                   D1         29
             C3    D0         30
                   D1         31
A2    B0     C0    D0         32
                   D1         33
             C1    D0         34
                   D1         35
             C2    D0         36
                   D1         37
             C3    D0         38
                   D1         39
      B1     C0    D0         40
                   D1         41
             C1    D0         42
                   D1         43
             C2    D0         44
                   D1         45
             C3    D0         46
                   D1         47
A3    B0     C0    D0         48
                   D1         49
             C1    D0         50
                   D1         51
             C2    D0         52
                   D1         53
             C3    D0         54
                   D1         55
      B1     C0    D0         56
                   D1         57
             C1    D0         58
                   D1         59
                             ...

[64 rows x 1 columns]

Erstellen Sie ein indexer über alle Ebenen, der Auswahl von alle Einträge

In [15]: indexer = [slice(None)]*len(df.index.names)

Machen die wir uns interessieren nur die Einträge kümmern wir uns um

In [16]: indexer[df.index.names.index('third')] = ['C1','C3']

Wählen Sie es aus (es ist wichtig, dass dieses ist ein Tupel!)

In [18]: df.loc[tuple(indexer),:]
Out[18]: 
                           value
first second third fourth       
A0    B0     C1    D0          2
                   D1          3
             C3    D0          6
                   D1          7
      B1     C1    D0         10
                   D1         11
             C3    D0         14
                   D1         15
A1    B0     C1    D0         18
                   D1         19
             C3    D0         22
                   D1         23
      B1     C1    D0         26
                   D1         27
             C3    D0         30
                   D1         31
A2    B0     C1    D0         34
                   D1         35
             C3    D0         38
                   D1         39
      B1     C1    D0         42
                   D1         43
             C3    D0         46
                   D1         47
A3    B0     C1    D0         50
                   D1         51
             C3    D0         54
                   D1         55
      B1     C1    D0         58
                   D1         59
             C3    D0         62
                   D1         63

[32 rows x 1 columns]

Für Klarheit, dies zu tun manuell auf dieser dataframe Aussehen würde df.loc[pd.IndexSlice[:, :, ['C1','C3'], :], :] oder df.loc(axis=0)[:,:,['C1','C3'], :]
Gibt es eine Möglichkeit, wählen Sie einen Datumsbereich aus einem MultiIndex? Ich habe df.loc[:, pd.IndexSlice[:, :, :, :, 'value']] wo die ersten : wäre ein Datum und ich möchte die Scheibe durch eine Reihe von Daten und nicht nur einen einzigen Tag.
Es funktioniert auch für die Serie, wenn Sie s.loc[pd.IndexSlice[:, :, ['C1','C3'], :]] statt df.loc[pd.IndexSlice[:, :, ['C1','C3'], :], :].

InformationsquelleAutor Jeff

Haben Sie die - filter Methode, können Dinge tun, wie diese. ZB mit dem Beispiel, dass gefragt wurde, in der verbunden ALSO Frage:

In [188]: df.filter(like='0630', axis=0)
Out[188]: 
                      sales        cogs    net_pft
STK_ID RPT_Date                                   
876    20060630   857483000   729541000   67157200
       20070630  1146245000  1050808000  113468500
       20080630  1932470000  1777010000  133756300
2254   20070630   501221000   289167000  118012200

Die filter-Methode ist umgestaltet im moment (in den kommenden 0.14), und eine level Schlüsselwort Hinzugefügt werden (da kannst du jetzt ein problem haben, wenn die gleichen Etiketten werden in verschiedenen Ebenen des index).

InformationsquelleAutor joris

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.