J'essaie d'obtenir le nombre de lignes de df de trame de données 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 deux 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 .shapepropriété ou tout simplement len(DataFrame.index). Cependant, il existe des différences de performances notables ( len(DataFrame.index)est la 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 comme countexclut NaNs,

Supposons que dfvotre trame de données soit 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 synchronisation, configurées 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 len(df.index)directement, 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 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.countrenvoie les décomptes pour chaque colonne sous forme de, Seriescar le décompte non nul varie selon la colonne.
2. DataFrameGroupBy.sizerenvoie a Series, car toutes les colonnes du même groupe partagent le même nombre de lignes.
3. DataFrameGroupBy.countrenvoie a DataFrame, car le nombre non nul peut différer d'une colonne à l'autre dans le même groupe. Pour obtenir le nombre non nul par groupe pour une colonne spécifique, utilisez df.groupby(...)['x'].count()où "x" est la colonne à compter.

Exemples de code minimal

Ci-dessous, je montre 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'une trame de données: len(df), df.shape[0]oulen(df.index)

len(df)
# 5

df.shape[0]
# 5

len(df.index)
# 5

Il semble stupide de comparer les performances d'opérations à temps constant, surtout lorsque la différence est au niveau de "sérieusement, ne vous inquiétez pas". Mais cela semble être une tendance avec d'autres réponses, donc je fais de même pour être complet.

Des 3 méthodes ci-dessus, len(df.index)(comme mentionné dans d'autres réponses) est la plus rapide.

Remarque

• Toutes les méthodes ci-dessus sont des opérations à temps constant car ce sont de simples recherches d'attributs.
• df.shape(similaire à ndarray.shape) est un attribut qui renvoie un tuple de (# Rows, # Cols). Par exemple, df.shaperenvoie (8, 2)l'exemple ici.

Nombre de colonnes d'une trame de données: 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.sizeet len(s.index)sont à peu près les mêmes en termes de vitesse. Mais je recommande len(df).

La note
size est un attribut et renvoie le nombre d'éléments (= nombre de lignes pour n'importe quelle 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.countetSeries.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 DataFrame.countrenvoie des nombres non NaN pour chaque colonne:

df.count()

A    5
B    3
dtype: int64

Pour les séries, utilisez Series.countun effet similaire:

s.count()
# 3

Nombre de lignes par groupe: GroupBy.size

Pour DataFrames, utilisez DataFrameGroupBy.sizepour 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 Seriesest retourné. Cela a du sens pourDataFrames puisque tous les groupes partagent le même nombre de lignes.

Nombre de lignes non nulles par groupe: GroupBy.count

Similaire ci - dessus, mais l' utilisation GroupBy.count, non GroupBy.size. Notez que sizerenvoie toujours un Series, tandis que countrenvoie un Seriessi 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'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.

TL; DR

utilisation len(df)

len()est votre ami, il peut être utilisé pour le nombre de lignes len(df).

Vous pouvez également accéder à toutes les lignes par df.indexet à toutes les colonnes par df.columns, et comme vous pouvez utiliser le len(anyList)pour obtenir le nombre de listes, utiliser len(df.index)pour obtenir le nombre de lignes et le nombre de len(df.columns)colonnes.

Ou, vous pouvez utiliser df.shapequi retourne le nombre de lignes et de colonnes ensemble, si vous souhaitez accéder au nombre de lignes utilisent uniquement df.shape[0]et pour le nombre de colonnes utilisez uniquement: df.shape[1].

Outre les réponses ci-dessus, l'utilisation peut être utilisée df.axespour obtenir le tuple avec des index de ligne et de colonne, puis utiliser la len()fonction:

total_rows=len(df.axes[0])
total_cols=len(df.axes[1])

... en 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]. Regardez le code. df.shape est un @propertyqui exécute une méthode DataFrame appelant lendeux 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 a un appel de fonction en moins, mais c'est toujours plus rapide quedf.shape[0]

Je viens des pandas de Rfond, et je vois que les pandas sont plus compliqués quand il s'agit de sélectionner une ligne ou une colonne. J'ai dû lutter avec pendant un certain temps, puis j'ai trouvé des moyens de gérer:

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.

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 instruction dans une len()fonction.

Vous pouvez utiliser à la __len__()place, mais cela __len__()semble un peu bizarre.

Hé, vous pouvez également le faire:

Disons que dfc'est votre dataframe. df.shapeVous donne ensuite la forme de votre cadre de données, c'est-à-dire(row,col)

Ainsi, attribuez la commande ci-dessous pour obtenir la

 row = df.shape[0], col = df.shape[1]

Pour dataframe df, un nombre de lignes au format virgule imprimé utilisé lors de l'exploration des données:

def nrow(df):
    print("{:,}".format(df.shape[0]))

Exemple:

nrow(my_df)
12,456,789

Une méthode alternative pour trouver la quantité de lignes dans une trame de données qui, je pense, est la variante la plus lisible est pandas.Index.size.

Notez que, comme j'ai commenté la réponse acceptée:

Suspecté pandas.Index.sizeserait en fait plus rapide que len(df.index)mais timeitsur mon ordinateur me dit le contraire (~ 150 ns plus lent par boucle).

Je ne sais pas si cela fonctionnerait (les données POURRAIENT être omises), mais cela peut fonctionner:

*dataframe name*.tails(1)

puis en utilisant cela, vous pouvez trouver le nombre de lignes en exécutant l'extrait de code et en regardant le numéro de ligne qui vous a été donné.

L'un ou l'autre de ceci peut faire ( dfest le nom du DataFrame):

Méthode 1: en utilisant la lenfonction:

len(df)donnera le nombre de lignes dans un DataFrame nommé df.

Méthode 2: en utilisant la countfonction:

df[col].count()comptera le nombre de lignes dans une colonne donnée col.

df.count() donnera le nombre de lignes pour toutes les colonnes.