Question

我有一个看起来像这样的数据框

pd.DataFrame({'a':['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
              'b':['N', 'Y', 'Y', 'N', 'Y', 'N', 'Y', 'N', 'N', 'Y'],
              'c':[4, 5, 9, 8, 1, 3, 7, 2, 6, 10]})

   a  b   c
0  A  N   4
1  B  Y   5
2  C  Y   9
3  D  N   8
4  E  Y   1
5  F  N   3
6  G  Y   7
7  H  N   2
8  I  N   6
9  J  Y  10

我要根据以下条件从10行中选择5行：

列“ c”是我的排名列。

选择排名最低的2行（选择第4行和第7行）
选择列“ b” =“ Y”且排名<= 5（已选择第1行）的所有行
如果使用上述标准选择的行数少于5行，则剩余的未结头寸应按排名顺序（最低）填充，其中'b'='Y'并且排名<= 7（选择第6行））
如果少于5行通过了前3个条件，则按排名顺序（最低）填充剩余位置，其中'b'='N'

我已经尝试过了（涵盖了规则1和2），但一直在努力从那里继续前进

df['selected'] = ''
df.loc[(df.c <= 2), 'selected'] = 'rule_1'
df.loc[((df.c <= 5) & (df.b == 'Y')), 'selected'] = 'rule_2'

我得到的数据框应该看起来像这样

   a  b   c  selected
0  A  N   4     False
1  B  Y   5     rule_2
2  C  Y   9     False
3  D  N   8     rule_4
4  E  Y   1     rule_1
5  F  N   3     False
6  G  Y   7     rule_3
7  H  N   2     rule_1
8  I  N   6     False
9  J  Y  10     False

基于以下Vinod Karantothu提供的解决方案，我进行了以下工作：

def solution(df):

    def sol(df, b='Y'):
        result_df_rule1 = df.sort_values('c')[:2]
        result_df_rule1['action'] = 'rule_1'
        result_df_rule2 = df.sort_values('c')[2:].loc[df['b'] == b].loc[df['c'] <= 5]
        result_df_rule2['action'] = 'rule_2'
        result = pd.concat([result_df_rule1, result_df_rule2]).head(5)

        if len(result) < 5:
            remaining_rows = pd.concat([df, result, result]).drop_duplicates(subset='a', keep=False)
            result_df_rule3 = remaining_rows.loc[df['b'] == b].loc[df['c'] <= 7]
            result_df_rule3['action'] = 'rule_3'
            result = pd.concat([result, result_df_rule3]).head(5)
            return result, pd.concat([remaining_rows, result, result]).drop_duplicates(subset='a', keep=False)

    result, remaining_data = sol(df)

    if len(result) < 5:
        result1, remaining_data = sol(remaining_data, 'N')
        result1['action'] = 'rule_4'
        result = pd.concat([result, result1]).head(5).drop_duplicates(subset='a', keep=False).merge(df, how='outer', on='a')

    return result

if __name__ == '__main__':
df = pd.DataFrame({'a': ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
                   'b': ['N', 'Y', 'Y', 'N', 'Y', 'N', 'Y', 'N', 'N', 'Y'],
                   'c': [4, 5, 9, 8, 1, 3, 7, 2, 6, 10]})

    result = solution(df)
    print(result)

Answer 1

import pandas as pd

def solution(df):

    def sol(df, b='Y'):
        result_df_rule1 = df.sort_values('c')[:2]
        result_df_rule2 = df.sort_values('c')[2:].loc[df['b'] == b].loc[df['c'] <= 5]
        result = pd.concat([result_df_rule1, result_df_rule2]).head(5)

        if len(result) < 5:
            remaining_rows = pd.concat([df, result, result]).drop_duplicates(keep=False)
            result_df_rule3 = remaining_rows.loc[df['b'] == b].loc[df['c'] <= 7]
            result = pd.concat([result, result_df_rule3]).head(5)
            return result, pd.concat([remaining_rows, result, result]).drop_duplicates(keep=False)

    result, remaining_data = sol(df)

    if len(result) < 5:
        result1, remaining_data = sol(remaining_data, 'N')
        result = pd.concat([result, result1]).head(5)

    return result

if __name__ == '__main__':
    df = pd.DataFrame({'a':['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
              'b':['N', 'Y', 'Y', 'N', 'Y', 'N', 'Y', 'N', 'N', 'Y'],
              'c':[4, 5, 9, 8, 1, 3, 7, 2, 6, 10]})
    
    result = solution(df)
    print(result)

结果：

Answer 2

对于您的第4条规则，您已经在结果数据框中提到了 ROW_INDEX 3 ，但其排名为 8 并非最低， ROW_INDEX 5 应该符合您给出的规则：

import pandas as pd
data = pd.DataFrame({'a':['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
          'b':['N', 'Y', 'Y', 'N', 'Y', 'N', 'Y', 'N', 'N', 'Y'],
          'c':[4, 5, 9, 8, 1, 3, 7, 2, 6, 10]})

data1 = data.nsmallest(2, ['c'])
dataX = data.drop(data1.index)

data2 = dataX[((dataX.b == "Y") & (dataX.c<=5))] 
dataX = dataX.drop(data2.index) 

data3 = dataX[((dataX.b == "Y") & (dataX.c<=7))]  
dataX = dataX.drop(data3.index) 

data4 = dataX[((dataX.b == "N"))]
data4 = data4.nsmallest(1, ['c'])

resultframes = [data1, data2, data3, data4]
resultfinal = pd.concat(resultframes)
print(resultfinal)

这是输出：

Answer 3

您可以为规则创建额外的列，然后进行排序并取首。 IIUC从评论中得知，规则3已经涵盖了规则2，因此无需单独进行计算。

df['r1'] = df.c < 3
df['r3'] = (df.c <= 7) & (df.b == 'Y')
print(df.sort_values(['r1', 'r3', 'c'], ascending=[False, False, True])[['a', 'b', 'c']].head(5))

   a  b  c
4  E  Y  1
7  H  N  2
1  B  Y  5
6  G  Y  7
5  F  N  3

对布尔列进行排序是因为True > False。

注意：您可能需要使用不同的数据集来调整代码以达到您的期望。例如，您的最后一行9 J Y 10当前未被任何规则覆盖。您可以采用这种方法，并在需要时进行扩展。

大熊猫：使用循环根据列排名选择一定数量的行

3 个答案: