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


937

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?


12
ok descubrí, debería haber llamado a método no verificar propiedad, por lo que debería ser df.count () no df.count
yemu

56
^ ¡Peligroso! Tenga en cuenta que df.count()solo devolverá el recuento de filas que no sean NA / NaN para cada columna. En su df.shape[0]lugar, debe usar , que siempre le indicará correctamente el número de filas.
smci

3
Tenga en cuenta que df.count no devolverá un int cuando el marco de datos esté vacío (p. Ej., Pd.DataFrame (columnas = ["Azul", "Rojo"). Conteo no es 0)
Marcelo Bielsa

Respuestas:


1255

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)

ingrese la descripción de la imagen aquí

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


13
Hay una buena razón por la que se usa shapeen el trabajo interactivo, en lugar de len (df): al probar diferentes filtros, a menudo necesito saber cuántos elementos quedan. Con forma, puedo ver eso simplemente agregando .shape después de mi filtrado. Con len () la edición de la línea de comandos se vuelve mucho más engorrosa, yendo y viniendo.
K.-Michael Aye

99
No funcionará para OP, pero si solo necesita saber si el marco de datos está vacío, df.emptyes la mejor opción.
jtschoonhoven

19
Sé que ha pasado un tiempo, pero no es len (df.index) toma 381 nanosegundos, o 0.381 microsegundos, df.shape es 3 veces más lento, con 1.17 microsegundos. ¿Me he perdido algo? @root
TG

11
(3,3) matriz es un mal ejemplo ya que no muestra el orden de la tupla de forma
xaedes

44
¿Cómo es df.shape[0]más rápido que len(df)o len(df.columns)? Dado que 1 ns (nanosegundos) = 1000 µs (microsegundos), por lo tanto 1.17µs = 1170ns, lo que significa que es aproximadamente 3 veces más lento que 381ns
jef el

304

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

44
Si el conjunto de datos es grande, len (df.index) es significativamente más rápido que df.shape [0] si solo necesita un recuento de filas. Lo probé
Sumit Pokhrel

145

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.


81

¿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.

ingrese la descripción de la imagen aquí

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.


35

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].


19

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])

2
Esto devuelve objetos de índice, que pueden o no ser copias del original, lo cual es un desperdicio si simplemente los descarta después de verificar la longitud. A menos que tenga la intención de hacer algo más con el índice, NO LO USE .
cs95

9

... 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]


7

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.

Después de usar Pandas por un tiempo, creo que deberíamos seguir df.shape. Devuelve el número de filas y columnas respectivamente.
Catbuilts

4

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.


Parece inútil querer "canalizar" esta operación porque no hay nada más en lo que pueda canalizar esto (devuelve un número entero). Yo preferiría mucho más count = len(df.reset_index())que count = df.reset_index().pipe(len). El primero es solo una búsqueda de atributos sin la llamada a la función.
cs95

1

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]

0

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

0

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).


0

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.


-2

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.


3
Esta es una buena respuesta, pero ya hay suficientes respuestas a esta pregunta, por lo que esto realmente no agrega nada.
John
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.