您也可以这样做：

假设df是您的数据帧。然后df.shape为您提供数据帧的形状，即（行，列）

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

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

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

长度（df.索引）df.形状[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）非常可读。

…建立在Jan Philip Gehrcke的答案之上。

len（df）或len（df.index）比df.shape[0]更快的原因是：

看看代码。df.shape是一个@属性，它运行两次调用len的DataFrame方法。

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]快

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

*dataframe name*.tails(1)

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

如何获取Pandas DataFrame的行计数？

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

脚注DataFrame.count将每个列的计数作为一个系列返回，因为非空计数因列而异。DataFrameGroupBy.size返回一个系列，因为同一组中的所有列共享相同的行计数。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是一个属性，它返回元素的数量（=count任何系列的行数）。DataFrames还定义了一个大小属性返回与df.shape[0]*df.shape[1]相同的结果。

非空行计数：DataFrame.Count和Series.Count

这里描述的方法只计算非空值（意味着忽略NaN）。

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

df.count()

A    5
B    3
dtype: int64

对于“系列”，请使用“系列计数”以产生类似效果：

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始终返回一个Series，而count如果在特定列上调用，则返回一个Serial，否则返回一个DataFrame。

以下方法返回相同的结果：

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

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

同时，伯爵，我们有

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

在特定列上调用。