pandas dataframe entfernen Konstante Spalte

Ich habe einen dataframe, die möglicherweise oder möglicherweise nicht haben Spalten, die den gleichen Wert. Zum Beispiel

    row    A    B
    1      9    0
    2      7    0
    3      5    0
    4      2    0

Ich würde gerne zurück nur

Gibt es eine einfache Möglichkeit zu bestimmen, ob eine Spalte vorhanden ist und dann diese entfernen?

InformationsquelleAutor user1802143 | 2013-11-26

29

Glaube ich, ist diese option schneller als die anderen Antworten hier, wie es wird, Durchlaufen die Daten-Frames nur einmal für den Vergleich und Kurzschluss wenn Sie einen nicht eindeutigen Wert gefunden wird.
```
>>> df

   0  1  2
0  1  9  0
1  2  7  0
2  3  7  0

>>> df.loc[:, (df != df.iloc[0]).any()] 

   0  1
0  1  9
1  2  7
2  3  7
```
+1 vielen Dank für die änderung. Diese Kurzschlüsse auf der jeder, nachdem er das schon getan != Vergleich auf jedem element, so dass die DSM-Lösung wird wahrscheinlich effizienter sein... Frage mich, ob besser durch einen Kurzschluss in der Lösung.
In meinen tests, meine Lösung ist immer schneller als das zählen der einzigartige Elemente, obwohl der Faktor variiert von 0,1 für eine 10×10 DataFrame bei etwa 0,5 für 10000×10. Ich denke, dass der Speicher, den Sie speichern, indem nicht die Berechnung der vollen Gleichstellung array trades Sie sich gegen die extra-Zeit beteiligt zählen alle eindeutigen Werte (und Erhaltung einer Tabelle von Werten schon gesehen und so weiter).
Guter Punkt, nehmen Sie wieder die effizienter! Frage mich immer noch, wenn der Weg zu einem Kurzschluss der != nach der erste Unterschied, der es sieht.
Beachten Sie, dass eine Spalte mit NaN wird nicht als konstant. Dies ist technisch korrekt (weil NaN ≠ Nan), aber das ist wohl nicht das, was wir wollen (da es praktisch keine Differenz zwischen den einzelnen NaN).
Ich habe eine Spalte, die einen Zeitstempel und ich bekomme TypeError: int() argument must be a string, a bytes-like object or a number, not 'Timestamp' verstehe nicht, warum.

InformationsquelleAutor chthonicdaemon
18

Ignorieren NaNs, wie üblich, eine Spalte ist konstant, wenn nunique() == 1. Also:
```
>>> df
   A  B  row
0  9  0    1
1  7  0    2
2  5  0    3
3  2  0    4
>>> df = df.loc[:,df.apply(pd.Series.nunique) != 1]
>>> df
   A  row
0  9    1
1  7    2
2  5    3
3  2    4
```
df.apply(pd.Series.nunique) ist mehr einfach df.nunique() im Pandas-0.20.3 zumindest.
Und wenn wir wollen, dass NaN als ein eindeutiger Wert, der df.nunique(dropna=False) gut funktioniert (es behandelt die Tatsache, dass NaN ≠ NaN, wie wir erwarten, zählen alle NaN-Werte als den gleichen Wert, obwohl Sie nicht gleich sind).

InformationsquelleAutor DSM

Unter der Annahme, dass der DataFrame ist vollständig der Typ numeric:

können Sie versuchen:

>>> df = df.loc[:, df.var() == 0.0]

die entfernt die Konstante(d.h. Varianz = 0) - Spalten.

Wenn das DataFrame ist der Typ sowohl numerische und Objekt, dann sollten Sie versuchen:

>>> enum_df = df.select_dtypes(include=['object'])
>>> num_df = df.select_dtypes(exclude=['object'])
>>> num_df = num_df.loc[:, num_df.var() == 0.0]
>>> df = pd.concat([num_df, enum_df], axis=1)

die drop-Konstante Spalten, die einen numerischen Typ nur.

Wenn Sie wollen auch zu ignorieren/löschen, Konstante enum-Spalten, die Sie versuchen sollten:

>>> enum_df = df.select_dtypes(include=['object'])
>>> num_df = df.select_dtypes(exclude=['object'])
>>> enum_df = enum_df.loc[:, [True if y !=1 else False for y in [len(np.unique(x, return_counts=True)[-1]) for x in enum_df.T.as_matrix()]]]
>>> num_df = num_df.loc[:, num_df.var() == 0.0]
>>> df = pd.concat([num_df, enum_df], axis=1)

Vermutlich würden Sie wollen df = df.loc[:, ~df.var() == 0.0] andernfalls wählen Sie die 0-Spalten. Es ist vermutlich auch für Sie lohnt np.isclose(0, df.var()) für möglich, floating-point-Fehler

InformationsquelleAutor Hng

Ich im Vergleich der verschiedenen Methoden auf Daten-frame der Größe 120*10000. Und fand die effizient ist

def drop_constant_column(dataframe):
    """
    Drops constant value columns of pandas dataframe.
    """
    return dataframe.loc[:, (dataframe != dataframe.iloc[0]).any()]

1-Schleife, best-of-3: 237 ms pro Schleife

Die anderen Anwärter sind

def drop_constant_columns(dataframe):
    """
    Drops constant value columns of pandas dataframe.
    """
    result = dataframe.copy()
    for column in dataframe.columns:
        if len(dataframe[column].unique()) == 1:
            result = result.drop(column,axis=1)
    return result

1-Schleife, best-of-3: 19.2 s pro loop

def drop_constant_columns_2(dataframe):
    """
    Drops constant value columns of pandas dataframe.
    """
    for column in dataframe.columns:
        if len(dataframe[column].unique()) == 1:
            dataframe.drop(column,inplace=True,axis=1)
    return dataframe

1-Schleife, best-of-3: 317 ms pro Schleife

def drop_constant_columns_3(dataframe):
    """
    Drops constant value columns of pandas dataframe.
    """
    keep_columns = [col for col in dataframe.columns if len(dataframe[col].unique()) > 1]
    return dataframe[keep_columns].copy()

1-Schleife, best-of-3: 358 ms pro Schleife

def drop_constant_columns_4(dataframe):
    """
    Drops constant value columns of pandas dataframe.
    """
    keep_columns = dataframe.columns[dataframe.nunique()>1]
    return dataframe.loc[:,keep_columns].copy()

1-Schleife, best-of-3: 1,8 s pro loop

InformationsquelleAutor Yantraguru

Hier ist meine Lösung, denn ich brauchte beides, Objekt und numerischen Spalten. Nicht fordern, seine super-effizient oder nichts, aber es bekommt den job getan.

def drop_constants(df):
    """iterate through columns and remove columns with constant values (all same)"""
    columns = df.columns.values
    for col in columns:
        # drop col if unique values is 1
        if df[col].nunique(dropna=False) == 1:
            del df[col]
    return df

Zusätzliche Einschränkung, es funktioniert nicht auf Spalten von Listen oder arrays, da Sie nicht hashable.

InformationsquelleAutor dreyco676

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.