在 pandas DataFrame 中查找（仅）满足给定条件的第一行

Question

我有一个数据框df，其中有一列很长的随机正整数：

df = pd.DataFrame({'n': np.random.randint(1, 10, size = 10000)})

我想确定列中第一个偶数的索引。一种方法是：

df[df.n % 2 == 0].iloc[0]

但这涉及很多操作（生成索引f.n % 2 == 0，在这些索引上评估df，最后取第一项）并且非常慢。这样的循环要快得多：

for j in range(len(df)):
    if df.n.iloc[j] % 2 == 0:
        break

还因为第一个结果可能在前几行。有没有类似性能的熊猫方法？谢谢。

注意：此条件（为偶数）只是一个示例。 我正在寻找一种适用于值的任何类型条件的解决方案，即，一种快速的单行替代方案：

df[ conditions on df.n ].iloc[0]

Answer 1

TLDR：您可以使用next(j for j in range(len(df)) if df.at[j, "n"] % 2 == 0)

---

我认为完全有可能在 oneliner 中编写代码。让我们定义一个 DataFrame 来证明这一点：

df = pd.DataFrame({'n': np.random.randint(1, 10, size = 100000)})

首先，您的代码给出：

for j in range(len(df)):
    if df.n.iloc[j] % 2 == 0:
        break
% 22.1 µs ± 1.5 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

将其转换为 oneliner 给出：

next(j for j in range(len(df)) if df["n"].iloc[j] % 2 == 0)
% 20.6 µs ± 1.26 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)

为了进一步加快计算速度，我们可以使用at而不是iloc，因为这在访问单个值时更快：

next(j for j in range(len(df)) if df.at[j, "n"] % 2 == 0)
% 8.88 µs ± 617 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Answer 2

让您迭代行并在满意时停止的选项是使用 DataFrame.iterrows，是 pandas 的行迭代器。

在这种情况下，您可以像这样实现它：

def get_first_row_with(condition, df):
    for index, row in df.iterrows():
        if condition(row):
            return index, row
    return None # Condition not met on any row in entire DataFrame

然后，给定一个DataFrame，例如：

df = pd.DataFrame({
                    'cats': [1,2,3,4], 
                    'dogs': [2,4,6,8]
                  }, 
                  index=['Alice', 'Bob', 'Charlie', 'Eve'])

你可以用作：

def some_condition(row):
    return row.cats + row.dogs >= 7

index, row = get_first_row_with(some_condition, df)

# Use results however you like, e.g.:
print('{} is the first person to have at least 7 pets.'.format(index))
print('They have {} cats and {} dogs!'.format(row.cats, row.dogs))

哪个会输出：

Charlie is the first person to have at least 7 pets.
They have 3 cats and 6 dogs!

Answer 3

Zip 索引和列，然后循环它们以获得更快的循环速度。 Zip 提供最快的循环性能，比iterrows() 或itertuples() 更快。

for j in zip(df.index,df.n):
        if j[1] % 2 == 0:
                index_position = j[0]
                break

Answer 4

为了好玩，我决定尝试几种可能性。我拿了一个数据框：

MAX = 10**7
df = pd.DataFrame({'n': range(MAX)})

（这次不是随机的。）我想找到n >= N 的第一行，其中某个值为N。我已经计时了以下四个版本：

def getfirst_pandas(condition, df):
    return df[condition(df)].iloc[0]

def getfirst_iterrows_loop(condition, df):
    for index, row in df.iterrows():
        if condition(row):
            return index, row
    return None

def getfirst_for_loop(condition, df):
    for j in range(len(df)):
        if condition(df.iloc[j]):
            break
    return j

def getfirst_numpy_argmax(condition, df):
    array = df.as_matrix()
    imax  = np.argmax(condition(array))
    return df.index[imax]

N = 十的幂。当然，numpy（优化的 C）代码预计会比 python 中的for 循环更快，但我想看看N python 循环的哪些值仍然可以。

我计时了：

getfirst_pandas(lambda x: x.n >= N, df)
getfirst_iterrows_loop(lambda x: x.n >= N, df)
getfirst_for_loop(lambda x: x.n >= N, df)
getfirst_numpy_argmax(lambda x: x >= N, df.n)

为N = 1, 10, 100, 1000, ...。这是性能的对数图：

PICTURE

简单的for 循环是可以的，只要“第一个真实位置”预计在开头，但随后就变坏了。 np.argmax 是最安全的解决方案。

从图中可以看出，pandas 和 argmax 的时间保持（几乎）不变，因为它们总是扫描整个数组。最好有一个 np 或 pandas 方法，但没有。

Answer 5

做了一些时间安排，是的，使用生成器通常会给你更快的结果

df = pd.DataFrame({'n': np.random.randint(1, 10, size = 10000)})

%timeit df[df.n % 2 == 0].iloc[0]
%timeit df.iloc[next(k for k,v in df.iterrows() if v.n % 2 == 0)]
%timeit df.iloc[next(t[0] for t in df.itertuples() if t.n % 2 == 0)]

我明白了：

1000 loops, best of 3: 1.09 ms per loop
1000 loops, best of 3: 619 µs per loop # <-- iterrows generator
1000 loops, best of 3: 1.1 ms per loop
10000 loops, best of 3: 25 µs per loop # <--- your solution

但是当你放大它时：

df = pd.DataFrame({'n': np.random.randint(1, 10, size = 1000000)})

差异消失：

10 loops, best of 3: 40.5 ms per loop 
10 loops, best of 3: 40.7 ms per loop # <--- iterrows
10 loops, best of 3: 56.9 ms per loop

您的解决方案是最快的，为什么不使用它呢？

for j in range(len(df)):
    if df.n.iloc[j] % 2 == 0:
        break