Sto cercando di ottenere il numero di righe di dataframe df con Panda, ed ecco il mio codice.

Metodo 1:

total_rows = df.count
print total_rows +1

Metodo 2:

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

Entrambi gli snippet di codice mi danno questo errore:

TypeError: tipi di operando non supportati per +: 'instancemethod' e 'int'

Che cosa sto facendo di sbagliato?

È possibile utilizzare la .shapeproprietà o semplicemente len(DataFrame.index). Tuttavia, ci sono notevoli differenze di prestazioni ( len(DataFrame.index)è la più veloce):

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: come ha notato @Dan Allen nei commenti len(df.index)e df[0].count()non sono intercambiabili come countesclude NaNs,

Supponiamo che dfsia il tuo frame di dati quindi:

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

O, più succintamente,

r, c = df.shape

Usa len(df). Funziona a partire da Panda 0.11 o forse anche prima.

__len__()è attualmente (0.12) documentato con Returns length of index. Informazioni sul tempo, impostate come nella risposta di root:

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

A causa di una chiamata di funzione aggiuntiva, è un po 'più lento rispetto alla chiamata len(df.index)diretta, ma ciò non dovrebbe svolgere alcun ruolo nella maggior parte dei casi d'uso.

Come posso ottenere il conteggio delle righe di un DataFrame Panda?

Questa tabella riassume le diverse situazioni in cui vorresti contare qualcosa in un DataFrame (o Serie, per completezza), insieme ai metodi consigliati.

Le note

1. DataFrame.countrestituisce i conteggi per ogni colonna come a Seriespoiché il conteggio non nullo varia in base alla colonna.
2. DataFrameGroupBy.sizerestituisce a Series, poiché tutte le colonne dello stesso gruppo condividono lo stesso conteggio di righe.
3. DataFrameGroupBy.countrestituisce a DataFrame, poiché il conteggio non nullo potrebbe differire tra le colonne dello stesso gruppo. Per ottenere il conteggio non nullo a livello di gruppo per una colonna specifica, utilizzare df.groupby(...)['x'].count()dove "x" è la colonna da contare.

Esempi di codice minimo

Di seguito, mostro esempi di ciascuno dei metodi descritti nella tabella sopra. Innanzitutto, l'installazione -

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

Conteggio righe di un dataframe: len(df), df.shape[0], olen(df.index)

len(df)
# 5

df.shape[0]
# 5

len(df.index)
# 5

Sembra sciocco confrontare le prestazioni delle operazioni a tempo costante, specialmente quando la differenza è sul livello di "seriamente, non preoccuparti". Ma questa sembra essere una tendenza con altre risposte, quindi sto facendo lo stesso per completezza.

Dei 3 metodi sopra, len(df.index)(come menzionato in altre risposte) è il più veloce.

Nota

• Tutti i metodi sopra indicati sono operazioni a tempo costante in quanto sono semplici ricerche di attributi.
• df.shape(simile a ndarray.shape) è un attributo che restituisce una tupla di (# Rows, # Cols). Ad esempio, df.shaperitorna (8, 2)per l'esempio qui.

Conte Colonna di un dataframe: df.shape[1],len(df.columns)

df.shape[1]
# 2

len(df.columns)
# 2

Analogamente a len(df.index), len(df.columns)è il più veloce dei due metodi (ma richiede più caratteri per digitare).

Numero di righe di una Serie: len(s), s.size,len(s.index)

len(s)
# 5

s.size
# 5

len(s.index)
# 5

s.sizee len(s.index)sono più o meno gli stessi in termini di velocità. Ma io consiglio len(df).

Nota
size è un attributo e restituisce il numero di elementi (= conteggio delle righe per qualsiasi serie). DataFrames definisce anche un attributo size che restituisce lo stesso risultato di df.shape[0] * df.shape[1].

Conteggio righe non null: DataFrame.counteSeries.count

I metodi qui descritti contano solo valori non nulli (il che significa che i NaN vengono ignorati).

La chiamata DataFrame.countrestituirà conteggi non NaN per ogni colonna:

df.count()

A    5
B    3
dtype: int64

Per le serie, utilizzare Series.countcon effetti simili:

s.count()
# 3

Conteggio righe di gruppo: GroupBy.size

Per DataFrames, usare DataFrameGroupBy.sizeper contare il numero di righe per gruppo.

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

A
a    2
b    2
c    1
dtype: int64

Allo stesso modo, per Series, userete SeriesGroupBy.size.

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

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

In entrambi i casi, Seriesviene restituito a. Questo ha senso DataFramesanche perché tutti i gruppi condividono lo stesso numero di righe.

Conteggio delle righe non nulle del gruppo: GroupBy.count

Simile a sopra, ma usare GroupBy.count, non GroupBy.size. Nota che sizerestituisce sempre a Series, mentre countrestituisce a Seriesse chiamato su una colonna specifica, oppure a DataFrame.

I seguenti metodi restituiscono la stessa cosa:

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

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

Nel frattempo, per count, abbiamo

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

   B
A   
a  2
b  1
c  0

... chiamato sull'intero oggetto GroupBy, v / s,

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

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

Chiamato su una colonna specifica.

TL; DR

uso len(df)

len()è tuo amico, può essere utilizzato per i conteggi delle righe come len(df).

In alternativa, è possibile accedere a tutte le righe per df.indexe tutte le colonne per df.columnse poiché è possibile utilizzare len(anyList)per ottenere il conteggio dell'elenco, utilizzare len(df.index)per ottenere il numero di righe e len(df.columns)per il conteggio delle colonne.

In alternativa, è possibile utilizzare df.shapeche restituisce il numero di righe e colonne insieme, se si desidera accedere al numero di righe solo uso df.shape[0]e per il numero di colonne utilizzare solo: df.shape[1].

Oltre alle risposte precedenti, usare può usare df.axesper ottenere la tupla con indici di riga e colonna e quindi usare la len()funzione:

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

... basandosi sulla risposta di Jan-Philip Gehrcke.

Il motivo per cui len(df)o len(df.index)è più veloce di df.shape[0]. Guarda il codice. df.shape è un file @propertyche esegue un metodo DataFrame che chiama lendue volte.

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)

E sotto il cappuccio di 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)sarà leggermente più veloce rispetto a len(df)quando ha una chiamata di funzione in meno, ma questo è sempre più veloce didf.shape[0]

Vengo ai panda dallo Rsfondo e vedo che i panda sono più complicati quando si tratta di selezionare una riga o una colonna. Ho dovuto lottare per un po ', poi ho trovato alcuni modi per affrontare:

ottenere il numero di colonne:

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.

ottenere il numero di righe:

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

Nel caso in cui si desideri ottenere il conteggio delle righe nel mezzo di un'operazione concatenata, è possibile utilizzare:

df.pipe(len)

Esempio:

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

Questo può essere utile se non vuoi inserire una lunga dichiarazione all'interno di una len()funzione.

__len__()Invece potresti usare ma __len__()sembra un po 'strano.

Ehi, puoi usare anche questo:

Supponiamo che dfsia il tuo frame di dati. Quindi df.shapeti dà la forma del tuo frame di dati, ad es(row,col)

Quindi, assegnare il comando seguente per ottenere il necessario

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

Per dataframe df, un conteggio di righe in formato virgola stampato utilizzato durante l'esplorazione dei dati:

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

Esempio:

nrow(my_df)
12,456,789

Un metodo alternativo per scoprire la quantità di righe in un frame di dati che penso sia la variante più leggibile è pandas.Index.size.

Si noti che come ho commentato la risposta accettata:

Sospettato pandas.Index.sizesarebbe effettivamente più veloce di len(df.index)ma timeitsul mio computer mi dice diversamente (~ 150 ns più lento per ciclo).

Non sono sicuro che funzionerebbe (i dati POTREBBERO essere omessi), ma potrebbe funzionare:

*dataframe name*.tails(1)

e quindi usando questo, puoi trovare il numero di righe eseguendo lo snippet di codice e guardando il numero di riga che ti è stato dato.

Ognuno di questi può fare ( dfè il nome del DataFrame):

Metodo 1: utilizzando la lenfunzione:

len(df)fornirà il numero di righe in un DataFrame denominato df.

Metodo 2: utilizzando la countfunzione:

df[col].count()conterà il numero di righe in una determinata colonna col.

df.count() fornirà il numero di righe per tutte le colonne.