Python 按最小-最大kwargs过滤数据帧

我有一个基于用户输入的最小值和最大值的可选kwargs（总共8个）函数

例如

GR\u min，GR\u max，GR\u N\u min，GR\u N\u max，Hi\u min，Hi\u max

等…其中数据帧列为

GR

，

GR\u N

，

Hi

等

我希望dataframe根据给定的最小值和最大值进行过滤，但如果函数调用中未给出一个或多个值，则将默认的最小值最大值设置为列的最小值最大值

例如，一些伪代码：

df = pd.DataFrame({'GR': [1, 2, 3, 4, 2, 3], 
'GR_N': [0.8, 0, 1, 0.6, 0.9, 1], 'Hi':[3, 6, 2, 5, 22, 7]})

让我明白：

    GR  GR_N    Hi
0   1   0.8     3
1   2   0.0     6
2   3   1.0     2
3   4   0.6     5
4   2   0.9     22
5   3   1.0     7

我想要一个函数，它可以执行如下操作：

def picker(data, **kwargs):

      data_filtered = data[data['GR'].between(GR_min, GR_max) &
                         data['GR_N'].between(GR_N_min, GR_N_max) &
                         data['Hi'].between(Hi_min, Hi_max)]

      return data_filtered

import numpy as np
def picker(data, **kwargs):
    d = dict(GR_min=-np.inf, GR_max=np.inf) # ... etc
    kwargs = {**d, **kwargs}
    data_filtered = data[data['GR'].between(kwargs["GR_min"], kwargs["GR_max"])] # ... etc
    return data_filtered

调用后的输出为：

picker(data=df, GR_min=2, GR_max=3, Hi_min=1, Hi_max=6)

    GR  GR_N    Hi
1   2   0.0     6
2   3   1.0     2

除了不显式调用数据帧的每一列之外，我们使用**KWARG本身进行过滤

---

有什么方法可以做到这一点吗？

您可以为您的KWARG设置一个默认字典，将最小值和最大值指定为-infinity和+infinity，然后使用用户输入超越它们。大概是这样的：

def picker(data, **kwargs):

      data_filtered = data[data['GR'].between(GR_min, GR_max) &
                         data['GR_N'].between(GR_N_min, GR_N_max) &
                         data['Hi'].between(Hi_min, Hi_max)]

      return data_filtered

import numpy as np
def picker(data, **kwargs):
    d = dict(GR_min=-np.inf, GR_max=np.inf) # ... etc
    kwargs = {**d, **kwargs}
    data_filtered = data[data['GR'].between(kwargs["GR_min"], kwargs["GR_max"])] # ... etc
    return data_filtered

---

DataFrame.query

在这里很方便，因为它将解析包含条件的字符串。因此，从关键字参数构建条件字符串就足够了

对于

K_min=val

参数，可以将每个单独的条件构建为：

K=val

。要构建列表，每个单独的条件必须用括号（

（）

）括起来，然后用

&

连接起来

代码可以是：

def picker(data, **kwargs):
    def make_cond(k,v):
        if len(k)<5:
            raise(ValueError('Arg too short {}'.format(k)))
        if k.endswith('_min'):
            return '({}>={})'.format(k[:-4], v)
        elif k.endswith('_max'):
            return '({}<={})'.format(k[:-4], v)
        else:
            raise(ValueError('Unknow arg {}'.format(k)))
    strcond='&'.join((make_cond(k, v) for k,v in kwargs.items()))
    # print(strcond)     # uncomment for traces
    return data.query(strcond)

def选择器（数据，**kwargs）：
def生成条件（k，v）：
如果len（k）我对此有点困惑，那么基于列中的最小-最大值进行过滤就根本不会过滤，不是吗？为什么不只是根据提供的参数进行筛选？无论如何，这听起来像是默认参数的例子

#create the DataFrame
df = pd.DataFrame({'GR': [1, 2, 3, 4, 2, 3], 
'GR_N': [0.8, 0, 1, 0.6, 0.9, 1], 'Hi':[3, 6, 2, 5, 22, 7]})

def picker(df, GR_min = None, GR_max = None, GR_N_min = None, GR_N_max = None,
           Hi_min = None, Hi_max = None): #use default arguments

           if GR_min == None:
               GR_min = df['GR'].min()
           if GR_max == None:
               GR_max = df['GR'].max()
           if GR_N_min == None:
               GR_N_min = df['GR_N'].min()
           if GR_N_max == None:
               GR_N_max == df['GR_N'].max()

           #filter the DataFrame with masks
           df_out = df.loc[(df['GR'] > GR_min) & (df['GR'] < GR_max) & 
                           (df['GR_N'] > GR_N_min) & (df['GR_N'] < GR_N_max)]
           return df_out

#创建数据帧
df=pd.DataFrame（{'GR'：[1,2,3,4,2,3]，
‘GR_N’：[0.8,0,1,0.6,0.9,1]，‘Hi’：[3,6,2,5,22,7]}）
def选择器（df，GR_最小值=无，GR_最大值=无，GR_N_最小值=无，GR_N_最大值=无，
Hi_min=None，Hi_max=None）：#使用默认参数
如果GR_min==无：
GR_min=df['GR'].min（）
如果GR_max==无：
GR_max=df['GR'].max（）
如果GR_N_min==无：
GR_N_min=df['GR_N'].min（）
如果GR_N_max==无：
GR_N_max==df['GR_N'].max（）
#使用掩码过滤数据帧
df_out=df.loc[（df['GR']>GR_min）和（df['GR']GR_N_min）和（df['GR_N']
是否有一种方法可以使此默认字典只接受用户指定的值，而不是明确定义所有可能的最小值和最大值？这就是这种方法的结果-默认dict中定义的KWARG只会替换为用户输入的值。因此，如果在没有任何KWARG的情况下运行该函数，它将返回所有数据。这就是您想要的吗？此方法为
.join（（make_cond（k，v））
本身调用函数。它输出“strcond”不存在。@HelloToEarth:复制时出现愚蠢的缩进错误。已修复。