Estoy tratando de obtener el número de filas de dataframe df con Pandas, y aquí está mi código.

Método 1:

total_rows = df.count
print total_rows +1

Método 2:

total_rows = df['First_columnn_label'].count
print total_rows +1

Ambos fragmentos de código me dan este error:

TypeError: tipos de operando no admitidos para +: 'instancemethod' e 'int'

¿Qué estoy haciendo mal?

Puede usar la .shapepropiedad o simplemente len(DataFrame.index). Sin embargo, hay diferencias notables de rendimiento ( len(DataFrame.index)es el más rápido):

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)

EDITAR: como señaló @Dan Allen en los comentarios len(df.index)y df[0].count()no son intercambiables, ya que countexcluye NaNs,

Supongamos dfque su marco de datos es entonces:

count_row = df.shape[0]  # gives number of row count
count_col = df.shape[1]  # gives number of col count

O, más sucintamente,

r, c = df.shape

Uso len(df). Esto funciona a partir de pandas 0.11 o tal vez incluso antes.

__len__()actualmente está documentado (0.12) con Returns length of index. Información de tiempo, configurada de la misma manera que en la respuesta de la raíz:

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

Debido a una llamada de función adicional, es un poco más lento que llamar len(df.index)directamente, pero esto no debería desempeñar ningún papel en la mayoría de los casos de uso.

¿Cómo obtengo el recuento de filas de un DataFrame de pandas?

Esta tabla resume las diferentes situaciones en las que desea contar algo en un DataFrame (o Serie, para completar), junto con los métodos recomendados.

Notas al pie

1. DataFrame.countdevuelve los recuentos para cada columna como un Seriesya que el recuento no nulo varía según la columna.
2. DataFrameGroupBy.sizedevuelve un Series, ya que todas las columnas del mismo grupo comparten el mismo recuento de filas.
3. DataFrameGroupBy.countdevuelve a DataFrame, ya que el recuento no nulo podría diferir entre las columnas del mismo grupo. Para obtener el recuento no nulo en grupo para una columna específica, use df.groupby(...)['x'].count()donde "x" es la columna a contar.

Ejemplos de código mínimo

A continuación, muestro ejemplos de cada uno de los métodos descritos en la tabla anterior. Primero, la configuración -

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

Recuento de filas de una trama de datos: len(df), df.shape[0]olen(df.index)

len(df)
# 5

df.shape[0]
# 5

len(df.index)
# 5

Parece una tontería comparar el rendimiento de las operaciones de tiempo constante, especialmente cuando la diferencia está en el nivel de "en serio, no te preocupes por eso". Pero esto parece ser una tendencia con otras respuestas, así que estoy haciendo lo mismo para completar.

De los 3 métodos anteriores, len(df.index)(como se menciona en otras respuestas) es el más rápido.

Nota

• Todos los métodos anteriores son operaciones de tiempo constante, ya que son simples búsquedas de atributos.
• df.shape(similar a ndarray.shape) es un atributo que devuelve una tupla de (# Rows, # Cols). Por ejemplo, df.shapevuelve (8, 2)para el ejemplo aquí.

Número de columnas de una trama de datos: df.shape[1],len(df.columns)

df.shape[1]
# 2

len(df.columns)
# 2

Análogo a len(df.index), len(df.columns)es el más rápido de los dos métodos (pero requiere más caracteres para escribir).

Número de filas de una Serie: len(s), s.size,len(s.index)

len(s)
# 5

s.size
# 5

len(s.index)
# 5

s.sizey len(s.index)son casi iguales en términos de velocidad. Pero lo recomiendo len(df).

Note
size es un atributo y devuelve el número de elementos (= recuento de filas para cualquier serie). Los marcos de datos también definen un atributo de tamaño que devuelve el mismo resultado que df.shape[0] * df.shape[1].

Recuento de filas no nulas: DataFrame.countySeries.count

Los métodos descritos aquí solo cuentan valores no nulos (lo que significa que se ignoran los NaN).

Las llamadas DataFrame.countdevolverán recuentos que no sean NaN para cada columna:

df.count()

A    5
B    3
dtype: int64

Para la serie, use Series.countcon un efecto similar:

s.count()
# 3

Recuento de filas en grupo: GroupBy.size

Para DataFrames, use DataFrameGroupBy.sizepara contar el número de filas por grupo.

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

A
a    2
b    2
c    1
dtype: int64

Del mismo modo, para Series, lo utilizará SeriesGroupBy.size.

s.groupby(df.A).size()

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

En ambos casos, Seriesse devuelve a. Esto también tiene sentido DataFramesya que todos los grupos comparten el mismo recuento de filas.

Recuento de filas no nulas en grupo: GroupBy.count

Similar a lo anterior, pero use GroupBy.count, no GroupBy.size. Tenga en cuenta que sizesiempre devuelve a Series, mientras que countdevuelve un Seriesif en una columna específica, o bien a DataFrame.

Los siguientes métodos devuelven lo mismo:

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

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

Mientras tanto, para count, tenemos

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

   B
A   
a  2
b  1
c  0

... invocó todo el objeto GroupBy, v / s,

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

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

Llamado en una columna específica.

TL; DR

utilizar len(df)

len()es tu amigo, se puede usar para contar filas como len(df).

Alternativamente, puede acceder a todas las filas df.indexy a todas las columnas df.columns, y como puede usar len(anyList)para obtener el recuento de la lista, use len(df.index)para obtener el número de filas y len(df.columns)para el recuento de columnas.

O bien, puede utilizar df.shapeque devuelve el número de filas y columnas en conjunto, si desea acceder al número de filas sólo uso df.shape[0]y por el número de columnas Use Only: df.shape[1].

Además de las respuestas anteriores, el uso puede usarse df.axespara obtener la tupla con índices de fila y columna y luego usar la len()función:

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

... basándose en la respuesta de Jan-Philip Gehrcke.

La razón por la cual len(df)o len(df.index)es más rápido que df.shape[0]. Mira el código df.shape es un @propertyque ejecuta un método DataFrame que llama lendos veces.

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)

Y debajo del capó 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)será un poco más rápido que len(df)ya que tiene una llamada de función menos, pero esto siempre es más rápido quedf.shape[0]

Llego a los pandas desde el Rfondo, y veo que los pandas son más complicados cuando se trata de seleccionar una fila o columna. Tuve que lidiar con eso por un tiempo, luego encontré algunas formas de lidiar con esto:

obteniendo el número de columnas:

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.

obteniendo el número de filas:

len(df.index) #It's similar.

En caso de que desee obtener el recuento de filas en medio de una operación encadenada, puede usar:

df.pipe(len)

Ejemplo:

row_count = (
      pd.DataFrame(np.random.rand(3,4))
      .reset_index()
      .pipe(len)
)

Esto puede ser útil si no desea poner una declaración larga dentro de una len()función.

Podrías usar __len__()en su lugar, pero se __len__()ve un poco raro.

Oye, puedes usar hacer esto también:

Digamos que dfes su marco de datos. Luego df.shapele da la forma de su marco de datos, es decir(row,col)

Por lo tanto, asigne el siguiente comando para obtener el requerido

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

Para el marco de datos df, un recuento de filas con formato de coma impreso utilizado al explorar datos:

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

Ejemplo:

nrow(my_df)
12,456,789

Un método alternativo para averiguar la cantidad de filas en un marco de datos que creo que es la variante más legible es pandas.Index.size.

Tenga en cuenta que, como comenté en la respuesta aceptada:

Sospechoso en pandas.Index.sizerealidad sería más rápido que, len(df.index)pero timeiten mi computadora me dice lo contrario (~ 150 ns más lento por ciclo).

No estoy seguro de si esto funcionaría (los datos PODRÍAN omitirse), pero esto puede funcionar:

*dataframe name*.tails(1)

y luego usando esto, puede encontrar el número de filas ejecutando el fragmento de código y mirando el número de fila que se le dio.

Cualquiera de estos puede hacer ( dfes el nombre del DataFrame):

Método 1: uso de la lenfunción:

len(df)dará el número de filas en un DataFrame llamado df.

Método 2: usando la countfunción:

df[col].count()contará el número de filas en una columna dada col.

df.count() dará el número de filas para todas las columnas.