使用多变量条件比较数据框

Question

I am having troubles using merge to find out the value of a column. I have two data frames:

df Conditions

A  |  B  |  C  |  D  |  E  | F |
A1 | B1  |     |     |     | F1|
A2 | B2  |     |     |     | F2|
A3 | B3  |     |  D3 |     | F3|
A4 | B4  |     |  D4 |  E4 | F4|

df Result

A  |  B  |  C  |  D  |  E  | G  | H  | 
A1 | B1  |  C1 |  D1 |  E1 | G1 | H1 |
A2 | B2  |  C2 |  D2 |  E2 | G2 | H2 |
A3 | B3  |  C3 |  D3 |  E3 | G3 | H3 |
A4 | B4  |  C4 |  D4 |  E4 | G4 | H4 |

The Column F has the parameter value to be include with merge(), as result I want the df Result

I'm using the code:

df Result = pd.merge(df Result, df Conditions[[A,B,C,D,E,F]], on = [A,B,C,D,E], how = 'left')

Currently, the result is getting only the F column that has the most number of conditions, but doesn't evaluate every condition.

A  |  B  |  C  |  D  |  E  | G  | H  | F |
A1 | B1  |  C1 |  D1 |  E1 | G1 | H1 |   |
A2 | B2  |  C2 |  D2 |  E2 | G2 | H2 |   |
A3 | B3  |  C3 |  D3 |  E3 | G3 | H3 |   |
A4 | B4  |  C4 |  D4 |  E4 | G4 | H4 | F4|

How can I do this?

Answer 1

I think of a way make use of multiple df.update() with merge. Basic idea is to create multiple wildcards dataframe to the None values on different columns

df_Conditions = pd.DataFrame(columns=['A', 'B', 'C', 'D', 'E', 'F'],
                             data=[['A1', 'B1', None, None, None, 'F1'],
                                   ['A2', 'B2', None, None, None, 'F2'],
                                   ['A3', 'B3', None, 'D3', None, 'F3'],
                                   ['A4', 'B4', None, 'D4', 'E4', 'F4'],
                                   ])

df_Result = pd.DataFrame(columns=['A', 'B', 'C', 'D', 'E', 'G', 'H'],
                         data=[['A1', 'B1', 'C1', 'D1', 'E1', 'G1', 'H1'],
                               ['A2', 'B2', 'C2', 'D2', 'E2', 'G2', 'H2'],
                               ['A3', 'B3', 'C3', 'D3', 'E3', 'G3', 'H3'],
                               ['A4', 'B4', 'C4', 'D4', 'E4', 'G4', 'H4'],
                               ])

First merge as what you did, it should gives you an extra empty column F

res = pd.merge(df_Result, df_Conditions, on=['A', 'B', 'C', 'D', 'E'], how='left')
res
Out[8]: 
    A   B   C   D   E   G   H    F
0  A1  B1  C1  D1  E1  G1  H1  NaN
1  A2  B2  C2  D2  E2  G2  H2  NaN
2  A3  B3  C3  D3  E3  G3  H3  NaN
3  A4  B4  C4  D4  E4  G4  H4  NaN

Create a wildcard dataframe as a sub-dataframe of df_Conditions

wildcards_C = df_Conditions[df_Conditions['C'].isnull()].dropna(axis=1, how='all')
wildcards_C
Out[10]: 
    A   B     D     E   F
0  A1  B1  None  None  F1
1  A2  B2  None  None  F2
2  A3  B3    D3  None  F3
3  A4  B4    D4    E4  F4

Merge it with df_Result and update the values on res

res.update(df_Result.merge(wildcards_C, how='left'), overwrite=False)
res
Out[12]: 
    A   B   C   D   E   G   H    F
0  A1  B1  C1  D1  E1  G1  H1  NaN
1  A2  B2  C2  D2  E2  G2  H2  NaN
2  A3  B3  C3  D3  E3  G3  H3  NaN
3  A4  B4  C4  D4  E4  G4  H4   F4

It would update the columns F on res dataframe when values on columns A, B, D, E are matched. Repeat the same with conditions column E

wildcards_E = df_Conditions[df_Conditions['E'].isnull()].dropna(axis=1, how='all')
res.update(df_Result.merge(wildcards_E, how='left'), overwrite=False)
res
Out[6]: 
    A   B   C   D   E   G   H    F
0  A1  B1  C1  D1  E1  G1  H1  NaN
1  A2  B2  C2  D2  E2  G2  H2  NaN
2  A3  B3  C3  D3  E3  G3  H3   F3
3  A4  B4  C4  D4  E4  G4  H4   F4

Finally repeat the same with conditions column D

wildcards_D = df_Conditions[df_Conditions['D'].isnull()].dropna(axis=1, how='all')
res.update(df_Result.merge(wildcards_D, how='left'), overwrite=False)
res
Out[6]: 
    A   B   C   D   E   G   H   F
0  A1  B1  C1  D1  E1  G1  H1  F1
1  A2  B2  C2  D2  E2  G2  H2  F2
2  A3  B3  C3  D3  E3  G3  H3  F3
3  A4  B4  C4  D4  E4  G4  H4  F4

For demonstration purpose, I did not group the repetitions in a loop.

One drawback here is you have to analyze the order of "wildcard" yourself, current tactics: keep the column with least wildcards (ie column D) as long as possible.