Comment puis-je obtenir le nombre de lignes d'un pandas DataFrame?
J'essaie d'obtenir le nombre de lignes de dataframe df avec Pandas, et voici mon code.
Méthode 1:
total_rows = df.count
print total_rows +1
Méthode 2:
total_rows = df['First_columnn_label'].count
print total_rows +1
Les extraits de code me donnent cette erreur:
TypeError: type (s) d'opérande non pris en charge pour +: 'instancemethod' et 'int'
Qu'est-ce que je fais mal?
Vous pouvez utiliser la propriété .shape ou simplement len(DataFrame.index). Cependant, il existe des différences de performances notables (len(DataFrame.index) est le plus rapide):
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: Comme @Dan Allen l’a noté dans les commentaires len(df.index) et df[0].count() ne sont pas interchangeables car count exclut NaNs,
Supposons que df soit votre cadre de données alors:
count_row = df.shape[0] # gives number of row count
count_col = df.shape[1] # gives number of col count
Ou, plus succinctement,
r, c = df.shape
Utilisez len(df). Cela fonctionne à partir de pandas 0.11 ou peut-être même plus tôt.
__len__() est actuellement (0.12) documenté avec Returns length of index. Informations de chronométrage, configuré de la même manière que dans la réponse de 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
En raison d'un appel de fonction supplémentaire, il est un peu plus lent que d'appeler directement len(df.index), mais cela ne devrait jouer aucun rôle dans la plupart des cas d'utilisation.
Comment puis-je obtenir le nombre de lignes d'un pandas DataFrame?
Ce tableau récapitule les différentes situations dans lesquelles vous voudriez compter quelque chose dans un DataFrame (ou une série, par souci d'exhaustivité), ainsi que la ou les méthodes recommandées.
Notes de bas de page
- _
DataFrame.count_ renvoie les comptes de chaque colonne sous la formeSeries, car le nombre non nul varie selon la colonne.- _
DataFrameGroupBy.size_ renvoie unSeries, car toutes les colonnes du même groupe partagent le même nombre de lignes.- _
DataFrameGroupBy.count_ renvoie unDataFrame, car le nombre non nul peut différer d'une colonne à l'autre du même groupe. Pour obtenir le nombre non nul par groupe d'une colonne spécifique, utilisezdf.groupby(...)['x'].count()où "x" est la colonne à compter.
Exemples de codes minimaux
Ci-dessous, je présente des exemples de chacune des méthodes décrites dans le tableau ci-dessus. Tout d'abord, la configuration -
_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
_Nombre de lignes d'un DataFrame: len(df), _df.shape[0]_ ou len(df.index)
_len(df)
# 5
df.shape[0]
# 5
len(df.index)
# 5
_Il semble ridicule de comparer les performances des opérations à temps constant, en particulier lorsque la différence est du niveau "sérieusement, ne vous en faites pas". Mais cela semble être une tendance avec d'autres réponses, alors je fais la même chose pour être complet.
Parmi les 3 méthodes ci-dessus, len(df.index) (comme indiqué dans d'autres réponses) est la plus rapide.
Remarque
- Toutes les méthodes ci-dessus sont des opérations à temps constant car il s'agit de simples recherches d'attributs.
- _
df.shape_ (similaire à _ndarray.shape_) est un attribut qui renvoie un tuple de _(# Rows, # Cols)_. Par exemple, _df.shape_ renvoie _(8, 2)_ pour l'exemple ici.
Nombre de colonnes d'un DataFrame: _df.shape[1]_, len(df.columns)
_df.shape[1]
# 2
len(df.columns)
# 2
_Analogue à len(df.index), len(df.columns) est la plus rapide des deux méthodes (mais nécessite plus de caractères à taper).
Nombre de lignes d'une série: len(s), _s.size_, len(s.index)
_len(s)
# 5
s.size
# 5
len(s.index)
# 5
__s.size_ et len(s.index) sont à peu près les mêmes en termes de vitesse. Mais je recommande len(df).
Remarque
sizeest un attribut et renvoie le nombre d'éléments (= nombre de lignes pour une série). Les DataFrames définissent également un attribut de taille qui renvoie le même résultat que _df.shape[0] * df.shape[1]_.
Nombre de lignes non nulles: _DataFrame.count_ et _Series.count_
Les méthodes décrites ici ne comptent que les valeurs non nulles (ce qui signifie que les NaN sont ignorés).
L'appel de DataFrame.count renverra des comptes non-NaN pour chaque colonne :
_df.count()
A 5
B 3
dtype: int64
_Pour la série, utilisez Series.count avec un effet similaire:
_s.count()
# 3
_Nombre de lignes par groupe: _GroupBy.size_
Pour DataFrames, utilisez DataFrameGroupBy.size pour compter le nombre de lignes par groupe.
_df.groupby('A').size()
A
a 2
b 2
c 1
dtype: int64
_De même, pour Series, vous utiliserez SeriesGroupBy.size .
_s.groupby(df.A).size()
A
a 2
b 2
c 1
Name: B, dtype: int64
_Dans les deux cas, un Series est renvoyé. Cela a également un sens pour DataFrames puisque tous les groupes partagent le même nombre de lignes.
Nombre de lignes non nulles par groupe: _GroupBy.count_
Semblable à ce qui précède, mais utilisez GroupBy.count , pas _GroupBy.size_. Notez que size renvoie toujours un Series, tandis que count renvoie un Series s'il est appelé sur une colonne spécifique, ou bien un DataFrame.
Les méthodes suivantes renvoient la même chose:
_df.groupby('A')['B'].size()
df.groupby('A').size()
A
a 2
b 2
c 1
Name: B, dtype: int64
_En attendant, pour count, nous avons
_df.groupby('A').count()
B
A
a 2
b 1
c 0
_... appelé sur l'ensemble de l'objet GroupBy, v/s,
_df.groupby('A')['B'].count()
A
a 2
b 1
c 0
Name: B, dtype: int64
_Appelé sur une colonne spécifique.
len() est votre ami, la réponse courte pour le nombre de lignes est len(df).
Vous pouvez également accéder à toutes les lignes par df.index et à toutes les colonnes à df.columns, et comme vous pouvez utiliser len(anyList) pour obtenir le nombre de listes, vous pouvez donc utiliser len(df.index) pour obtenir le nombre de lignes et len(df.columns) pour le nombre de colonnes.
Vous pouvez également utiliser df.shape qui renvoie le nombre de lignes et de colonnes. Si vous souhaitez accéder au nombre de lignes, utilisez uniquement df.shape[0] et, pour le nombre de colonnes, utilisez: df.shape[1] .
En plus des réponses ci-dessus, vous pouvez utiliser df.axes pour obtenir le tuple avec les index de ligne et de colonne, puis utilisez la fonction len():
total_rows=len(df.axes[0])
total_cols=len(df.axes[1])
Nombre de lignes (utilisez n'importe lequel):
df.shape[0]
len(df)
J'arrive à pandas de R arrière-plan et je constate que pandas est plus compliqué à sélectionner une ligne ou une colonne. J'ai dû lutter avec pendant un moment, puis j'ai trouvé des moyens de faire face:
obtenir le nombre de colonnes:
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.
obtenir le nombre de lignes:
len(df.index) #It's similar.
... s'appuyant sur la réponse de Jan-Philip Gehrcke.
La raison pour laquelle len(df) ou len(df.index) est plus rapide que df.shape[0]. Regarde le code. df.shape est un @property qui exécute une méthode DataFrame appelant len deux fois.
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)
Et sous le capot 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) sera légèrement plus rapide que len(df) puisqu'il comporte un appel de fonction de moins, mais il est toujours plus rapide que df.shape[0]
df.shape renvoie la forme du bloc de données sous la forme d'un tuple (nombre de lignes, nombre de colonnes).
Vous pouvez simplement accéder non. de rangées ou non. de colonnes avec df.shape[0] ou df.shape[1], respectivement, ce qui revient à accéder aux valeurs du tuple.
Si vous souhaitez obtenir le nombre de lignes au milieu d'une opération chaînée, vous pouvez utiliser:
df.pipe(len)
Exemple:
row_count = (
pd.DataFrame(np.random.Rand(3,4))
.reset_index()
.pipe(len)
)
Cela peut être utile si vous ne voulez pas mettre une longue déclaration dans une fonction len ().
Vous pouvez utiliser __len __ () à la place, mais __len __ () semble un peu bizarre.
Pour dataframe df, un nombre de lignes au format virgule imprimé utilisé lors de l'exploration de données:
def nrow(df):
print("{:,}".format(df.shape[0]))
Exemple:
nrow(my_df)
12,456,789