Question

我有一个DataFrame，其中某些商品的价格范围：

   price_low  price_high item
0         10          20    a
1          1           7    b
2         10          12    c
3         20          25    d
4          4           8    e
5          5          30    f
6         16          26    g

如何确定哪些商品在给定的价格范围内重叠（例如$ 8-$ 16）？

预期输出：

   price_low  price_high item
0         10          20    a
2         10          12    c
4          4           8    e
5          5          30    f
6         16          26    g

Answer 1

从熊猫0.24.0开始，您可以使用IntervalArray.overlaps方法，也可以使用IntervalIndex.overlaps方法：

# construct the IntervalArray
price_ivs = pd.arrays.IntervalArray.from_arrays(df['price_low'], df['price_high'], closed='both')

# define desired price Interval and use the overlaps method to restrict df
my_price = pd.Interval(8, 16, closed='both')
df = df[price_ivs.overlaps(my_price)]

对于交互式演示，首先构造示例数据：

In [1]: import pandas as pd; pd.__version__
Out[1]: '0.24.0rc1'

In [2]: df = pd.DataFrame({
   ...:     'price_low': [10, 1, 10, 20, 4, 5, 16],
   ...:     'price_high': [20, 7, 12, 25, 8, 30, 26],
   ...:     'item': list('abcdefg')
   ...: })

In [3]: df
Out[3]: 
   price_low  price_high item
0         10          20    a
1          1           7    b
2         10          12    c
3         20          25    d
4          4           8    e
5          5          30    f
6         16          26    g

从IntervalArray构造一个DataFrame：

In [4]: price_ivs = pd.arrays.IntervalArray.from_arrays(
   ...:     df['price_low'], df['price_high'], closed='both')

In [5]: price_ivs
Out[5]: 
IntervalArray([[10, 20], [1, 7], [10, 12], [20, 25], [4, 8], [5, 30], [16, 26]],
              closed='both',
              dtype='interval[int64]')

定义所需价格Interval，然后使用overlaps方法获取布尔值索引器：

In [6]: my_price = pd.Interval(8, 16, closed='both')

In [7]: idxr = price_ivs.overlaps(my_price)

In [8]: idxr
Out[8]: array([ True, False,  True, False,  True,  True,  True])

In [9]: df[idxr]
Out[9]: 
   price_low  price_high item
0         10          20    a
2         10          12    c
4          4           8    e
5          5          30    f
6         16          26    g

如果您已经有一列价格作为间隔（或间隔的Series），则可以使用array属性访问基础的IntervalArray并使用与以下相同的方法以上：

In [10]: df = pd.DataFrame({'price_ivs': price_ivs, 'item': list('abcdefg')})

In [11]: df
Out[11]: 
  price_ivs item
0  [10, 20]    a
1    [1, 7]    b
2  [10, 12]    c
3  [20, 25]    d
4    [4, 8]    e
5   [5, 30]    f
6  [16, 26]    g

In [12]: idxr = df['price_ivs'].array.overlaps(my_price)

In [13]: idxr
Out[13]: array([ True, False,  True, False,  True,  True,  True])

In [14]: df[idxr]
Out[14]: 
  price_ivs item
0  [10, 20]    a
2  [10, 12]    c
4    [4, 8]    e
5   [5, 30]    f
6  [16, 26]    g

Answer 2

根的答案是一般性的和有益的。如果您正在寻找简单案例的快速解决方案，可以尝试以下

df[(df['price_low']<=16)&(df['price_high']>=8)]

这是两个间隔重叠的前提。以这种方式更容易理解：价格范围（8）的下限不应高于price_high，价格范围的上限（16）不应低于price_low。

如何找到包含区间的Series / DataFrame与给定区间重叠的位置

2 个答案: