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


935

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?


12
ok eu descobri, eu deveria ter chamado método não verificar a propriedade, por isso deve ser df.count () não df.count
Yemu

56
^ Perigoso! Cuidado que df.count()retornará apenas a contagem de linhas não NA / NaN para cada coluna. Você deve usar df.shape[0], que sempre informará corretamente o número de linhas.
SMCI

3
Note-se que df.count não irá retornar um int quando a trama de dados é vazio (. Por exemplo, pd.DataFrame (colunas = [ "azul", "Red") contagem não é 0)
Marcelo Bielsa

Respostas:


1253

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)

insira a descrição da imagem aqui

EDIT: Como @Dan Allen observou nos comentários len(df.index)e df[0].count()não é intercambiável, pois countexclui NaNs,


13
Há uma boa razão para usar shapeno trabalho interativo, em vez de len (df): Para experimentar filtros diferentes, muitas vezes preciso saber quantos itens restam. Com a forma, posso ver isso apenas adicionando .shape após minha filtragem. Com len (), a edição da linha de comando se torna muito mais complicada, indo e voltando.
K.-Michael Aye

9
Não funcionará no OP, mas se você precisar apenas saber se o dataframe está vazio, df.emptyé a melhor opção.
Jtschoonhoven

19
Sei que já faz um tempo, mas o len (df.index) leva 381 nanossegundos ou 0,381 microssegundo, df.shape é 3 vezes mais lento, levando 1,17 microssegundo. Perdi alguma coisa? @root
TG

11
(3,3) matriz é mau exemplo como ele não mostra a ordem da tupla forma
xaedes

4
Como é df.shape[0]mais rápido que len(df)ou len(df.columns)? Desde 1 ns (nanossegundos) = 1000 uS (microssegundo), portanto 1.17μs = 1170ns, o que significa que é cerca de 3 vezes mais lenta do que 381ns
itsjef

304

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

4
Se o conjunto de dados for grande, len (df.index) é significativamente mais rápido que df.shape [0] se você precisar apenas de contagem de linhas. Eu testei.
Sumit Pokhrel

145

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.


81

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).

insira a descrição da imagem aqui

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.


35

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].


19

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])

2
Isso retorna objetos de índice, que podem ou não ser cópias do original, que são um desperdício se você apenas os estiver descartando após verificar o comprimento. A menos que você pretenda fazer mais alguma coisa com o índice, NÃO USE .
cs95

9

... 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]


7

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.

Depois de usar o Pandas por um tempo, acho que devemos continuar df.shape. Retorna o número de linhas e colunas, respectivamente.
Catbuilts

4

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.


Parece inútil querer "canalizar" esta operação porque não há mais nada em que você possa canalizar (ele retorna um número inteiro). Eu prefiro muito mais count = len(df.reset_index())do que count = df.reset_index().pipe(len). O primeiro é apenas uma pesquisa de atributo sem a chamada de função.
cs95

1

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]

0

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

0

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).


0

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ê.


-2

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.


3
Essa é uma boa resposta, mas já existem respostas suficientes para essa pergunta, portanto, isso realmente não adiciona nada.
John
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.