对于 DataFrame ，可以使用以下任何一种：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",
)

使用 ：-）。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)

除了前面的答案之外，您还可以使用以下函数获取带有行和列索引的元组，然后使用以下函数：df.axeslen()

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

假设您的数据帧是：df

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

或者，更简洁地说，

r, c = df.shape

TL的;DR use len（df）

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

---

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

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

我是从 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.

对于数据帧 df，浏览数据时使用的打印逗号格式的行计数：

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

例：

nrow(my_df)
12,456,789

...建立在 Jan-Philip Gehrcke 的回答之上。

原因或比：len(df)len(df.index)df.shape[0]

查看代码。df.shape 是一个运行调用两次的 DataFrame 方法。@propertylen

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]

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

df.pipe(len)

例：

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

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

你可以改用，但看起来有点奇怪。__len__()__len__()

如何获取 Pandas DataFrame 的行数？

下表总结了您希望在 DataFrame（或 Series，为完整起见）中对某些内容进行计数的不同情况，以及推荐的方法。

脚注

1. DataFrame.count将每列的计数作为 A 返回，因为非 null 计数因列而异。Series
2. DataFrameGroupBy.size返回 ，因为同一组中的所有列共享相同的行数。Series
3. DataFrameGroupBy.count返回 a ，因为同一组中的列之间的非 null 计数可能不同。若要获取特定列的组级非 null 计数，请使用其中“x”是要计数的列。DataFramedf.groupby(...)['x'].count()

---

最小代码示例

下面，我展示了上表中描述的每种方法的示例。首先，设置——

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.sizelen(s.index)

len(s)
# 5

s.size
# 5

len(s.index)
# 5

s.size在速度方面大致相同。但我建议.len(s.index)len(df)

Note 是一个属性，它返回元素数 （=count 任何系列的行数）。DataFrames 还定义了一个 size 属性，该属性 返回与 相同的结果。sizedf.shape[0] * df.shape[1]

非 null 行计数：和DataFrame.countSeries.count

此处描述的方法仅计算非 null 值（这意味着忽略 NaN）。

调用 DataFrame.count 将返回每列的非 NaN 计数：

df.count()

A    5
B    3
dtype: int64

对于 Series，请使用 Series.count 达到类似的效果：

s.count()
# 3

按组划分的行计数：GroupBy.size

对于 ，使用 DataFrameGroupBy.size 计算每个组的行数。DataFrames

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

A
a    2
b    2
c    1
dtype: int64

同样，对于 ，您将使用 SeriesGroupBy.size。Series

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

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

在这两种情况下，都返回 a。这也是有道理的，因为所有组共享相同的行数。SeriesDataFrames

按组划分的非 Null 行计数：GroupBy.count

与上面类似，但使用 GroupBy.count，而不是 .请注意，如果对特定列调用，则始终返回 ，而返回 。GroupBy.sizesizeSeriescountSeriesDataFrame

以下方法返回相同的内容：

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

在特定列上调用。

找出数据帧中行数的另一种方法是 pandas，我认为这是最易读的变体。索引大小。

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

怀疑实际上会比但在我的计算机上告诉我的要快（每个循环慢 ~150 ns）。pandas.Index.sizelen(df.index)timeit

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

*dataframe name*.tails(1)

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

其中任何一个都可以做到这一点（ 是 DataFrame 的名称）：df

方法一：使用函数：len

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

方法二：使用函数：count

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

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

您也可以这样做：

假设是您的数据帧。然后给你数据帧的形状，即dfdf.shape(row,col)

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

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

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

使用时，您可能会遇到以下错误：len(df)len(df.index)

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

解决方案：

lengh = df.shape[0]

len（df.index） 将以列出的所有方式中最快的方式工作

对于数据帧：df

当您仍在编写代码时：

1. len(df)
2. 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",
)

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

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

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