我的数据框包含数百列。幸运的是，可以将它们分为具有常规列名称的两个大组。组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并根据规则填充它们）？
感谢您关注我的问题。
最佳答案
根据给定的命名约定，确保对列进行排序并使用.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逻辑，只考虑计算我们将为所有内容填充的内容。 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是对齐的，因此我们可以安全地划分每一列，这意味着可以访问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中使用不为空的值，否则使用计算中的值”，这正是我们想要的。同样，我们需要为
.values的“ other”（第二个参数）访问where，因为列名也不相同，但是值是对齐的。分别对每个组执行此操作，然后将其重新加入。
关于python - 通过检测NaN的出现位置，通过其他列的数学运算将NaN填充到一列中，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/54830897/