Wie überprüft man, ob ein Pandas DataFrame leer ist?

Question

Wie überprüft man, ob ein pandas DataFrame leer ist? In meinem Fall möchte ich eine Nachricht in der Konsole ausgeben, wenn der DataFrame leer ist.

Answer 1

Sie können das Attribut df.empty verwenden, um zu überprüfen, ob es leer ist oder nicht:

if df.empty:
    print('DataFrame ist leer!')

Quelle: Pandas-Dokumentation

Answer 2

Ich benutze die len Funktion. Sie ist viel schneller als empty. len(df.index) ist noch schneller.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10000, 4), columns=list('ABCD'))

def empty(df):
    return df.empty

def lenz(df):
    return len(df) == 0

def lenzi(df):
    return len(df.index) == 0

'''
%timeit empty(df)
%timeit lenz(df)
%timeit lenzi(df)

10000 loops, best of 3: 13.9 µs per loop
100000 loops, best of 3: 2.34 µs per loop
1000000 loops, best of 3: 695 ns per loop

len on index seems to be faster
'''

Answer 3

Um zu sehen, ob ein DataFrame leer ist, argumentiere ich, dass man die Länge des Spaltenindexes eines DataFrames überprüfen sollte:

if len(df.columns) == 0: 1

Grund:

Laut der Pandas Reference API gibt es einen Unterschied zwischen:

• einem leeren DataFrame mit 0 Zeilen und 0 Spalten
• einem leeren DataFrame mit Zeilen, die NaN enthalten, also mindestens 1 Spalte

Argumentativ sind sie nicht dasselbe. Die anderen Antworten sind ungenau, weil df.empty, len(df) oder len(df.index) keinen Unterschied machen und in beiden Fällen Index ist 0 und leer ist True zurückgeben.

Beispiele

Beispiel 1: Ein leeres DataFrame mit 0 Zeilen und 0 Spalten

In [1]: import pandas as pd
        df1 = pd.DataFrame()
        df1
Out[1]: Empty DataFrame
        Columns: []
        Index: []

In [2]: len(df1.index)  # oder len(df1)
Out[2]: 0

In [3]: df1.empty
Out[3]: True

Beispiel 2: Ein DataFrame, das auf 0 Zeilen geleert wird, aber immer noch n Spalten behält

In [4]: df2 = pd.DataFrame({'AA' : [1, 2, 3], 'BB' : [11, 22, 33]})
        df2
Out[4]:    AA  BB
        0   1  11
        1   2  22
        2   3  33

In [5]: df2 = df2[df2['AA'] == 5]
        df2
Out[5]: Empty DataFrame
        Columns: [AA, BB]
        Index: []

In [6]: len(df2.index)  # oder len(df2)
Out[6]: 0

In [7]: df2.empty
Out[7]: True

Nun, aufbauend auf den vorherigen Beispielen, in denen der Index 0 und leer True ist. Beim Lesen der Länge des Spaltenindexes für das erste geladene DataFrame df1 wird zurückgegeben, dass es 0 Spalten hat, um zu beweisen, dass es in der Tat leer ist.

In [8]: len(df1.columns)
Out[8]: 0

In [9]: len(df2.columns)
Out[9]: 2

Kritisch, während das zweite DataFrame df2 keine Daten enthält, ist es nicht komplett leer, weil es die Anzahl der leeren Spalten zurückgibt, die fortbestehen.

Warum es wichtig ist

Fügen wir diesen DataFrames eine neue Spalte hinzu, um die Auswirkungen zu verstehen:

# Wie erwartet zeigt die leere Spalte 1 Serie an
In [10]: df1['CC'] = [111, 222, 333]
         df1
Out[10]:    CC
         0 111
         1 222
         2 333
In [11]: len(df1.columns)
Out[11]: 1

# Beachten Sie die fortbestehende Serie mit Zeilen, die `NaN`-Werte in df2 enthalten
In [12]: df2['CC'] = [111, 222, 333]
         df2
Out[12]:    AA  BB   CC
         0 NaN NaN  111
         1 NaN NaN  222
         2 NaN NaN  333
In [13]: len(df2.columns)
Out[13]: 3

Es ist offensichtlich, dass die Originalspalten in df2 wieder aufgetaucht sind. Daher ist es ratsam, stattdessen die Länge des Spaltenindexes mit len(pandas.core.frame.DataFrame.columns) zu lesen, um zu sehen, ob ein DataFrame leer ist.

Praktische Lösung

# Neuer DataFrame df
In [1]: df = pd.DataFrame({'AA' : [1, 2, 3], 'BB' : [11, 22, 33]})
        df
Out[1]:    AA  BB
        0   1  11
        1   2  22
        2   3  33

# Diese Datenmanipulationsmethode führt zu einem leeren df
# aufgrund einer Teilmenge von Werten, die nicht verfügbar sind (`NaN`)
In [2]: df = df[df['AA'] == 5]
        df
Out[2]: Empty DataFrame
        Columns: [AA, BB]
        Index: []

# HINWEIS: das df ist leer, ABER die Spalten sind persistent
In [3]: len(df.columns)
Out[3]: 2

# Und entsprechend die anderen Antworten auf dieser Seite
In [4]: len(df.index)  # oder len(df)
Out[4]: 0

In [5]: df.empty
Out[5]: True

# LÖSUNG: Bedingte Überprüfung auf leere Spalten
In [6]: if len(df.columns) != 0:  # <--- hier
            # Mach etwas, z.B. 
            # lösche alle Spalten, die Zeilen mit `NaN` enthalten, 
            # um das df wirklich leer zu machen
            df = df.dropna(how='all', axis=1)
        df
Out[6]: Empty DataFrame
        Columns: []
        Index: []

# Tests zeigen, dass es jetzt tatsächlich leer ist
In [7]: len(df.columns)
Out[7]: 0

Das Hinzufügen einer neuen Datenreihe funktioniert wie erwartet ohne das Wiederauftauchen von leeren Spalten (tatsächlich ohne irgendwelche Serien, die Zeilen enthielten, die nur NaN enthielten):

In [8]: df['CC'] = [111, 222, 333]
         df
Out[8]:    CC
         0 111
         1 222
         2 333
In [9]: len(df.columns)
Out[9]: 1

Answer 4

Ich ziehe es vor, den langen Weg zu gehen. Dies sind die Überprüfungen, die ich befolge, um zu vermeiden, eine try-except-Klausel zu verwenden -

1. Überprüfen, ob die Variable nicht None ist
2. dann überprüfen, ob es sich um ein DataFrame handelt und
3. Stellen Sie sicher, dass es nicht leer ist

Hier ist die verdächtige Variable DATA -

DATA ist nicht None und isinstance(DATA, pd.DataFrame) und nicht DATA.empty

Answer 5

1. Wenn ein DataFrame NaN- und Nicht-Null-Werte enthält und Sie herausfinden möchten, ob der DataFrame leer ist oder nicht, versuchen Sie es mit diesem Code.

2. Wann kann diese Situation eintreten? Diese Situation tritt auf, wenn eine einzelne Funktion verwendet wird, um mehr als einen DataFrame zu plotten, die als Parameter übergeben werden. In einer solchen Situation versucht die Funktion, die Daten zu plotten, selbst wenn ein DataFrame leer ist, und plot eine leere Abbildung! Es würde Sinn machen, einfach die Nachricht 'DataFrame hat keine Daten' anzuzeigen.

3. Warum? Wenn ein DataFrame leer ist (d.h. überhaupt keine Daten enthält. Beachten Sie, dass ein DataFrame mit NaN-Werten als nicht leer betrachtet wird), dann ist es wünschenswert, nicht zu plotten, sondern eine Nachricht auszugeben: Angenommen, wir haben zwei DataFrames df1 und df2. Die Funktion myfunc nimmt jeden DataFrame (df1 und df2 in diesem Fall) und gibt eine Nachricht aus, wenn ein DataFrame leer ist (anstatt zu plotten):

   df1                     df2
   col1 col2           col1 col2 
   Nan   2              Nan  Nan 
   2     Nan            Nan  Nan  

und die Funktion:

def myfunc(df):
  if (df.count().sum()) > 0: ## zähle die Gesamtanzahl der Nicht-NaN-Werte. Gleich 0, wenn der DataFrame leer ist
     print('nicht leer')
     df.plot(kind='barh')
  else:
     Zeigen Sie eine Nachricht anstelle des Plottens an, wenn er leer ist
     print('leer')