Essa é a diferença entre groupby("x").count e groupby("x").sizenos pandas?

O tamanho exclui apenas nulo?

sizeinclui NaNvalores, countnão:

In [46]:
df = pd.DataFrame({'a':[0,0,1,2,2,2], 'b':[1,2,3,4,np.NaN,4], 'c':np.random.randn(6)})
df

Out[46]:
   a   b         c
0  0   1  1.067627
1  0   2  0.554691
2  1   3  0.458084
3  2   4  0.426635
4  2 NaN -2.238091
5  2   4  1.256943

In [48]:
print(df.groupby(['a'])['b'].count())
print(df.groupby(['a'])['b'].size())

a
0    2
1    1
2    2
Name: b, dtype: int64

a
0    2
1    1
2    3
dtype: int64 

Qual é a diferença entre size e count in pandas?

As outras respostas apontaram a diferença, no entanto, não é totalmente correto dizer " sizeconta NaNs enquanto countnão". Embora sizerealmente conte NaNs, isso é realmente uma consequência do fato de que sizeretorna o tamanho (ou o comprimento) do objeto no qual é chamado. Naturalmente, isso também inclui linhas / valores que são NaN.

Portanto, para resumir, sizeretorna o tamanho do Series / DataFrame ¹ ,

df = pd.DataFrame({'A': ['x', 'y', np.nan, 'z']})
df

     A
0    x
1    y
2  NaN
3    z

df.A.size
# 4

... enquanto countconta os valores não NaN:

df.A.count()
# 3 

Observe que sizeé um atributo (dá o mesmo resultado que len(df)ou len(df.A)). counté uma função.

_{1. DataFrame.sizetambém é um atributo e retorna o número de elementos no DataFrame (linhas x colunas).}

Comportamento com GroupBy- Estrutura de Saída

Além da diferença básica, há também a diferença na estrutura da saída gerada quando chamado GroupBy.size()vs GroupBy.count().

df = pd.DataFrame({'A': list('aaabbccc'), 'B': ['x', 'x', np.nan, np.nan, np.nan, np.nan, 'x', 'x']})
df
   A    B
0  a    x
1  a    x
2  a  NaN
3  b  NaN
4  b  NaN
5  c  NaN
6  c    x
7  c    x

Considerar,

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

A
a    3
b    2
c    3
dtype: int64

Versus,

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

   B
A   
a  2
b  0
c  2

GroupBy.countretorna um DataFrame quando você chama countem todas as colunas, enquanto GroupBy.sizeretorna um Series.

O motivo é que sizeé o mesmo para todas as colunas, portanto, apenas um único resultado é retornado. Enquanto isso, o counté chamado para cada coluna, pois os resultados dependeriam de quantos NaNs cada coluna tem.

Comportamento com pivot_table

Outro exemplo é como pivot_tabletrata esses dados. Suponha que gostaríamos de calcular a tabulação cruzada de

df

   A  B
0  0  1
1  0  1
2  1  2
3  0  2
4  0  0

pd.crosstab(df.A, df.B)  # Result we expect, but with `pivot_table`.

B  0  1  2
A         
0  1  2  1
1  0  0  1

Com pivot_table, você pode emitir size:

df.pivot_table(index='A', columns='B', aggfunc='size', fill_value=0)

B  0  1  2
A         
0  1  2  1
1  0  0  1

Mas countnão funciona; um DataFrame vazio é retornado:

df.pivot_table(index='A', columns='B', aggfunc='count')

Empty DataFrame
Columns: []
Index: [0, 1]

Acredito que a razão para isso é que 'count'deve ser feito na série que é passada para o valuesargumento, e quando nada é passado, os pandas decidem não fazer suposições.

Apenas para adicionar um pouco à resposta de @Edchum, mesmo que os dados não tenham valores NA, o resultado de count () é mais detalhado, usando o exemplo anterior:

grouped = df.groupby('a')
grouped.count()
Out[197]: 
   b  c
a      
0  2  2
1  1  1
2  2  3
grouped.size()
Out[198]: 
a
0    2
1    1
2    3
dtype: int64

Quando estamos lidando com dataframes normais, então apenas a diferença será uma inclusão de valores NAN, significa que a contagem não inclui valores NAN ao contar linhas.

Mas se estivermos usando essas funções com o groupbythen, para obter os resultados corretos count(), temos que associar qualquer campo numérico ao groupbypara obter o número exato de grupos onde para size()não há necessidade desse tipo de associação.

Além de todas as respostas acima, gostaria de apontar mais uma diferença que me parece significativa.

Você pode correlacionar o Datarametamanho do Panda e contar com o do JavaVectors tamanho e comprimento . Quando criamos o vetor, alguma memória predefinida é alocada a ele. quando chegamos mais perto do número de elementos que ele pode ocupar enquanto adicionamos elementos, mais memória é alocada para ele. Da mesma forma, emDataFrame medida que adicionamos elementos, a memória alocada a ele aumenta.

O atributo de tamanho fornece o número de células de memória alocadas, DataFrameenquanto a contagem fornece o número de elementos que estão realmente presentes DataFrame. Por exemplo,

Você pode ver que existem 3 linhas em DataFrame , seu tamanho é 6.

Esta resposta cobre a diferença de tamanho e contagem em relação a DataFramee não Pandas Series. Eu não verifiquei o que acontece comSeries