摘要：问题描述：如何获取 pandas 数据框的行数df？解决方案 1：对于数据框df，可以使用以下任一项：len(df.index)df.shape[0]df[df.columns[0]].count()（==第一列中非 NaN 值的数量）重现情节的代码：import numpy as np import pan...

问题描述：

如何获取 pandas 数据框的行数df？

解决方案 1：

对于数据框df，可以使用以下任一项：

len(df.index)
df.shape[0]
df[df.columns[0]].count()（==第一列中非 NaN 值的数量）

表演情节

重现情节的代码：

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",
)

解决方案 2：

假设df您的数据框是：

count_row = df.shape[0]  # Gives number of rows
count_col = df.shape[1]  # Gives number of columns

或者更简洁地说，

r, c = df.shape

解决方案 3：

使用len(df)：-）。

__len__()记录有“返回索引的长度”。

时间信息，设置方式与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)直接调用慢一点当然是正确的。但在大多数情况下这并不重要。我发现len(df)它非常易读。

解决方案 4：

如何获取 Pandas DataFrame 的行数？

下表总结了您想要在 DataFrame（或 Series，为了完整性）中计算某些内容的不同情况，以及推荐的方法。

在此处输入图片描述

脚注
DataFrame.count返回每列的计数，Series因为非空计数因列而异。
DataFrameGroupBy.size返回 a Series，因为同一组中的所有列共享相同的行数。
DataFrameGroupBy.count返回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

比较恒定时间操作的性能似乎很愚蠢，尤其是当差异处于“认真，不用担心”的水平时。但这似乎是其他答案的趋势，所以为了完整性，我也这样做了。

在上述三种方法中，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 还定义了一个 size 属性，它返回的结果与相同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都会返回 a。这也是有意义的DataFrames，因为所有组都共享相同的行数。

按组计算非空行数：`GroupBy.count`

与上面类似，但使用GroupBy.count，而不是GroupBy.size。请注意size总是返回Series，而如果在特定列上调用则count返回Series，否则返回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 对象，而不是，

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

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

在特定列上调用。

解决方案 5：

TL;DR使用`len(df)`

len()返回列表对象的项目数（长度）（也适用于字典、字符串、元组或范围对象）。因此，要获取 DataFrame 的行数，只需使用。有关lenlen(df)函数的更多信息，请参阅官方页面。

df.index或者，您可以分别使用、和访问所有行和所有列df.columns。由于您可以使用len(anyList)来获取元素编号，因此使用
len(df.index)将给出行数，而len(df.columns)使用将给出列数。

或者，您可以使用df.shape它来返回行数和列数（作为元组），您可以使用其索引访问每个项目。如果您想访问行数，请仅使用df.shape[0]。对于列数，请仅使用：df.shape[1]。

解决方案 6：

除了前面的答案之外，您还可以使用df.axes它来获取具有行和列索引的元组，然后使用该len()函数：

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

解决方案 7：

对于数据框df：

当您仍在编写代码时：

len(df)
df.shape[0]

代码完成后速度最快：

len(df.index)

在正常数据大小下，每个选项将在一秒内完成。因此，“最快”选项实际上是让您工作速度最快的选项，len(df)或者df.shape[0]如果您已经有一个子集df并且只想.shape[0]在交互式会话中简要添加。

在最终优化的代码中，最快的运行时间是len(df.index)。

表演情节

df[df.columns[0]].count()在上述讨论中被省略，因为没有评论者指出它有用的情况。它的速度非常慢，而且输入时间很长。它提供了第一列中非 NaN 值的数量。

重现情节的代码：

pip install pandas perfplot

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: len(df),
        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",
)

解决方案 8：

...基于Jan-Philip Gehrcke 的回答。

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)

在 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)会比稍快一些，len(df)因为它少了一个函数调用，但这总是比df.shape[0]

解决方案 9：

我从R背景转到 Pandas ，我发现 Pandas 在选择行或列时更加复杂。

我不得不与之搏斗一段时间，然后我找到了一些解决方法：

获取列数：

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.

获取行数：

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

解决方案 10：

你也可以这样做：

假设df是你的数据框。然后df.shape给出你的数据框的形状，即(row,col)

因此，分配以下命令来获取所需的

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

解决方案 11：

如果你想在链式操作中获取行数，你可以使用：

df.pipe(len)

例子：

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

如果您不想在len()函数中放置长语句，这将很有用。

您也可以使用__len__()它，但__len__()看起来有点奇怪。

解决方案 12：

以下任一方法都可以做到（df是 DataFrame 的名称）：

方法 1：使用len函数：

len(df)将给出名为的 DataFrame 中的行数df。

方法 2：使用count函数：

df[col].count()将计算给定列中的行数col。

df.count()将给出所有列的行数。

解决方案 13：

对于数据框 df，探索数据时使用的打印逗号格式的行数：

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

例子：

nrow(my_df)
12,456,789

解决方案 14：

使用时len(df)可能len(df.index)会遇到此错误：

----> 4 df['id'] = np.arange(len(df.index)
TypeError: 'int' object is not callable

解决方案：

lengh = df.shape[0]

解决方案 15：

df.index.stop将返回最后一个索引，如果步长为 1，则表示行数。

df.index.size将返回总行数。

您可以使用其中任一个，但最好使用后者。

解决方案 16：

len(df)对于大型数据框来说是最简单且最快的df。

import time
import numpy as np
import pandas as pd

a = np.zeros(3*10**9)
b = np.zeros(3*10**9)
a[100:300] = 2
b[100:210] = 1
df = pd.DataFrame({'a':pd.arrays.SparseArray(a, fill_value=0), 'b':pd.arrays.SparseArray(b, fill_value=0)})

start = time.time()
row_count = len(df.index)
end = time.time()
print("len(df.index) takes: " +str(end-start)+ " seconds")
start = time.time()
row_count = df.shape[0]
end = time.time()
print("df.shape[0] takes: " +str(end-start)+ " seconds")
start = time.time()
row_count = len(df)
end = time.time()
print("len(df) takes: " +str(end-start)+ " seconds")

输出：

len(df.index) takes: 0.00010704994201660156 seconds
df.shape[0] takes: 0.00010991096496582031 seconds
len(df) takes: 7.677078247070312e-05 seconds

解决方案 17：

我认为找出数据框中行数的另一种方法是最具可读性的变体pandas.Index.size。

请注意，正如我对已接受的答案所评论的那样，

怀疑pandas.Index.size实际上会比len(df.index)但timeit我的电脑告诉我相反（每个循环慢约 150 纳秒）。

解决方案 18：

我不确定这是否可行（可以省略数据），但这可能会有效：

*dataframe name*.tails(1)

然后使用它，您可以通过运行代码片段并查看给您的行号来找到行数。

解决方案 19：

len(df.index) 是所有列出的方法中最快的

解决方案 20：

想想看，数据集是“数据”，并将数据集命名为“data_fr”，data_fr 中的行数是“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)