Estou tentando obter o número de linhas do dataframe df com o Pandas, e aqui está o meu código.

Método 1:

total_rows = df.count
print total_rows +1

Método 2:

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

Ambos os trechos de código me dão este erro:

TypeError: tipo (s) de operando não suportado para +: 'instancemethod' e 'int'

O que estou fazendo errado?

Você pode usar a .shapepropriedade ou apenas len(DataFrame.index). No entanto, existem diferenças notáveis ​​de desempenho ( len(DataFrame.index)é mais rápido):

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: Como @Dan Allen observou nos comentários len(df.index)e df[0].count()não é intercambiável, pois countexclui NaNs,

Suponha que dfseu dataframe seja:

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

Ou, mais sucintamente,

r, c = df.shape

Use len(df). Isso funciona a partir dos pandas 0.11 ou talvez até mais cedo.

__len__()está atualmente (0,12) documentado com Returns length of index. Informações de tempo, configuradas da mesma maneira que na resposta raiz:

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

Devido a uma chamada de função adicional, é um pouco mais lenta que a chamada len(df.index)direta, mas isso não deve desempenhar nenhum papel na maioria dos casos de uso.

Como obtenho a contagem de linhas de um DataFrame do pandas?

Esta tabela resume as diferentes situações nas quais você deseja contar algo em um DataFrame (ou em série, para completar), juntamente com o (s) método (s) recomendado (s).

Notas de rodapé

1. DataFrame.countretorna contagens para cada coluna como a Seriesdesde que a contagem não nula varia de acordo com a coluna.
2. DataFrameGroupBy.sizeretorna a Series, pois todas as colunas do mesmo grupo compartilham a mesma contagem de linhas.
3. DataFrameGroupBy.countretorna a DataFrame, pois a contagem não nula pode diferir nas colunas do mesmo grupo. Para obter a contagem não nula em grupo para uma coluna específica, use df.groupby(...)['x'].count()onde "x" é a coluna a ser contada.

Exemplos de código mínimo

Abaixo, mostro exemplos de cada um dos métodos descritos na tabela acima. Primeiro, a configuração -

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

Conde linha de uma trama de dados: len(df), df.shape[0]oulen(df.index)

len(df)
# 5

df.shape[0]
# 5

len(df.index)
# 5

Parece tolice comparar o desempenho de operações de tempo constante, especialmente quando a diferença está no nível de "sério, não se preocupe com isso". Mas essa parece ser uma tendência com outras respostas, por isso estou fazendo o mesmo por completude.

Dos três métodos acima, len(df.index)(como mencionado em outras respostas), é o mais rápido.

Nota

• Todos os métodos acima são operações de tempo constante, pois são simples pesquisas de atributo.
• df.shape(similar a ndarray.shape) é um atributo que retorna uma tupla de (# Rows, # Cols). Por exemplo, df.shaperetorna (8, 2)para o exemplo aqui.

Coluna Contagem de uma trama de dados: df.shape[1],len(df.columns)

df.shape[1]
# 2

len(df.columns)
# 2

Análogo a len(df.index), len(df.columns)é o mais rápido dos dois métodos (mas leva mais caracteres para digitar).

Contagem de linhas de uma série: len(s), s.size,len(s.index)

len(s)
# 5

s.size
# 5

len(s.index)
# 5

s.sizee len(s.index)são praticamente os mesmos em termos de velocidade. Mas eu recomendo len(df).

Note
size é um atributo e retorna o número de elementos (= contagem de linhas para qualquer série). Os DataFrames também definem um atributo de tamanho que retorna o mesmo resultado que df.shape[0] * df.shape[1].

Contagem de linhas não nulas: DataFrame.counteSeries.count

Os métodos descritos aqui contam apenas valores não nulos (significando que os NaNs são ignorados).

A chamada DataFrame.countretornará contagens não-NaN para cada coluna:

df.count()

A    5
B    3
dtype: int64

Para Série, use Series.countpara efeito semelhante:

s.count()
# 3

Contagem de linhas em grupo: GroupBy.size

Para DataFrames, use DataFrameGroupBy.sizepara contar o número de linhas por grupo.

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

A
a    2
b    2
c    1
dtype: int64

Da mesma forma, para Series, você usará SeriesGroupBy.size.

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

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

Nos dois casos, a Seriesé retornado. Isso faz sentido paraDataFrames , pois todos os grupos compartilham a mesma contagem de linhas.

Contagem de linhas não nulas em grupo: GroupBy.count

Semelhante ao anterior, mas use GroupBy.count, não GroupBy.size. Observe que sizesempre retorna a Series, while countretorna a Seriesse chamado em uma coluna específica, ou então a DataFrame.

Os seguintes métodos retornam a mesma coisa:

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

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

Enquanto isso, counttemos

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

   B
A   
a  2
b  1
c  0

... chamou o objeto GroupBy inteiro, v / s,

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

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

Chamado em uma coluna específica.

TL; DR

usar len(df)

len()é seu amigo, ele pode ser usado para contagens de linhas como len(df).

Como alternativa, você pode acessar todas as linhas por df.indexe todas as colunas por df.columnse, como você pode usar len(anyList)para obter a contagem da lista, use len(df.index)para obter o número de linhas elen(df.columns) para a contagem de colunas.

Ou, você pode usar df.shapeque retorna o número de linhas e colunas em conjunto, se você deseja acessar o número de linhas só usam df.shape[0]e para o número de colunas só usar: df.shape[1].

Além das respostas acima, use pode usar df.axespara obter a tupla com índices de linha e coluna e, em seguida, usar a len()função:

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

... baseado na resposta de Jan-Philip Gehrcke.

A razão pela qual len(df)ou len(df.index)é mais rápido que df.shape[0]. Veja o código. df.shape é @propertyaquele que executa um método DataFrame chamando lenduas vezes.

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 sob o capô de 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)será um pouco mais rápido do que len(df)uma vez que tem uma chamada de função a menos, mas isso é sempre mais rápido quedf.shape[0]

Chego aos pandas de Rfundo e vejo que os pandas são mais complicados quando se trata de selecionar linha ou coluna. Eu tive que lutar com isso por um tempo, depois encontrei algumas maneiras de lidar com:

obtendo o número de colunas:

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.

obtendo o número de linhas:

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

Caso deseje obter a contagem de linhas no meio de uma operação encadeada, você pode usar:

df.pipe(len)

Exemplo:

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

Isso pode ser útil se você não quiser colocar uma declaração longa dentro de um len() função.

Você poderia usar, __len__()mas __len__()parece um pouco estranho.

Ei, você pode usar faça isso também:

Digamos que dfseja seu quadro de dados. Em seguida, df.shapefornece a forma do seu quadro de dados, ou seja,(row,col)

Portanto, atribua o comando abaixo para obter as informações necessárias

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

Para dataframe df, uma contagem de linhas no formato de vírgula impressa usada ao explorar dados:

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

Exemplo:

nrow(my_df)
12,456,789

Um método alternativo para descobrir a quantidade de linhas em um dataframe que eu acho que é a variante mais legível pandas.Index.size.

Observe que, como eu comentei a resposta aceita:

Suspeita pandas.Index.sizeseria realmente mais rápido do que, len(df.index)mas timeitno meu computador me diz o contrário (~ 150 ns mais lento por loop).

Não tenho certeza se isso funcionaria (os dados poderiam ser omitidos), mas isso pode funcionar:

*dataframe name*.tails(1)

e, usando isso, você pode encontrar o número de linhas executando o snippet de código e observando o número da linha que foi fornecido a você.

Isso pode ser feito ( dfé o nome do DataFrame):

Método 1: Usando a lenfunção:

len(df)fornecerá o número de linhas em um DataFrame chamado df.

Método 2: usando a countfunção:

df[col].count() contará o número de linhas em uma determinada coluna col .

df.count() dará o número de linhas para todas as colunas.