C'est la différence entre groupby("x").countet groupby("x").sizechez les pandas?

La taille exclut-elle simplement zéro?

sizeinclut des NaNvaleurs, countne:

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 

Quelle est la différence entre la taille et le nombre chez les pandas?

Les autres réponses ont souligné la différence, cependant, il n'est pas tout à fait exact de dire " sizecompte NaNs alors countque non". Bien sizeque les NaN comptent effectivement, c'est en fait une conséquence du fait que sizerenvoie la taille (ou la longueur) de l'objet sur lequel il est appelé. Naturellement, cela inclut également les lignes / valeurs qui sont NaN.

Donc, pour résumer, sizerenvoie la taille 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 countcompte les valeurs non-NaN:

df.A.count()
# 3 

Notez que sizec'est un attribut (donne le même résultat que len(df)ou len(df.A)). countest une fonction.

_{1. DataFrame.sizeest également un attribut et renvoie le nombre d'éléments dans le DataFrame (lignes x colonnes).}

Comportement avec GroupBy- Structure de sortie

Outre la différence de base, il y a aussi la différence dans la structure de la sortie générée lors de l' appel 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

Considérer,

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

A
a    3
b    2
c    3
dtype: int64

Contre,

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

   B
A   
a  2
b  0
c  2

GroupBy.countrenvoie un DataFrame lorsque vous appelez countsur toutes les colonnes, tandis que GroupBy.sizerenvoie une Series.

La raison en est que sizec'est la même chose pour toutes les colonnes, donc un seul résultat est renvoyé. Pendant ce temps, le countest appelé pour chaque colonne, car les résultats dépendraient du nombre de NaN de chaque colonne.

Comportement avec pivot_table

Un autre exemple est la façon dont pivot_tabletraite ces données. Supposons que nous souhaitons calculer la tabulation croisée 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

Avec pivot_table, vous pouvez émettre 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

Mais countne fonctionne pas; un DataFrame vide est renvoyé:

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

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

Je crois que la raison en est que cela 'count'doit être fait sur la série qui est passée à l' valuesargument, et quand rien n'est passé, les pandas décident de ne faire aucune hypothèse.

Juste pour ajouter un peu à la réponse de @ Edchum, même si les données n'ont pas de valeurs NA, le résultat de count () est plus détaillé, en utilisant l'exemple précédent:

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

Lorsque nous traitons avec des dataframes normales, la seule différence sera l'inclusion de valeurs NAN, ce qui signifie que le compte n'inclut pas les valeurs NAN lors du comptage des lignes.

Mais si nous utilisons ces fonctions avec le groupbyalors, pour obtenir les bons résultats, count()nous devons associer n'importe quel champ numérique avec le groupbypour obtenir le nombre exact de groupes où size()il n'y a pas besoin de ce type d'association.

En plus de toutes les réponses ci-dessus, je voudrais souligner une autre différence qui me semble significative.

Vous pouvez corréler la Datarametaille et le nombre de Panda avec la Vectorstaille et la longueur de Java . Lorsque nous créons un vecteur, une mémoire prédéfinie lui est allouée. lorsque nous nous rapprochons du nombre d'éléments qu'il peut occuper en ajoutant des éléments, plus de mémoire lui est allouée. De même, à DataFramemesure que nous ajoutons des éléments, la mémoire qui leur est allouée augmente.

L'attribut Size donne le nombre de cellules de mémoire allouées DataFramealors que count donne le nombre d'éléments qui sont réellement présents dans DataFrame. Par exemple,

Vous pouvez voir s'il y a 3 lignes DataFrame, sa taille est de 6.

Cette réponse couvre la différence de taille et de nombre par rapport à DataFrameet non Pandas Series. Je n'ai pas vérifié ce qui se passe avecSeries