Comment obtenir le nombre de lignes d'un DataFrame Pandas ?

Question

Comment obtenir le nombre de lignes d'un dataframe pandas ? df ?

Answer 1

Pour un cadre de données df on peut utiliser l'un des éléments suivants :

• len(df.index)
• df.shape[0]
• df[df.columns[0]].count() (== nombre de valeurs non NaN dans la première colonne)

---

Code pour reproduire l'intrigue :

import numpy as np
import pandas as pd
import perfplot

perfplot.save(
    "out.png",
    setup=lambda n: pd.DataFrame(np.arange(n * 3).reshape(n, 3)),
    n_range=[2**k for k in range(25)],
    kernels=[
        lambda df: len(df.index),
        lambda df: df.shape[0],
        lambda df: df[df.columns[0]].count(),
    ],
    labels=["len(df.index)", "df.shape[0]", "df[df.columns[0]].count()"],
    xlabel="Number of rows",
)

Answer 2

Supposons que df est votre cadre de données alors :

count_row = df.shape[0]  # Gives number of rows
count_col = df.shape[1]  # Gives number of columns

Ou, plus succinctement,

r, c = df.shape

Answer 3

Utilisez len(df) :-).

__len__() est documenté par "Renvoie la longueur de l'index".

Informations sur le chronométrage, configurées de la même manière qu'en 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 bien sûr correct de dire que c'est un peu plus lent que d'appeler len(df.index) directement. Mais cela ne devrait pas avoir d'importance dans la plupart des cas. Je trouve len(df) pour être tout à fait lisible.

Answer 4

Comment obtenir le nombre de lignes d'un DataFrame Pandas ?

Ce tableau résume les différentes situations dans lesquelles vous souhaitez compter quelque chose dans un DataFrame (ou une série, pour être complet), ainsi que la ou les méthodes recommandées.

Notes de bas de page

1. DataFrame.count renvoie les comptes pour chaque colonne sous forme de Series puisque le nombre de non-nuls varie selon les colonnes.
2. DataFrameGroupBy.size renvoie un Series puisque toutes les colonnes d'un même groupe partagent le même nombre de lignes.
3. DataFrameGroupBy.count renvoie un DataFrame puisque le compte non nul peut différer entre les colonnes d'un même groupe. Pour obtenir le nombre de non-nuls par groupe pour une colonne spécifique, utilisez df.groupby(...)['x'].count() où "x" est la colonne à compter.

---

Exemples de code minimal

Je présente ci-dessous 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 idiot de comparer les performances d'opérations à temps constant, surtout quand la différence est du niveau de "sérieusement, ne vous en faites pas". Mais cela semble être une tendance avec d'autres réponses, donc je fais la même chose pour être complet.

Parmi les trois méthodes ci-dessus, len(df.index) (comme mentionné dans d'autres réponses) est le plus rapide.

Note

• Toutes les méthodes ci-dessus sont des opérations en 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 prend 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 y len(s.index) sont à peu près les mêmes en termes de vitesse. Mais je recommande len(df) .

Note size est un attribut et renvoie le nombre d'éléments (=count). de lignes pour toute série). Les DataFrames définissent également un attribut size qui renvoie le même résultat que df.shape[0] * df.shape[1] .

Non-Null Row Count : DataFrame.count y Series.count

Les méthodes décrites ici ne comptent que les valeurs non nulles (ce qui signifie que les NaN sont ignorés).

Appel à DataFrame.count retournera des comptages non-NaN pour chaque colonne :

df.count()

A    5
B    3
dtype: int64

Pour les séries, utilisez Series.count à un effet similaire :

s.count()
# 3

Nombre de rangs par groupe : GroupBy.size

Para DataFrames utiliser 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 est utile pour DataFrames puisque tous les groupes partagent le même nombre de lignes.

Comptage des rangs non nuls par groupe : GroupBy.count

Similaire au précédent, mais utiliser GroupBy.count pas GroupBy.size . Notez que size renvoie toujours un Series alors 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

Pendant ce temps, pour count nous avons

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

   B
A
a  2
b  1
c  0

...appelé sur l'objet GroupBy entier, vs,

df.groupby('A')['B'].count()

A
a    2
b    1
c    0
Name: B, dtype: int64

Appelé sur une colonne spécifique.

Answer 5

TL;DR utiliser len(df)

len() renvoie le nombre d'éléments (la longueur) d'un objet de type liste (fonctionne également pour les objets de type dictionnaire, chaîne, tuple ou plage). Ainsi, pour obtenir le nombre de lignes d'un DataFrame, utilisez simplement len(df) . Pour en savoir plus sur len fonction, voir la page officielle .

---

Alternativement, vous pouvez accéder à toutes les lignes et à toutes les colonnes avec df.index et df.columns respectivement. Puisque vous pouvez utiliser le len(anyList) pour obtenir les numéros d'éléments, utilisez len(df.index) vous donnera le nombre de lignes, et len(df.columns) donnera le nombre de colonnes.

Ou bien, vous pouvez utiliser df.shape qui renvoie le nombre de lignes et de colonnes ensemble (sous forme de tuple). Si vous souhaitez accéder au nombre de lignes, utilisez uniquement la commande df.shape[0] . Pour le nombre de colonnes, utilisez uniquement : df.shape[1] .