Ответ 1

Вы можете использовать свойство .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 исключает NaN s,

Ответ 2

Предположим, что 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

Ответ 3

Используйте len(df). Это работает как pandas 0,11 или, возможно, даже раньше.

__len__() в настоящее время (0.12) документирован с помощью Returns length of index. Информация о времени, настроенная так же, как в корневом ответе:

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) напрямую, но это не должно играть никакой роли в большинстве случаев использования.

Ответ 4

len() - ваш друг, краткий ответ для количества строк - len(df).

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

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

Ответ 5

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

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

Ответ 6

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

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

Сноски

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

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

Из трех приведенных выше методов самым быстрым является 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) является более быстрым из двух методов (но для его ввода требуется больше символов).

s.size в серии: 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 DataFrame.count: DataFrame.count и Series.count

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

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

df.count()

A    5
B    3
dtype: int64

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

s.count()
# 3

GroupBy.size: 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.count, а не GroupBy.size. Обратите внимание, что size всегда возвращает Series, а count возвращает Series если DataFrame для определенного столбца или для 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

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

Ответ 7

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

число столбцов:

len(df.columns)  
## Here:
#df is your data.frame
#df.columns return a string, it contains column titles of the df. 
#Then, "len()" gets the length of it.

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

len(df.index) #It similar.

Ответ 8

Количество строк (используйте любой):

df.shape[0]
len(df)

Ответ 9

df.shape возвращает форму кадра данных в виде кортежа (количество строк, число столбцов).

Вы можете просто открыть no. строк или нет. из cols с df.shape[0] или df.shape[1], соответственно, что равнозначно доступу к значениям кортежа.

Ответ 10

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

Причина, по которой 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]

Ответ 11

вы можете попробовать:

total_rows = len(df)

Ответ 12

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

df.pipe(len)

Пример:

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

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

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

Ответ 13

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

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

Пример:

nrow(my_df)
12,456,789