¿Esa es la diferencia entre groupby("x").county groupby("x").sizeen pandas?

¿El tamaño simplemente excluye nada?

sizeincluye NaNvalores, countno:

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 

¿Cuál es la diferencia entre tamaño y recuento en pandas?

Las otras respuestas han señalado la diferencia, sin embargo, no es completamente exacto decir " sizecuenta NaN mientras countque no". Si bien de sizehecho cuenta los NaN, esto es en realidad una consecuencia del hecho de que sizedevuelve el tamaño (o la longitud) del objeto al que se llama. Naturalmente, esto también incluye filas / valores que son NaN.

Entonces, para resumir, sizedevuelve el tamaño de 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

... while countcuenta los valores no NaN:

df.A.count()
# 3 

Observe que sizees un atributo (da el mismo resultado que len(df)o len(df.A)). countes una función.

_{1. DataFrame.sizetambién es un atributo y devuelve el número de elementos en el DataFrame (filas x columnas).}

Comportamiento con GroupBy- Estructura de salida

Además de la diferencia básica, también existe la diferencia en la estructura de la salida generada al llamar 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.countdevuelve un DataFrame cuando llama counta todas las columnas, mientras que GroupBy.sizedevuelve una Serie.

El motivo es que sizees el mismo para todas las columnas, por lo que solo se devuelve un resultado. Mientras tanto, countse llama para cada columna, ya que los resultados dependerían de cuántos NaN tenga cada columna.

Comportamiento con pivot_table

Otro ejemplo es cómo se pivot_tabletratan estos datos. Suponga que nos gustaría calcular la tabulación 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

Con pivot_table, puede 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

Pero countno funciona; se devuelve un DataFrame vacío:

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

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

Creo que la razón de esto es que se 'count'debe hacer sobre la serie que se pasa al valuesargumento, y cuando no se pasa nada, los pandas deciden no hacer suposiciones.

Solo para agregar un poco a la respuesta de @ Edchum, incluso si los datos no tienen valores NA, el resultado de count () es más detallado, usando el ejemplo 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

Cuando se trata de marcos de datos normales, la única diferencia será la inclusión de valores NAN, significa que el recuento no incluye los valores NAN al contar filas.

Pero si usamos estas funciones con el groupbyentonces, para obtener los resultados correctos count()tenemos que asociar cualquier campo numérico con el groupbypara obtener el número exacto de grupos donde size()no hay necesidad de este tipo de asociación.

Además de todas las respuestas anteriores, me gustaría señalar una diferencia más que me parece significativa.

Puede correlacionar el Datarametamaño de Panda y contar con el Vectorstamaño y la longitud de Java . Cuando creamos un vector, se le asigna algo de memoria predefinida. cuando nos acercamos al número de elementos que puede ocupar al agregar elementos, se le asigna más memoria. De manera similar, a DataFramemedida que agregamos elementos, la memoria asignada aumenta.

El atributo de tamaño proporciona el número de celdas de memoria asignadas, DataFramemientras que el recuento proporciona el número de elementos que están realmente presentes DataFrame. Por ejemplo,

Puedes ver que aunque hay 3 filas adentro DataFrame, su tamaño es 6.

Esta respuesta cubre la diferencia de tamaño y conteo con respecto a DataFramey no Pandas Series. No he comprobado que pasa conSeries