查找列之间的数值关系

为了解决您的问题，我强烈建议您对数据进行矢量化，并尽可能少地使用 Pandas 操作，因为需要进行大量操作，因此，我们越依赖 NumPy，代码运行速度就越快（NumPy 的核心是用 C 编写的）。

由于需要考虑多个运算（+，-，*，/），我们需要计算每个结果并将其与 进行比较target_column，但我们可以使用布尔掩码（即NumPy 数组）来提高空间效率，该掩码是以布尔值表示表达式 的列target_column == col1 operation col2。请注意，由于 中可能存在浮点数df，因此实际上最好使用 ，numpy.isclose()以便为浮点运算设置阈值。

您的代码可能类似于以下内容（我在最后添加了一个小示例）：

import numpy as np
import pandas as pd
from itertools import combinations

def detect_relations(df, numeric_cols, float_tolerance=1e-8):
    results = []
    ops = {
        "+": [(lambda x, y: x + y, "a + b")],   # No need to have `b + a` since sum is commutative
        "-": [
            (lambda x, y: x - y, "a - b"),
            (lambda x, y: y - x, "b - a")
        ],
        "*": [(lambda x, y: x * y, "a * b")],   # Same as sum, `a * b = b * a`
        "/": [
            # We need to ensure that we don't divide by 0
            (lambda x, y: np.divide(x, y, out=np.full_like(x, np.nan, dtype=float), where=(y != 0)), "a / b"),
            (lambda x, y: np.divide(y, x, out=np.full_like(x, np.nan, dtype=float), where=(x != 0)), "b / a")
        ],
    }
    # Iterating trough every combination
    for col1, col2 in combinations(numeric_cols, 2):
        a = df[col1].values
        b = df[col2].values
        # Iterating trough each possible operation
        for _, functions in ops.items():
            for func, op_name in functions:
                # Calculating the result of the operation `func` between col1 and col2
                val = func(a, b)
                # Confronting the result of `col1 operation col2` to the other numeric columns (avoiding col1 and col2)
                for target in numeric_cols:
                    if target in (col1, col2):
                        continue
                    c = df[target].values
                    # We get a boolean mask with the comparison between `col1 operation col2` and `target_column`
                    mask = np.isclose(val, c, atol=float_tolerance, equal_nan=False)
                    # Counting how many relations we found
                    matches = int(mask.sum())
                    total = len(df)
                    
                    results.append({
                        "col1": col1,
                        "col2": col2,
                        "operation": op_name,
                        "target": target,
                        "matches": matches,
                        "total": total,
                        "pct_match": matches / total
                    })
                
    return pd.DataFrame(results)


# --- Example---
df = pd.DataFrame({
    "a": [1, 2, 3, 4],
    "b": [2, 2, 2, 2],
    "c": [2, 4, 6, 8],
    "d": [2, 0, 1, 8],
})

numeric_cols = ["a", "b", "c", "d"]
res = detect_relations(df, numeric_cols)
# Avoid to print combinations with no relation
print(res[res["matches"] > 0].sort_values("pct_match", ascending=False))

输出：

   col1 col2 operation target  matches  total  pct_match
6     a    b     a * b      c        4      4       1.00
22    a    c     b / a      b        4      4       1.00
46    b    c     b / a      a        4      4       1.00
7     a    b     a * b      d        2      4       0.50
48    b    d     a + b      a        2      4       0.50
26    a    d     a - b      b        2      4       0.50
58    b    d     b / a      a        2      4       0.50
34    a    d     b / a      b        2      4       0.50
3     a    b     a - b      d        2      4       0.50
5     a    b     b - a      d        1      4       0.25
0     a    b     a + b      c        1      4       0.25
19    a    c     a * b      d        1      4       0.25
18    a    c     a * b      b        1      4       0.25
16    a    c     b - a      b        1      4       0.25
11    a    b     b / a      d        1      4       0.25
10    a    b     b / a      c        1      4       0.25
30    a    d     a * b      b        1      4       0.25
24    a    d     a + b      b        1      4       0.25
23    a    c     b / a      d        1      4       0.25
40    b    c     b - a      a        1      4       0.25
35    a    d     b / a      c        1      4       0.25
31    a    d     a * b      c        1      4       0.25
44    b    c     a / b      a        1      4       0.25
50    b    d     a - b      a        1      4       0.25
56    b    d     a / b      a        1      4       0.25
68    c    d     a / b      a        1      4       0.25
70    c    d     b / a      a        1      4       0.25

复杂性分析

我想指出的是，上面的代码有一定的时间复杂度，当元素数量很大时可能会很慢。

上面的代码必须经过多次循环：

• 通过的每一个组合numerical_cols，即(m choose 2) = m(m-1)/2 ~ O(m^2)；
• 尽一切可能target，即O(m - 2) = O(m)；
• numpy.isclose()通过循环遍历每个元素进行的比较n，因此其复杂度为O(n)。

考虑到这些周期，很容易看出代码的时间复杂度为O(m^2 * m * n) = O(n * m^3)，因此所需时间将相对于数值列的数量呈立方增加，并且相对于每列中的元素数量呈线性增加。