Ich versuche mit Pandas die Anzahl der Zeilen des Datenrahmens df zu ermitteln, und hier ist mein Code.

Methode 1:

total_rows = df.count
print total_rows +1

Methode 2:

total_rows = df['First_columnn_label'].count
print total_rows +1

Beide Codefragmente geben mir diesen Fehler:

TypeError: Nicht unterstützte Operandentypen für +: 'instancemethod' und 'int'

Was mache ich falsch?

Sie können die .shapeEigenschaft oder nur verwenden len(DataFrame.index). Es gibt jedoch bemerkenswerte Leistungsunterschiede ( len(DataFrame.index)ist am schnellsten):

In [1]: import numpy as np

In [2]: import pandas as pd

In [3]: df = pd.DataFrame(np.arange(12).reshape(4,3))

In [4]: df
Out[4]: 
   0  1  2
0  0  1  2
1  3  4  5
2  6  7  8
3  9  10 11

In [5]: df.shape
Out[5]: (4, 3)

In [6]: timeit df.shape
2.77 µs ± 644 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [7]: timeit df[0].count()
348 µs ± 1.31 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [8]: len(df.index)
Out[8]: 4

In [9]: timeit len(df.index)
990 ns ± 4.97 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

EDIT: Wie @ Dan Allen bemerkt in den Kommentaren len(df.index)und df[0].count()sind nicht austauschbar wie countausschließt NaNs,

Angenommen, dfIhr Datenrahmen ist dann:

count_row = df.shape[0]  # gives number of row count
count_col = df.shape[1]  # gives number of col count

Oder prägnanter:

r, c = df.shape

Verwenden Sie len(df). Dies funktioniert ab Pandas 0.11 oder vielleicht sogar früher.

__len__()ist derzeit (0.12) dokumentiert mit Returns length of index. Timing-Informationen, richten Sie sie wie in der Antwort von root ein:

In [7]: timeit len(df.index)
1000000 loops, best of 3: 248 ns per loop

In [8]: timeit len(df)
1000000 loops, best of 3: 573 ns per loop

Aufgrund eines zusätzlichen Funktionsaufrufs ist es etwas langsamer als der len(df.index)direkte Aufruf , dies sollte jedoch in den meisten Anwendungsfällen keine Rolle spielen.

Wie erhalte ich die Zeilenanzahl eines Pandas DataFrame?

Diese Tabelle fasst die verschiedenen Situationen zusammen, in denen Sie der Vollständigkeit halber etwas in einem DataFrame (oder einer Serie) zählen möchten, sowie die empfohlenen Methoden.

Fußnoten

1. DataFrame.countSeriesGibt die Anzahl für jede Spalte als zurück, da die Anzahl ungleich Null je nach Spalte variiert.
2. DataFrameGroupBy.sizeGibt a zurück Series, da alle Spalten in derselben Gruppe dieselbe Zeilenanzahl haben.
3. DataFrameGroupBy.countGibt a zurück DataFrame, da die Anzahl der Nicht-Nullen in den Spalten derselben Gruppe unterschiedlich sein kann. Verwenden Sie df.groupby(...)['x'].count()"x" als zu zählende Spalte, um die gruppenweise Nicht-Null-Zählung für eine bestimmte Spalte zu erhalten.

Beispiele für minimale Codes

Im Folgenden zeige ich Beispiele für jede der in der obigen Tabelle beschriebenen Methoden. Zunächst das Setup -

df = pd.DataFrame({
    'A': list('aabbc'), 'B': ['x', 'x', np.nan, 'x', np.nan]})
s = df['B'].copy()

df

   A    B
0  a    x
1  a    x
2  b  NaN
3  b    x
4  c  NaN

s

0      x
1      x
2    NaN
3      x
4    NaN
Name: B, dtype: object

Zeilenanzahl eines Datenrahmens: len(df), df.shape[0]oderlen(df.index)

len(df)
# 5

df.shape[0]
# 5

len(df.index)
# 5

Es erscheint unsinnig, die Leistung von Operationen mit konstanter Zeit zu vergleichen, insbesondere wenn der Unterschied auf der Ebene "Ernsthaft, mach dir keine Sorgen" liegt. Dies scheint jedoch ein Trend mit anderen Antworten zu sein, daher mache ich der Vollständigkeit halber dasselbe.

Von den 3 oben len(df.index)genannten Methoden ist (wie in anderen Antworten erwähnt) die schnellste.

Hinweis

• Alle oben genannten Methoden sind Operationen mit konstanter Zeit, da es sich um einfache Attributsuchen handelt.
• df.shape(ähnlich wie ndarray.shape) ist ein Attribut, das ein Tupel von zurückgibt (# Rows, # Cols). Zum Beispiel df.shapegibt (8, 2)für das Beispiel hier.

Spaltenanzahl eines Datenrahmen: df.shape[1],len(df.columns)

df.shape[1]
# 2

len(df.columns)
# 2

Analog zu len(df.index), len(df.columns)ist die schnellere der beiden Methoden (aber braucht mehr Zeichen - Typ).

Zeilenanzahl einer Serie: len(s), s.size,len(s.index)

len(s)
# 5

s.size
# 5

len(s.index)
# 5

s.sizeund len(s.index)sind in Bezug auf die Geschwindigkeit ungefähr gleich. Aber ich empfehle len(df).

Note
size ist ein Attribut und gibt die Anzahl der Elemente zurück (= Anzahl der Zeilen für jede Serie). DataFrames definieren auch ein Größenattribut, das das gleiche Ergebnis wie zurückgibt df.shape[0] * df.shape[1].

Nicht-Null-Zeilenanzahl: DataFrame.countundSeries.count

Die hier beschriebenen Methoden zählen nur Nicht-Null-Werte (dh NaNs werden ignoriert).

Beim Aufrufen DataFrame.countwerden Nicht-NaN-Zählungen für jede Spalte zurückgegeben:

df.count()

A    5
B    3
dtype: int64

Verwenden Sie für Serien Series.counteinen ähnlichen Effekt:

s.count()
# 3

Gruppenweise Zeilenanzahl: GroupBy.size

DataFramesVerwenden Sie für , um DataFrameGroupBy.sizedie Anzahl der Zeilen pro Gruppe zu zählen.

df.groupby('A').size()

A
a    2
b    2
c    1
dtype: int64

Ebenso werden Sie für Seriesverwenden SeriesGroupBy.size.

s.groupby(df.A).size()

A
a    2
b    2
c    1
Name: B, dtype: int64

In beiden Fällen wird a Serieszurückgegeben. Das macht Sinn fürDataFrames da alle Gruppen die gleiche Zeilenanzahl haben.

Gruppenweise Nicht-Null-Zeilenanzahl: GroupBy.count

Ähnlich wie oben, aber GroupBy.countnicht verwenden GroupBy.size. Beachten Sie, dass sizeimmer a zurückgegeben wird Series, während counta zurückgegeben wird, Serieswenn es für eine bestimmte Spalte aufgerufen wird, oder a DataFrame.

Die folgenden Methoden geben dasselbe zurück:

df.groupby('A')['B'].size()
df.groupby('A').size()

A
a    2
b    2
c    1
Name: B, dtype: int64

Inzwischen counthaben wir

df.groupby('A').count()

   B
A   
a  2
b  1
c  0

... das gesamte GroupBy-Objekt aufgerufen, v / s,

df.groupby('A')['B'].count()

A
a    2
b    1
c    0
Name: B, dtype: int64

Wird in einer bestimmten Spalte aufgerufen.

TL; DR

verwenden len(df)

len()ist dein Freund, kann es für Zeilenzählungen als verwendet werden len(df).

Alternativ können Sie auf alle Zeilen nach df.indexund alle Spalten nach zugreifen df.columnsund, da Sie die len(anyList)zum Abrufen der Anzahl der Listen, len(df.index)zum Abrufen der Anzahl der Zeilen und len(df.columns)für die Anzahl der Spalten verwenden können.

Oder Sie können verwenden, df.shapewas die Anzahl der Zeilen und Spalten zusammen zurückgibt, wenn Sie auf die Anzahl der nur verwendeten Zeilen df.shape[0]und für die Anzahl der nur verwendeten Spalten zugreifen möchten : df.shape[1].

Abgesehen von den obigen Antworten kann use verwendet werden df.axes, um das Tupel mit Zeilen- und Spaltenindizes abzurufen und dann die len()Funktion zu verwenden:

total_rows=len(df.axes[0])
total_cols=len(df.axes[1])

... auf der Antwort von Jan-Philip Gehrcke aufbauen.

Der Grund warum len(df)oder len(df.index)ist schneller als df.shape[0]. Schauen Sie sich den Code an. df.shape ist eine @propertyMethode, die eine DataFrame-Methode ausführt, die lenzweimal aufgerufen wird .

df.shape??
Type:        property
String form: <property object at 0x1127b33c0>
Source:     
# df.shape.fget
@property
def shape(self):
    """
    Return a tuple representing the dimensionality of the DataFrame.
    """
    return len(self.index), len(self.columns)

Und unter der Haube von len (df)

df.__len__??
Signature: df.__len__()
Source:   
    def __len__(self):
        """Returns length of info axis, but here we use the index """
        return len(self.index)
File:      ~/miniconda2/lib/python2.7/site-packages/pandas/core/frame.py
Type:      instancemethod

len(df.index)wird etwas schneller sein als len(df)da es einen Funktionsaufruf weniger hat, aber dies ist immer schneller alsdf.shape[0]

Ich komme aus dem RHintergrund zu Pandas , und ich sehe, dass Pandas komplizierter sind, wenn es um die Auswahl von Zeilen oder Spalten geht. Ich musste eine Weile damit ringen, dann fand ich einige Möglichkeiten, damit umzugehen:

Abrufen der Anzahl der Spalten:

len(df.columns)  
## Here:
#df is your data.frame
#df.columns return a string, it contains column's titles of the df. 
#Then, "len()" gets the length of it.

Ermitteln der Anzahl der Zeilen:

len(df.index) #It's similar.

Wenn Sie die Zeilenanzahl in der Mitte einer verketteten Operation erhalten möchten, können Sie Folgendes verwenden:

df.pipe(len)

Beispiel:

row_count = (
      pd.DataFrame(np.random.rand(3,4))
      .reset_index()
      .pipe(len)
)

Dies kann nützlich sein, wenn Sie keine lange Anweisung in eine len()Funktion einfügen möchten .

Sie könnten __len__()stattdessen verwenden, __len__()sieht aber ein bisschen komisch aus.

Hey du kannst das auch machen:

dfAngenommen , es ist Ihr Datenrahmen. Dann df.shapegibt Ihnen die Form Ihres Datenrahmens dh(row,col)

Weisen Sie daher den folgenden Befehl zu, um den erforderlichen Befehl zu erhalten

 row = df.shape[0], col = df.shape[1]

Für dataframe df eine gedruckte, durch Kommas formatierte Zeilenanzahl, die beim Erkunden von Daten verwendet wird:

def nrow(df):
    print("{:,}".format(df.shape[0]))

Beispiel:

nrow(my_df)
12,456,789

Eine alternative Methode, um die Anzahl der Zeilen in einem Datenrahmen herauszufinden, die meiner Meinung nach die am besten lesbare Variante ist, ist pandas.Index.size.

Beachten Sie Folgendes, als ich die akzeptierte Antwort kommentierte:

Der Verdacht pandas.Index.sizewäre tatsächlich schneller als len(df.index)aber timeitauf meinem Computer sagt mir etwas anderes (~ 150 ns langsamer pro Schleife).

Ich bin nicht sicher, ob dies funktionieren würde (Daten könnten weggelassen werden), aber dies könnte funktionieren:

*dataframe name*.tails(1)

Wenn Sie dies verwenden, können Sie die Anzahl der Zeilen ermitteln, indem Sie das Code-Snippet ausführen und die Zeilennummer anzeigen, die Sie erhalten haben.

dfBeides kann ( ist der Name des DataFrame):

Methode 1: Verwenden der lenFunktion:

len(df)gibt die Anzahl der Zeilen in einem DataFrame mit dem Namen an df.

Methode 2: Verwenden der countFunktion:

df[col].count()zählt die Anzahl der Zeilen in einer bestimmten Spalte col.

df.count() gibt die Anzahl der Zeilen für alle Spalten an.