python value Como faço para obter a contagem de linhas de um dataframe do Pandas?




python pandas change index name (9)

... baseando-se na resposta de Jan-Philip Gehrcke.

A razão pela qual len(df) ou len(df.index) é mais rápido que df.shape[0] . Olhe o código. df.shape é uma @property que executa um método DataFrame chamando len duas 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 abaixo do 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 que len(df) já que tem uma chamada de função a menos, mas isso é sempre mais rápido que df.shape[0]

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 operandos sem suporte para +: 'instancemethod' e 'int'

O que estou fazendo de errado?


df.shape retorna a forma do quadro de dados na forma de uma tupla (no. de linhas, no. de cols).

Você pode simplesmente acessar não. de linhas ou não. de cols com df.shape[0] ou df.shape[1] , respectivamente, que é o mesmo que acessar os valores da tupla.


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

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

Suponha que df seja seu dataframe então:

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

Caso você queira 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 instrução longa dentro de uma função len ().

Você poderia usar __len __ () em vez disso, mas __len __ () parece um pouco estranho.


Contagem de linhas (use qualquer uma delas):

df.shape[0]
len(df)

len() é seu amigo, resposta curta para contagens de linhas é len(df) .

Alternativamente, você pode acessar todas as linhas por df.index e todas as colunas por df.columns , e como você pode usar o len(anyList) para obter a contagem de lista, portanto você pode usar len(df.index) para obter o número de linhas e len(df.columns) para a contagem de colunas.

Alternativamente, você pode usar df.shape que retorna o número de linhas e colunas juntas, se você quiser acessar o número de linhas use somente df.shape[0] e para o número de colunas use somente: df.shape[1] .


Use len(df) . Isso funciona como de pandas 0.11 ou talvez até mais cedo.

__len__() é atualmente (0.12) documentado com Returns length of index . Informações de tempo, configuradas da mesma forma que na resposta do 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

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


Você pode usar a propriedade .shape ou apenas len(DataFrame.index) . No entanto, existem diferenças de desempenho notáveis ​​( 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 são intercambiáveis ​​como count exclui NaN s,





dataframe