Estoy tratando de obtener la cantidad de filas de dataframe df con Pandas, y aquí está mi código.
total_rows = df.count print total_rows + 1
total_rows = df['First_column_label'].count print total_rows + 1
Ambos fragmentos de código me dan este error:
TypeError: tipos de operandos no admitidos para +: 'instancemethod' e 'int'
¿Qué estoy haciendo mal?
len(df)
len()
devuelve el número de elementos (la longitud) de un objeto de lista (también funciona para objetos de diccionario, cadena, tupla o rango). Entonces, para obtener el recuento de filas de un DataFrame, simplemente use len(df)
. Para obtener más información sobre la función len , consulte la página oficial .
Alternativamente, puede acceder a todas las filas y todas las columnas con df.index
y df.columns
, respectivamente. Como puede usar len(anyList)
para obtener los números de los elementos, use len(df.index)
para obtener el número de filas y len(df.columns)
para obtener el número de columnas.
O bien, puede usar df.shape
que devuelve el número de filas y columnas juntas (como una tupla). Si desea acceder al número de filas, solo use df.shape[0]
. Para el número de columnas, solo use: df.shape[1]
.
Supongamos que df
es su marco de datos entonces:
count_row = df.shape[0] # Gives number of rows count_col = df.shape[1] # Gives number of columns
O, más sucintamente,
r, c = df.shape
Para un marco de datos df
, se puede usar cualquiera de los siguientes:
len(df.index)
df.shape[0]
df[df.columns[0]].count()
(== número de valores que no son NaN en la primera columna)Código para reproducir la trama:
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", )
Usa len(df)
:-).
__len__()
está documentado con "Devuelve la longitud del índice".
Información de tiempo, configure de la misma manera que en la respuesta 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
Debido a una llamada de función adicional, por supuesto es correcto decir que es un poco más lento que llamar directamente a len(df.index)
. Pero esto no debería importar en la mayoría de los casos. Encuentro que len(df)
es bastante legible.
Llego a Pandas desde un fondo R , y veo que Pandas es más complicado cuando se trata de seleccionar filas o columnas.
Tuve que luchar con eso por un tiempo, y luego encontré algunas formas de lidiar con esto:
Obtener el número de columnas:
len(df.columns) ## Here: # df is your data.frame # df.columns returns a string. It contains column's titles of the df. # Then, "len()" gets the length of it.
Obtener el número de filas:
len(df.index) # It's similar.
Para dataframe df, un recuento de filas con formato de coma impresas que se usa al explorar los datos:
def nrow(df): print("{:,}".format(df.shape[0]))
Ejemplo:
nrow(my_df) 12,456,789
Además de las respuestas anteriores, puede usar df.axes
para obtener la tupla con índices de fila y columna y luego usar la función len()
:
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 una @property
que ejecuta un método DataFrame llamando a len
dos 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 que df.shape[0]
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 quiere poner una declaración larga dentro de una función len()
.
Podría usar __len__()
en su lugar, pero __len__()
se ve un poco raro.
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 ,
Se sospecha que
pandas.Index.size
en realidad sería más rápido quelen(df.index)
perotimeit
en mi computadora me dice lo contrario (~ 150 ns más lento por ciclo).
Cualquiera de estos puede hacerlo ( df
es el nombre del DataFrame):
Método 1 : Usando la función len
:
len(df)
dará el número de filas en un DataFrame llamado df
.
Método 2 : usando la función de count
:
df[col].count()
contará el número de filas en una columna col
dada.
df.count()
dará el número de filas para todas las columnas.
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.
Puedes hacer esto también:
Digamos que df
es su marco de datos. Luego df.shape
le 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]
Piense, el conjunto de datos es "datos" y nombre su conjunto de datos como "data_fr" y el número de filas en data_fr es "nu_rows"
#import the data frame. Extention could be different as csv,xlsx or etc. data_fr = pd.read_csv('data.csv') #print the number of rows nu_rows = data_fr.shape[0] print(nu_rows)