python - 从数据框中的组中删除在特定列中具有最小值的行-6ren

python - 从数据框中的组中删除在特定列中具有最小值的行

转载作者：行者123 更新时间：2023-11-28 18:12:26

我在 csv 文件中有一个数据集。我使用 pandas 作为数据框导入了它。然后我根据我命名为 Vf 的列从最小到最大对我的数据进行排序。

从这里我的代码试图做什么:将排序后的数据帧 (DF) 分组为 11 个一组。计算每组中相应的最小值和最大值之间的差异。遍历每个组并检查任何组的最小值和最大值之间的差异是否大于 0.2。如果任何组都满足此条件，我希望代码从原始数据框中删除包含该组最小值的数据行。然后再次对数据框进行排序和分组，减去该行。再次遍历每个组，检查最小值和最大值之间的差异。它应该继续这样做，直到它遍历每个组并发现它们的最小值和最大值之间的差异都不大于 0.2。

据我所知，现在我的代码就是这样做的。但是当我想要它时它不会停止，即当所有组的最小值和最大值之间的差异小于 0.2 时，它不会停止。此外，此时它实际上似乎将行添加回原始数据框中。

这是代码。请注意，我已将其设置为仅通过我数据中的前 2 组。另请注意，我的 for 循环中的行要求它打印语句和排序数据框的形状。这一切都是为了提供用于调试目的的信息。

def celling():
import numpy as np
import pandas as pd
Data = input("Name of File: ")
DF = pd.read_csv("Y:\CHRIS\{}.csv".format(Data), skiprows = 20, names = ["Serial","Bin","Ir","Vf"])

def sort(Data):
    SortedDF = Data.sort_values(by='Vf')
    GroupedDF = SortedDF.groupby(np.arange(len(SortedDF))//11)
    GroupMax = GroupedDF["Vf"].max()
    GroupMin = GroupedDF["Vf"].min()
    GroupDiff = GroupMax - GroupMin
    GroupMinIndices = GroupedDF["Vf"].idxmin()
#sort(DF)
    for i in range(2):

        if GroupDiff[i] > 0.2:
            DF = Data[Data.index != GroupMinIndices[i]]
            print("Group {} was bad.".format(i))
            print(SortedDF.shape)
            sort(DF)
        else:
            print("Group {} is good.".format(i))
        print(SortedDF.shape)
sort(DF)

这是原始数据框的示例:

        Serial  Bin       Ir     Vf
    0        1  1.0  0.00161  170.7
    1        2  1.0  0.00157  173.3
    2        3  1.0  0.00169  171.0
    3        4  1.0  0.00145  172.7
    4        5  1.0  0.00170  171.4
    5        6  1.0  0.00160  172.6
    6        7  1.0  0.00180  172.4
    7        8  1.0  0.00169  172.1
    8        9  1.0  0.00147  170.9
    9       10  1.0  0.00151  172.3
    10      11  1.0  0.00142  171.8
    11      12  1.0  0.00168  171.5

这是按 Vf 排序的数据帧示例:

    Serial  Bin       Ir     Vf
477    478  1.0  0.00180  170.0
359    360  1.0  0.00139  170.1
247    248  1.0  0.00197  170.1
575    576  1.0  0.00159  170.2
267    268  1.0  0.00178  170.2
178    179  1.0  0.00277  170.3
82      83  1.0  0.00145  170.3
574    575  1.0  0.00162  170.3
97      98  1.0  0.00190  170.3
399    400  1.0  0.00172  170.4
21      22  1.0  0.00166  170.4
67      68  1.0  0.00176  170.5
103    104  1.0  0.00154  170.5
553    554  1.0  0.00169  170.5
533    534  1.0  0.00167  170.5
177    178  1.0  0.00160  170.5
35      36  1.0  0.00150  170.5
186    187  1.0  0.00165  170.5
363    364  1.0  0.00172  170.6
487    488  1.0  0.00159  170.6

所以理想情况下，代码在这里应该做的是检查这个示例的前 11 行，注意这 11 行中的最大值和最小值之间的差值大于 0.2，然后从第一行中删除具有最小值的行11，在这种情况下，将是序列号为 11 的行。 478. 然后它应该重新组合数据，上面示例中的第 2-12 行现在构成第一组 11。然后它应该注意到最小/最大差异仍然大于 0.2 并重新开始。代码完成后，下面应该是上述示例中的第一组 11

178    179  1.0  0.00277  170.3
82      83  1.0  0.00145  170.3
574    575  1.0  0.00162  170.3
97      98  1.0  0.00190  170.3
399    400  1.0  0.00172  170.4
21      22  1.0  0.00166  170.4
67      68  1.0  0.00176  170.5
103    104  1.0  0.00154  170.5
553    554  1.0  0.00169  170.5
533    534  1.0  0.00167  170.5
177    178  1.0  0.00160  170.5

这是我的代码目前的结果:

Group 0 was bad.
(643, 4)
Group 0 was bad.
(642, 4)
Group 0 was bad.
(641, 4)
Group 0 was bad.
(640, 4)
Group 0 was bad.
(639, 4)
Group 0 is good.
(638, 4)
Group 1 was bad.
(638, 4)
Group 0 is good.
(637, 4)
Group 1 was bad.
(637, 4)
Group 0 is good.
(636, 4)
Group 1 was bad.
(636, 4)
Group 0 is good.
(635, 4)
Group 1 was bad.
(635, 4)
Group 0 is good.
(634, 4)
Group 1 was bad.
(634, 4)
Group 0 is good.
(633, 4)
Group 1 is good.
(633, 4)
(634, 4)
(635, 4)
(636, 4)
(637, 4)
(638, 4)
(639, 4)
Group 1 is good.
(639, 4)
(640, 4)
Group 1 is good.
(640, 4)
(641, 4)
Group 1 is good.
(641, 4)
(642, 4)
Group 1 is good.
(642, 4)
(643, 4)
Group 1 is good.
(643, 4)
(643, 4)

请注意，当它读取到第 0 组的最大值和最小值之差大于 0.2 时，它是如何不断删除行的。然后它移动到第 1 组。当它读到第 1 组中的最大/最小差异大于 0.2 时，它删除该行并返回到 for 循环的开始(我知道这个效率不高)。但是，请注意，理论上它应该在读到第 0 组良好然后第 1 组良好时立即停止，但事实并非如此。请注意，在它读取它们之后它们都很好，它似乎开始将行添加回数据框中。

如果有人能解释为什么我的代码这样做，或者解释我的代码在做什么，如果它没有这样做，我们将不胜感激。请注意，我是 python 的新手，所以请多关照! :)

最佳答案

这是一个棘手的问题，所以让我们从重述开始。

排序使用 Vf 列的数据
分组连续 11 行并找到最小-最大差值超过 0.2 的第一组。
将数据从该组开始分成两部分，第一部分是好的部分，第二部分是坏的并要求从开头删除行。
删除从坏部分开始的行，直到Vf 和Vf.shift(-10 )不超过0.2
重复这些步骤(group-split-remove)直到一个split有一个空的bad part
加入所有好的部分以获得最终结果
(可选)为最终结果分配一个group id

创建示例排序数据框:

df = pd.read_table(io.StringIO("""    Serial  Bin       Ir     Vf
477    478  1.0  0.00180  170.0
359    360  1.0  0.00139  170.1
247    248  1.0  0.00197  170.1
575    576  1.0  0.00159  170.2
267    268  1.0  0.00178  170.2
178    179  1.0  0.00277  170.3
82      83  1.0  0.00145  170.3
574    575  1.0  0.00162  170.3
97      98  1.0  0.00190  170.3
399    400  1.0  0.00172  170.4
21      22  1.0  0.00166  170.4
67      68  1.0  0.00176  170.5
103    104  1.0  0.00154  170.5
553    554  1.0  0.00169  170.5
533    534  1.0  0.00167  170.5
177    178  1.0  0.00160  170.5
35      36  1.0  0.00150  170.5
186    187  1.0  0.00165  170.5
363    364  1.0  0.00172  170.6
487    488  1.0  0.00159  170.6"""), sep='\s+')

以下是辅助函数:

def grouper(frame):
    return np.arange(len(frame)) // 11

def remove(frame): 
    return (
        (frame.Vf.shift(-10).fillna(frame.Vf.max()) - frame.Vf) < 0.2
    ).cumsum() > 0

def split_df(frame): 
    return frame.groupby(
        grouper(frame)
    ).Vf.transform(
        lambda x: (x.max() - x.min()) > 0.2
    ).cumsum() > 0

column.cumsum() > 0 其中列具有 bool 类型，在遇到第一个真值后过滤所有行，包括为真的行。

下面的函数实现了上面的递归逻辑(借助上面定义的一些辅助函数)

def group_split_remove(frame):
    temp = frame[split_df(frame)]
    if len(temp) == 0:
        return frame
    return pd.concat([frame[~split_df(frame)], group_split_remove(temp[remove(temp)])])

现在，python 中的递归并不总是最好的策略，因此，如果上述方法不够快或达到最大递归深度，请将其重新表述为 while 循环。但是，我相信递归公式在这种情况下更具可读性

使用您的示例(已排序)数据，group_split_remove(df) 返回以下数据框:

     Serial  Bin       Ir     Vf
178     179  1.0  0.00277  170.3
82       83  1.0  0.00145  170.3
574     575  1.0  0.00162  170.3
97       98  1.0  0.00190  170.3
399     400  1.0  0.00172  170.4
21       22  1.0  0.00166  170.4
67       68  1.0  0.00176  170.5
103     104  1.0  0.00154  170.5
553     554  1.0  0.00169  170.5
533     534  1.0  0.00167  170.5
177     178  1.0  0.00160  170.5
35       36  1.0  0.00150  170.5
186     187  1.0  0.00165  170.5
363     364  1.0  0.00172  170.6
487     488  1.0  0.00159  170.6

如您所见，前 11 行与您的预期输出完全匹配。

最后的可选步骤是分配一个 group_id，可以按如下方式完成:

res['group_id'] = grouper(res)

关于python - 从数据框中的组中删除在特定列中具有最小值的行，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/50344778/

文章推荐： ios - iOS 中安装了 URL Scheme

文章推荐： html - 组合 CSS 媒体查询条件

文章推荐： iphone - reloadData 只刷新一行

文章推荐： iphone - 将我的应用程序带到 Objective-C 的前台

python - Python 中的集群或合并集群以减少组数 (Python)
我正在处理一组标记为 160 个组的 173k 点。我想通过合并最接近的(到 9 或 10 个组)来减少组/集群的数量。我搜索过 sklearn 或类似的库，但没有成功。我猜它只是通过 knn 聚类
python - python 列表的子集基于同一列表的元素组，pythonically
我有一个扁平数字列表，这些数字逻辑上以 3 为一组，其中每个三元组是 (number, __ignored, flag[0 or 1])，例如: [7,56,1, 8,0,0, 2,0,0, 6,1,
python - 激活 Python 虚拟环境并在另一个 Python 脚本中调用 Python 脚本
我正在使用 pipenv 来管理我的包。我想编写一个 python 脚本来调用另一个使用不同虚拟环境(VE)的 python 脚本。如何运行使用 VE1 的 python 脚本 1 并调用另一个 p
python - 在焕然一新的 Python 环境中以编程方式从 Python 内部执行 Python 文件
假设我有一个文件 script.py 位于 path = "foo/bar/script.py"。我正在寻找一种在 Python 中通过函数 execute_script() 从我的主要 Python
python - 从 python 脚本但在 python 脚本之外运行 python 脚本
这听起来像是谜语或笑话，但实际上我还没有找到这个问题的答案。问题到底是什么？我想运行 2 个脚本。在第一个脚本中，我调用另一个脚本，但我希望它们继续并行，而不是在两个单独的线程中。主要是我不希望第
python - 使用不同的 python 从 python 运行 python 脚本
我有一个带有 python 2.5.5 的软件。我想发送一个命令，该命令将在 python 2.7.5 中启动一个脚本，然后继续执行该脚本。我试过用 #!python2.7.5 和http://re
python - 为什么从 Python 命令行调用 Python 时 Python 无法找到并运行我的脚本？
我在 python 命令行(使用 python 2.7)中，并尝试运行 Python 脚本。我的操作系统是 Windows 7。我已将我的目录设置为包含我所有脚本的文件夹，使用: os.chdir("
python - 使用动态版本的 Python 执行嵌入的 Python 代码时出现致命的 Python 错误
剧透:部分解决(见最后)。以下是使用 Python 嵌入的代码示例: #include int main(int argc, char** argv) { Py_SetPythonHome
python - python 中识别 python 数组或列表中最大累积差异的最快方法是什么？
假设我有以下列表，对应于及时的股票价格: prices = [1, 3, 7, 10, 9, 8, 5, 3, 6, 8, 12, 9, 6, 10, 13, 8, 4, 11] 我想确定以下总体上最
python - (Python) 通过单选按钮 python 更新背景
所以我试图在选择某个单选按钮时更改此框架的背景。我的框架位于一个类中，并且单选按钮的功能位于该类之外。 (这样我就可以在所有其他框架上调用它们。) 问题是每当我选择单选按钮时都会出现以下错误: co
python - python 中的字符串与正则表达式比较在 python 中失败
我正在尝试将字符串与 python 中的正则表达式进行比较，如下所示， #!/usr/bin/env python3 import re str1 = "Expecting property name
python - python 如何加载Boost.Python 库？
考虑以下原型(prototype) Boost.Python 模块，该模块从单独的 C++ 头文件中引入类“D”。 /* file: a/b.cpp */ BOOST_PYTHON_MODULE(c)
python - python 检查模块 python 的问题
如何编写一个程序来“识别函数调用的行号？” python 检查模块提供了定位行号的选项，但是， def di(): return inspect.currentframe().f_back.f_l
python - 系统 python 与用户 python
我已经使用 macports 安装了 Python 2.7，并且由于我的 $PATH 变量，这就是我输入 $ python 时得到的变量。然而，virtualenv 默认使用 Python 2.6，除
python - [Python] : Python re. 长字符串行的搜索速度优化
我只想问如何加快 python 上的 re.search 速度。我有一个很长的字符串行，长度为 176861(即带有一些符号的字母数字字符)，我使用此函数测试了该行以进行研究: def getExe
python - 编辑字符串 python 正则表达式 python
list1= [u'%app%%General%%Council%', u'%people%', u'%people%%Regional%%Council%%Mandate%', u'%ppp%%Ge
python - Python 映射中的副作用(Python "do" block )
这个问题在这里已经有了答案: Is it Pythonic to use list comprehensions for just side effects? (7 个答案) 关闭 4 个月前。告
python - 使用其值逻辑组合两个 python 列表 - Python
我想用 Python 将两个列表组合成一个列表，方法如下: a = [1,1,1,2,2,2,3,3,3,3] b= ["Sun", "is", "bright", "June","and" ,"Ju
python - Boost.Python python 链接错误
我正在运行带有最新 Boost 发行版 (1.55.0) 的 Mac OS X 10.8.4 (Darwin 12.4.0)。我正在按照说明 here构建包含在我的发行版中的教程 Boost-Pyth
python - 在 Python 中仅使用内置库制作一个基本的网络抓取工具 - Python
学习 Python，我正在尝试制作一个没有任何第 3 方库的网络抓取工具，这样过程对我来说并没有简化，而且我知道我在做什么。我浏览了一些在线资源，但所有这些都让我对某些事情感到困惑。 html 看起来

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

python - 从数据框中的组中删除在特定列中具有最小值的行