主页 / coding / 问题 / 78816988
Accepted
Andy
Asked: 2024-07-31 22:46:01 +0800 CST

如何删除具有最大/最小值的行

  • 772

我有数据框：

   one   N    th
0   A      5      1   
1   Z      17     0   
2   A      16     0   
3   B      9      1   
4   B      17     0   
5   B      117    1   
6   XC     35     1   
7   C      85     0    
8   Ce     965    1

我正在寻找在第三列中不断交替出现 0101 而不将 0 或 1 加倍的方法。因此，如果在第 列有两个重复的 0，我想删除具有最小值的行，如果有重复的 1，我想删除具有最大值的行。

我的基础由 1000000 行组成。

我希望有这样的数据框：

   one   N    th
0   A      5      1   
1   Z      17     0   
3   B      9      1   
4   B      17     0    
6   XC     35     1   
7   C      85     0    
8   Ce     965    1

最快的方法是什么？我的意思是矢量化方法。我尝试过，但没有结果。

python

5 个回答

  1. Best Answer

    使用自定义groupby.idxmax

    如果“th”为，则可以交换符号1（以获取最大值而不是最小值），然后设置自定义分组器（使用diff或shift+ cumsum）并执行以选择要保留的groupby.idxmax行：

    out = df.loc[df['N'].mul(df['th'].map({0: 1, 1: -1}))
             .groupby(df['th'].ne(df['th'].shift()).cumsum())
             .idxmax()]

    使用不同的方法来交换符号并计算组：

    out = df.loc[df['N'].mask(df['th'].eq(1), -df['N'])
             .groupby(df['th'].diff().ne(0).cumsum())
             .idxmax()]

    输出：

      one    N  th
0   A    5   1
1   Z   17   0
3   B    9   1
4   B   17   0
6  XC   35   1
7   C   85   0
8  Ce  965   1

    中间体：

      one    N  th  swap  group max
0   A    5   1    -5      1   X
1   Z   17   0    17      2   X
2   A   16   0    16      2    
3   B    9   1    -9      3   X
4   B   17   0    17      4   X
5   B  117   1  -117      5    
6  XC   35   1   -35      5   X
7   C   85   0    85      6   X
8  Ce  965   1  -965      7   X

    使用布尔掩码

    上述代码适用于任意数量的连续 0 或 1。如果你知道最多只有 2 个连续的 1，那么你也可以使用布尔索引，这应该会快得多：

    # has the value higher precedence than the next?
D = df['N'].mask(df['th'].eq(1), -df['N']).diff()

# is the th different from the previous?
G = df['th'].ne(df['th'].shift(fill_value=-1))

# rule for the bottom row
m1 = D.gt(0) | G

# rule for the top row
# same rule as above but shifted up
# D is inverted
# comparison is not strict in case of equality
m2 = ( D.le(0).shift(-1, fill_value=True)
      | G.shift(-1, fill_value=True)
     )

# keep rows of interest
out = df.loc[m1&m2]

    输出：

      one    N  th
0   A    5   1
1   Z   17   0
3   B    9   1
4   B   17   0
6  XC   35   1
7   C   85   0
8  Ce  965   1

    中间体：

      one    N  th       D      G     m1     m2  m1&m2
0   A    5   1     NaN   True   True   True   True
1   Z   17   0    22.0   True   True   True   True
2   A   16   0    -1.0  False  False   True  False
3   B    9   1   -25.0   True   True   True   True
4   B   17   0    26.0   True   True   True   True
5   B  117   1  -134.0   True   True  False  False
6  XC   35   1    82.0  False   True   True   True
7   C   85   0   120.0   True   True   True   True
8  Ce  965   1 -1050.0   True   True   True   True

    具有相等值的更复杂示例：

       one    N  th       D      G     m1     m2  m1&m2
0    A    5   1     NaN   True   True   True   True
1    Z   17   0    22.0   True   True   True   True
2    A   16   0    -1.0  False  False   True  False
3    B    9   1   -25.0   True   True   True   True
4    B   17   0    26.0   True   True   True   True
5    B  117   1  -134.0   True   True  False  False
6   XC   35   1    82.0  False   True   True   True
7    C   85   0   120.0   True   True   True   True
8   Ce  965   1 -1050.0   True   True   True   True
9    u  123   0  1088.0   True   True   True   True # because of D.le(0)
10   v  123   0     0.0  False  False   True  False # because or D.gt(0)

    注意：在相等的情况下，可以选择第一行/第二行或两者或都不选择，具体取决于所使用的运算符（，，，，D.le(0)）。D.lt(0)D.gt(0)D.ge(0)

    时间安排

    尽管最多只能有 2 个连续的“th”，但布尔掩码方法的速度要快 4-5 倍。对 1M 行进行计时：

    # groupby + idxmax
96.4 ms ± 6.64 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

# boolean masks
22.2 ms ± 1.48 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
    • 3
    1. 通过使用移位来标识新组的开始，为每个 0 和 1 序列创建一个组。
    2. 进行 groupby 变换以确定每组的最大值
    3. 过滤，以便仅接受 N = 最大的行

    df['group'] = (df['th'] != df['th'].shift(1)).cumsum()
df['max'] = df.groupby('group')['N'].transform('max')

df2 = df.loc[df['N'] == df['max']][['one', 'N', 'th']]

    如果您不想创建中间列，则可以使用一个版本：

    df.loc[df['N'] == df.groupby((df['th'] != df['th'].shift(1)).cumsum())['N'].transform('max')]
    • 1

  3. 创建一个变量不是很容易吗？然后在循环中将其设置为第一个，然后将其与下一个进行比较。如果相同，并且为 0，则删除最低的；如果为 1，则删除最高的。如果它们不同，则将变量设置为下一个并继续循环

    • 0

  4. 由于其中一条评论而添加此项。关于下面描述的迭代方法，它实际上并不是您想要使用的技术，因为它没有利用 Pandas。添加它是为了完整性，因为如果与其他解决方案相比，它不太简洁。

    data = [
    [0, 'A', 5, 1],
    [1, 'Z', 17, 0],
    [2, 'A', 16, 0],
    [3, 'B', 9, 1],
    [4, 'B', 17, 0],
    [5, 'B', 117, 1],
    [6, 'XC', 35, 1],
    [7, 'C', 85, 0],
    [8, 'Ce', 965, 1]
]

df = pd.DataFrame(data, columns=['id', 'one', 'N', 'th'])

def ensure_alternating_th(df):
    while True:
        repeats_found = False
        idx_to_remove = []

        for idx in range(1, len(df)):
            # check for repeated values in 'th' column
            if df.at[idx, 'th'] == df.at[idx - 1, 'th']:
                repeats_found = True
                if df.at[idx, 'th'] == 0:
                    # Drop row with minimum 'N' where 'th' == 0
                    min_row_idx = df.iloc[[idx - 1, idx]]['N'].idxmin()
                elif df.at[idx, 'th'] == 1:
                    # Drop row with maximum 'N' where 'th' == 1
                    max_row_idx = df.iloc[[idx - 1, idx]]['N'].idxmax()
                idx_to_remove.append(min_row_idx if df.at[idx, 'th'] == 0 else max_row_idx)

        if not repeats_found:
            break

        # remove identified rows and reset index
        df = df.drop(idx_to_remove).reset_index(drop=True)

    return df

df_cleaned = ensure_alternating_th(df)

"""
# Returns
   id   one N   th
0   0   A   5   1
1   1   Z   17  0
2   3   B   9   1
3   4   B   17  0
4   6   XC  35  1
5   7   C   85  0
6   8   Ce  965 1
"""
    • 0

  5. 您想要的是以下两种情况之间的“或”关系：

    bb = (df['th'] == 0) & (df['N'] == df['max_N'])
aa = (df['th'] == 1) & (df['N'] == df['min_N'])
res = (aa | bb)

    代码 ：

    import pandas as pd
import numpy as np

data = {
    'one': ['A', 'Z', 'A', 'B', 'B', 'B', 'XC', 'C', 'Ce'],
    'N': [5, 17, 16, 9, 17, 117, 35, 85, 965],
    'th': [1, 0, 0, 1, 0, 1, 1, 0, 1]
}


df = pd.DataFrame(data)
'''
  one    N  th
0   A    5   1
1   Z   17   0
2   A   16   0
3   B    9   1
4   B   17   0
5   B  117   1
6  XC   35   1
7   C   85   0
8  Ce  965   1
'''
df['group'] = (df['th'] != df['th'].shift()).cumsum()

gr = df.groupby(['th','group'])['N'].agg([('max_N','max'),('min_N','min')]).reset_index()
'''
gr :
   th  group  max_N  min_N
0   0      2     17     16
1   0      4     17     17
2   0      6     85     85
3   1      1      5      5
4   1      3      9      9
5   1      5    117     35
6   1      7    965    965
'''

df = df.merge(gr,on = ['th','group'])
'''
  one    N  th  group  max_N  min_N
0   A    5   1      1      5      5
1   Z   17   0      2     17     16
2   A   16   0      2     17     16
3   B    9   1      3      9      9
4   B   17   0      4     17     17
5   B  117   1      5    117     35
6  XC   35   1      5    117     35
7   C   85   0      6     85     85
8  Ce  965   1      7    965    965
'''

bb = (df['th'] == 0) & (df['N'] == df['max_N'])
aa = (df['th'] == 1) & (df['N'] == df['min_N'])
df['keep'] = (aa | bb)
'''
  one    N  th  group  max_N  min_N   keep
0   A    5   1      1      5      5   True
1   Z   17   0      2     17     16   True
2   A   16   0      2     17     16  False
3   B    9   1      3      9      9   True
4   B   17   0      4     17     17   True
5   B  117   1      5    117     35  False
6  XC   35   1      5    117     35   True
7   C   85   0      6     85     85   True
8  Ce  965   1      7    965    965   True
'''
filtered_df = df[df['keep']]
'''
  one    N  th  group  max_N  min_N  keep
0   A    5   1      1      5      5  True
1   Z   17   0      2     17     16  True
3   B    9   1      3      9      9  True
4   B   17   0      4     17     17  True
6  XC   35   1      5    117     35  True
7   C   85   0      6     85     85  True
8  Ce  965   1      7    965    965  True
'''
    • 0

相关问题