Я пытаюсь получить количество строк в df с помощью Pandas, и вот мой код.

Способ 1:

total_rows = df.count
print total_rows +1

Способ 2:

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

Оба фрагмента кода дают мне эту ошибку:

Ошибка типа: неподдерживаемые типы операндов для +: 'instancemethod' и 'int'

Что я делаю неправильно?

Вы можете использовать .shapeсобственность или просто len(DataFrame.index). Тем не менее, есть заметные различия в производительности ( len(DataFrame.index)самые быстрые):

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)

РЕДАКТИРОВАТЬ: Как @Dan Аллен отметил в комментариях len(df.index)и df[0].count()не являются взаимозаменяемыми, за countисключением NaNs,

Предположим, dfчто ваш фрейм данных:

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

Или, более кратко,

r, c = df.shape

Использование len(df). Это работает с пандами 0.11 или, может быть, даже раньше.

__len__()в настоящее время (0.12) задокументировано с Returns length of index. Информация о времени, настраивается так же, как в ответе 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

Из-за одного дополнительного вызова функции он немного медленнее, чем len(df.index)прямой вызов , но в большинстве случаев это не должно играть никакой роли.

Как я могу получить количество строк в DataFrame панд?

Эта таблица суммирует различные ситуации, в которых вы хотите подсчитать что-либо в DataFrame (или Series, для полноты), а также рекомендуемые методы.

Сноски

1. DataFrame.countвозвращает счетчики для каждого столбца как, Seriesпоскольку ненулевое значение зависит от столбца.
2. DataFrameGroupBy.sizeвозвращает a Series, поскольку все столбцы в одной группе имеют одинаковое количество строк.
3. DataFrameGroupBy.countвозвращает a DataFrame, поскольку ненулевое число может отличаться для разных столбцов в одной группе. Чтобы получить групповой ненулевой счетчик для определенного столбца, используйте df.groupby(...)['x'].count()где «x» - столбец для подсчета.

Примеры минимального кода

Ниже я показываю примеры каждого из методов, описанных в таблице выше. Во-первых, установка -

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

Ряд Граф в DataFrame: len(df), df.shape[0]илиlen(df.index)

len(df)
# 5

df.shape[0]
# 5

len(df.index)
# 5

Глупо сравнивать производительность операций с постоянным временем, особенно когда разница находится на уровне «серьезно, не беспокойтесь об этом». Но это похоже на тенденцию с другими ответами, поэтому я делаю то же самое для полноты.

Из 3 описанных выше методов len(df.index)(как уже упоминалось в других ответах) самый быстрый.

Запись

• Все описанные выше методы являются операциями с постоянным временем, поскольку они являются простыми поисками атрибутов.
• df.shape(аналогично ndarray.shape) является атрибутом, который возвращает кортеж (# Rows, # Cols). Например, df.shapeвозвращает (8, 2)для примера здесь.

Колонка графа из DataFrame: df.shape[1],len(df.columns)

df.shape[1]
# 2

len(df.columns)
# 2

Аналогично len(df.index), len(df.columns)это самый быстрый из двух методов (но для ввода требуется больше символов).

Ряд графа из серии: len(s), s.size,len(s.index)

len(s)
# 5

s.size
# 5

len(s.index)
# 5

s.sizeи len(s.index)примерно одинаковы по скорости. Но я рекомендую len(df).

Примечание
size является атрибутом и возвращает количество элементов (= количество строк для любой серии). DataFrames также определяют атрибут размера, который возвращает тот же результат, что и df.shape[0] * df.shape[1].

Счетчик ненулевых строк: DataFrame.countиSeries.count

Методы, описанные здесь, учитывают только ненулевые значения (то есть NaN игнорируются).

Вызов DataFrame.countбудет возвращать количество не-NaN для каждого столбца:

df.count()

A    5
B    3
dtype: int64

Для серии используйте Series.countаналогичный эффект:

s.count()
# 3

Количество строк по группам: GroupBy.size

Для DataFrames, используйте DataFrameGroupBy.sizeдля подсчета количества строк в группе.

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

A
a    2
b    2
c    1
dtype: int64

Точно так же, для Series, вы будете использовать SeriesGroupBy.size.

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

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

В обоих случаях Seriesвозвращается. Это также имеет смысл, DataFramesпоскольку все группы имеют одинаковое количество строк.

Количество групповых ненулевых строк: GroupBy.count

Похоже на выше, но использовать GroupBy.countне надо GroupBy.size. Обратите внимание, что sizeвсегда возвращает a Series, в то время как countвозвращает Seriesif, если вызывается для определенного столбца, или же a DataFrame.

Следующие методы возвращают одно и то же:

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

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

Между тем, у countнас есть

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

   B
A   
a  2
b  1
c  0

... вызывается для всего объекта GroupBy, v / s,

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

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

Вызывается в определенном столбце.

TL; DR

использование len(df)

len()Ваш друг, он может быть использован для подсчета строк как len(df).

Кроме того, вы можете получить доступ ко всем строкам по df.indexвсем столбцам и по ним df.columns, а также использовать len(anyList)для получения счетчика списка, len(df.index)для получения количества строк и len(df.columns)для столбца.

Или, вы можете использовать , df.shapeкоторый возвращает количество строк и столбцов вместе, если вы хотите получить доступ количество строк только использовать df.shape[0]и для числа столбцов используйте только: df.shape[1].

Помимо вышеупомянутых ответов, использование может использовать, df.axesчтобы получить кортеж с индексами строк и столбцов, а затем использовать len()функцию:

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

... основываясь на ответе Яна-Филиппа Герке.

Причина почему len(df)или len(df.index)быстрее чем df.shape[0]. Посмотри на код. df.shape - это @propertyметод, который запускает метод DataFrame, вызываемый lenдважды.

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)

И под капотом лен (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)будет немного быстрее, чем, len(df)поскольку он имеет на один вызов меньше функции, но это всегда быстрее, чемdf.shape[0]

Я прихожу к пандам из Rфона и вижу, что панды сложнее, когда дело доходит до выбора строки или столбца. Мне пришлось некоторое время с этим бороться, а потом я нашел несколько способов справиться с этим:

получение количества столбцов:

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.

получение количества строк:

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

Если вы хотите получить количество строк в середине цепочечной операции, вы можете использовать:

df.pipe(len)

Пример:

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

Это может быть полезно, если вы не хотите помещать длинную инструкцию в len()функцию.

Вы можете использовать __len__()вместо этого, но __len__()выглядит немного странно.

Эй, вы можете использовать сделать это также:

Позвольте сказать, dfэто ваш dataframe. Затем df.shapeдает вам форму вашего dataframe т.е.(row,col)

Таким образом, назначьте команду ниже, чтобы получить требуемый

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

Для фрейма данных df счетчик строк в формате с запятой используется при исследовании данных:

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

Пример:

nrow(my_df)
12,456,789

Альтернативный метод для определения количества строк в кадре данных, который я думаю, является наиболее читаемым вариантом pandas.Index.size.

Обратите внимание, что, как я прокомментировал принятый ответ:

Подозреваемый pandas.Index.sizeбудет на самом деле быстрее, чем, len(df.index)но timeitна моем компьютере говорит мне иначе (~ 150 нс медленнее за цикл).

Я не уверен, что это сработает (данные МОГУТ быть опущены), но это может сработать:

*dataframe name*.tails(1)

и затем, используя это, вы можете найти количество строк, запустив фрагмент кода и посмотрев номер строки, который вам дали.

Любое из этого может сделать ( dfэто имя DataFrame):

Метод 1: Использование lenфункции:

len(df)даст количество строк в названном DataFrame df.

Способ 2: используя countфункцию:

df[col].count()будет считать количество строк в данном столбце col.

df.count() даст количество строк для всех столбцов.