通过检测NAN发生的位置，通过数学操作在列中填充NAN

Question

我的dataframe包含数百列。幸运的是，它们可以分为两个带有常规列名称的大组。第1组包含列PDC，PDC.1，PDC.2 .... PDC.250。第2组由PAC，Pac.1。，Pac.2 .... Pac.250组成。请注意，每个组的第一列没有后缀号码。

我想使用以下规则来填补所有NAN，无论他们身在何处：
从组1（目标列和行）的任何一行中的NAN中，将在第2组中的列中填充值相同的订单（源列和行）乘以目标列的平均值除以平均值源列的。

使其简单，例如，如果NAN在PDC.25第10行（第1组）中，则应通过：
填充。PDC.25行10 = PAC.25行10 *（平均PDC.25/均值PAC.25）

如果NAN在第2组中，则是公式：
PAC.30行15 = PDC.30第15 *（平均PAC.30/平均PDC.30）

我编写以下代码：

df['Pdc.25'] = (df['Pdc.25'].fillna(df['Pac.25']*((df['Pdc.25'].mean()/df['Pac.25'].mean())))).to_frame()
df['Pac.30'] = (df['Pac.30'].fillna(df['Pdc.30']*((df['Pac.30'].mean()/df['Pdc.30'].mean())))).to_frame()

上面的代码正常工作，但是对于500列，我必须编写500行等式。

例如，通过自动找到NAN并根据规则填充NAN的任何想法？

感谢您查看我的问题。

Answer 1

确保对列进行排序，并使用 .values对准操作，鉴于您的命名约定。可以使用.where填充所有内容。如果您想在缺少列的情况下更安全（即您有PAC.31但没有PDC.31），则可以映射操作的列名，以保证对齐。

import pandas as pd
#df = df.sort_index(axis=1)
pac = df.filter(like='Pac')
pdc = df.filter(like='Pdc')
df_res = pd.concat([pac.where(pac.notnull(), pdc.multiply(pac.mean().div(pdc.mean().values).values).values),
                    pdc.where(pdc.notnull(), pac.multiply(pdc.mean().div(pac.mean().values).values).values)
                    ], axis=1)

输出df_res：

        Pac  Pac.1     Pac.2       Pdc     Pdc.1  Pdc.2
0  1.000000    6.0  3.000000  1.285714  4.952381    2.0
1  1.555556    1.0  2.000000  2.000000  2.000000    1.0
2  7.000000    6.0  3.714286  7.000000  4.952381    3.0
3  6.000000    7.0  5.000000  5.000000  5.000000    7.0
4  5.000000    2.0  3.714286  6.000000  1.650794    3.0
5  2.000000    7.0  4.000000  7.000000  5.000000    1.0
6  3.000000    4.0  3.000000  4.000000  1.000000    1.0
7  1.000000    5.0  3.000000  1.285714  7.000000    3.0
8  5.000000    5.0  6.000000  4.000000  5.000000    6.0
9  5.000000    2.0  3.714286  6.428571  1.000000    3.0

样本数据

import numpy as np
df = pd.DataFrame(np.random.choice([1,2,3,4,5,6,7, np.NaN], (10,6)),
                  columns = ['Pdc', 'Pdc.1', 'Pdc.2', 'Pac', 'Pac.1', 'Pac.2'])
   Pdc  Pdc.1  Pdc.2  Pac  Pac.1  Pac.2
0  NaN    NaN    2.0  1.0    6.0    3.0
1  2.0    2.0    1.0  NaN    1.0    2.0
2  7.0    NaN    3.0  7.0    6.0    NaN
3  5.0    5.0    7.0  6.0    7.0    5.0
4  6.0    NaN    3.0  5.0    2.0    NaN
5  7.0    5.0    1.0  2.0    7.0    4.0
6  4.0    1.0    1.0  3.0    4.0    3.0
7  NaN    7.0    3.0  1.0    5.0    3.0
8  4.0    5.0    6.0  5.0    5.0    6.0
9  NaN    1.0    3.0  5.0    2.0    NaN

---

说明：

第一步是对列进行排序，然后过滤寻找以字符串'Pac'或'Pdc'开头的列。由于我们对索引进行了排序，因此保证订购是一致的（只要组中的后缀集相同）

df = df.sort_index(axis=1)
pac = df.filter(like='Pac')
pdc = df.filter(like='Pdc')
print(pac.head(3))
#   Pac  Pac.1  Pac.2
#0  1.0    6.0    3.0
#1  NaN    1.0    2.0
#2  7.0    6.0    NaN
print(pdc.head(3))
#   Pdc  Pdc.1  Pdc.2
#0  NaN    NaN    2.0
#1  2.0    2.0    1.0
#2  7.0    NaN    3.0

现在我们可以做数学。忽略.fillna逻辑，只需考虑计算我们将填充的内容> everything 即可。DataFrame操作在索引上对齐（行和列）。您可以看到pac和pdc共享行索引，但是列索引（列名）不同，这会导致问题：

pac.mean()
#Pac      3.888889
#Pac.1    4.500000
#Pac.2    3.714286
#dtype: float64
pdc.mean()
#Pdc      5.000000
#Pdc.1    3.714286
#Pdc.2    3.000000
#dtype: float64
pac.mean().div(pdc.mean())
#Pac     NaN
#Pac.1   NaN
#Pac.2   NaN
#Pdc     NaN
#Pdc.1   NaN
#Pdc.2   NaN

但是，由于我们以前已经排序，因此我们可以看到values对齐，因此我们安全地将每个列分开意味着访问值数组。这给出了每个Pac列的平均值除以相应的Pdc列的平均值。

pac.mean().div(pdc.mean().values)
#Pac      0.777778
#Pac.1    1.211538
#Pac.2    1.238095
#dtype: float64

乘法存在相同的对齐问题，因此再次访问值，现在这给我们一个DataFrame，与子集相同的形状，如果值为null，则应填写的内容：

pdc.multiply(pac.mean().div(pdc.mean().values).values)
#        Pdc     Pdc.1     Pdc.2
#0       NaN       NaN  2.476190
#1  1.555556  2.423077  1.238095
#...

最后，fillna逻辑是用where完成的，因为我们有两个DataFrames：

pac.where(pac.notnull(), pdc.multiply(pac.mean().div(pdc.mean().values).values).values)

可以读取为"使用pAC中的值不为null，否则使用计算中的值"，这正是我们想要的。同样，我们需要访问 where的"其他"（第二个参数）的.values，因为列名再次不相同，但值是对齐的。

单独为每个组做这个，然后加入它们。