python - Pandas DataFrame 的多列可以被不同的值切片吗-6ren

python - Pandas DataFrame 的多列可以被不同的值切片吗

转载作者：太空宇宙更新时间：2023-11-04 04:57:54

我有一个日期时间索引的 DataFrame，(65 列(为清楚起见仅显示 9 列)-> 传感器数量和 x 行-> 观察数量(对于示例数据，我将其限制为 700 行，以说明我遇到的问题)。演示 csv: https://pastebin.com/mpSgJF94

    swp_data = pd.read_csv(FILE_NAME, index_col=0, header=0, parse_dates=True, infer_datetime_format=True)
swp_data = swp_data.sort_index()

对于每一列，我需要找到值为列最大值的 95% 的点，并找出从 DataFrame 开始到 95% 的点，时间步长之间的差异大于给定值(在本例中为 0.2)。

类似于在 R 中工作的东西(不是实际代码，而是插图)

  for (i in 1 : 95% point){
  difference[i] <- s[i] - s[(i-1)]
}
breaking <-which(difference > 0.2)[1]

这会将 95% 点作为循环的结束索引，并查看时间步长之间的差异并返回差异 > 0.2 的索引值

在 pandas 中，我计算了以下内容:95% 的值(value)

    s95 = (swp_data.max() + (swp_data.max() * .05))

A1-24, -20.6260635,A1-18, -17.863923,A1-12, -11.605629,A2-24, -16.755144,A2-18, -17.6815275,A2-12, -16.369584,A3-24, -15.5030295,

95% 的时间

    s95_time = (swp_data >= (swp_data.max() + (swp_data.max() * .05))).idxmax()

A1-24，2011 年 10 月 2 日 1:30，A1-18, 10/3/2011 6:20,A1-12, 10/2/2011 17:20,A2-24, 10/3/2011 6:10,A2-18, 10/3/2011 1:30,A2-12, 10/2/2011 17:10,A3-24, 10/2/2011 1:30,

到目前为止，我有最大值和 95% 的值，以及每列达到其 95% 点时的一系列时间戳。s95 值:

我试图通过创建值 <= 95% 点的 bool 数据帧来屏蔽 DataFrame(试图复制 R 的 which)，并尝试使用值 >=95% 的 df.where。 mask 或 where 都没有提供我需要的东西，因为当我开始记录时，一些传感器可能已经超过最大值的 95%(mask 返回这些值的 NaN)，而 where 返回这些值但不返回低于 95 的值％临界点。

我正在寻找的输出类似于

      A1-24, A1-18, A1-12, A2-24, A2-18, A2-12, A3-24, A3-18, A3-12
BREAKING  hh:mm, hh:mm, hh:mm, hh:mm, hh:mm, hh:mm, hh:mm, hh:mm, hh:mm

其中 hh:mm 等于从数据文件开始到突破值的时间。

到目前为止，我在 SE 和谷歌上发现的内容让我感到困惑，如果我可以通过不同的值对数据框的列进行子集化，并且我无法弄清楚我正在尝试做的事情是什么。

编辑:@Prateek 评论:

我想做的是找到一种方法，我可以在一定程度上自动化这个过程，这样我就可以使用 95% 的位置来返回断点。我有大约 200 个我正在尝试处理的 csv 文件，并且希望尽可能多地使用 95% 和中断位置来完成过滤。

最佳答案

根据我的理解可能的解决方案。请注意，我重命名为 swap_data至 df在示例中，解决方案在您的问题中提供的 csv 示例文件上进行了测试。

查找从开始到值达到列最大值的 95% 的持续时间

按照您的描述找到每列达到最大值 95% 的第一个时间点:

idx = (df >= df.max(axis=0) * 1.05).idxmax()

>>> idx
Out[]:
A1-24   2011-10-02 01:30:00
A1-18   2011-10-03 06:20:00
A1-12   2011-10-02 17:20:00
A2-24   2011-10-03 06:10:00
A2-18   2011-10-03 01:30:00
A2-12   2011-10-02 17:10:00
A3-24   2011-10-02 01:30:00
dtype: datetime64[ns]

注意使用 df.max() * 1.05避免计算 max两次，与 s95 = (swp_data.max() + (swp_data.max() * .05)) 相比否则都是一样的。

然后通过减去第一个时间戳获得从数据帧开始计算的持续时间

>>> idx - df.index[0]
Out[]:
A1-24   0 days 00:00:00
A1-18   1 days 04:50:00
A1-12   0 days 15:50:00
A2-24   1 days 04:40:00
A2-18   1 days 00:00:00
A2-12   0 days 15:40:00
A3-24   0 days 00:00:00
dtype: timedelta64[ns]

这是每一列从记录开始到 s95 花费的时间观点。如果第一个记录值已经高于此点，则时间为 0。

屏蔽数据框以覆盖这段时间

mask = pd.concat([pd.Series(df.index)] * df.columns.size, axis=1) < idx.values.T
df_masked = df.where(mask.values)

>>> df_masked.dropna(how='all')
Out[]:
                     A1-24     A1-18     A1-12     A2-24     A2-18     A2-12  A3-24
Timestamp
2011-10-02 01:30:00    NaN -18.63589 -16.90389 -17.26780 -19.20653 -19.59666    NaN
2011-10-02 01:40:00    NaN -18.64686 -16.93100 -17.26832 -19.22702 -19.62036    NaN
2011-10-02 01:50:00    NaN -18.65098 -16.92761 -17.26132 -19.22705 -19.61355    NaN
2011-10-02 02:00:00    NaN -18.64307 -16.94764 -17.27702 -19.22746 -19.63462    NaN
2011-10-02 02:10:00    NaN -18.66338 -16.94900 -17.27325 -19.25358 -19.62761    NaN
2011-10-02 02:20:00    NaN -18.66217 -16.95625 -17.27386 -19.25455 -19.64009    NaN
2011-10-02 02:30:00    NaN -18.66015 -16.96130 -17.27040 -19.25898 -19.64241    NaN
2011-10-02 02:40:00    NaN -18.66883 -16.96980 -17.27580 -19.27054 -19.65454    NaN
2011-10-02 02:50:00    NaN -18.68635 -16.97897 -17.27488 -19.28492 -19.65808    NaN
2011-10-02 03:00:00    NaN -18.68009 -16.99057 -17.28346 -19.28928 -19.67182    NaN
2011-10-02 03:10:00    NaN -18.68450 -17.00258 -17.28196 -19.32272 -19.68135    NaN
2011-10-02 03:20:00    NaN -18.68777 -17.01009 -17.29675 -19.30864 -19.68747    NaN
2011-10-02 03:30:00    NaN -18.70067 -17.01706 -17.29178 -19.32034 -19.69742    NaN
2011-10-02 03:40:00    NaN -18.70095 -17.03559 -17.29352 -19.32741 -19.70945    NaN
2011-10-02 03:50:00    NaN -18.70636 -17.03651 -17.28925 -19.33549 -19.71560    NaN
2011-10-02 04:00:00    NaN -18.70937 -17.03548 -17.28996 -19.33433 -19.71211    NaN
2011-10-02 04:10:00    NaN -18.70599 -17.04444 -17.29223 -19.33740 -19.72227    NaN
2011-10-02 04:20:00    NaN -18.71292 -17.05510 -17.29449 -19.35154 -19.72779    NaN
2011-10-02 04:30:00    NaN -18.72158 -17.06376 -17.28770 -19.35647 -19.73064    NaN
2011-10-02 04:40:00    NaN -18.72185 -17.06910 -17.30018 -19.36785 -19.74481    NaN
2011-10-02 04:50:00    NaN -18.72048 -17.06599 -17.29004 -19.37320 -19.73424    NaN
2011-10-02 05:00:00    NaN -18.73083 -17.07618 -17.29528 -19.37319 -19.75045    NaN
2011-10-02 05:10:00    NaN -18.72215 -17.08587 -17.29650 -19.38400 -19.75713    NaN
2011-10-02 05:20:00    NaN -18.73206 -17.10233 -17.29767 -19.39254 -19.76838    NaN
2011-10-02 05:30:00    NaN -18.73719 -17.09621 -17.29842 -19.39363 -19.76258    NaN
2011-10-02 05:40:00    NaN -18.73839 -17.10910 -17.29237 -19.40390 -19.76864    NaN
2011-10-02 05:50:00    NaN -18.74257 -17.12091 -17.29398 -19.40846 -19.78042    NaN
2011-10-02 06:00:00    NaN -18.74327 -17.12995 -17.29097 -19.41153 -19.77897    NaN
2011-10-02 06:10:00    NaN -18.74326 -17.04482 -17.28397 -19.40928 -19.77430    NaN
2011-10-02 06:20:00    NaN -18.73100 -16.86221 -17.28575 -19.40956 -19.78396    NaN
...                    ...       ...       ...       ...       ...       ...    ...
2011-10-03 01:20:00    NaN -18.16448       NaN -16.99797 -17.95030       NaN    NaN
2011-10-03 01:30:00    NaN -18.15606       NaN -16.98879       NaN       NaN    NaN
2011-10-03 01:40:00    NaN -18.12795       NaN -16.97951       NaN       NaN    NaN
2011-10-03 01:50:00    NaN -18.12974       NaN -16.97937       NaN       NaN    NaN
2011-10-03 02:00:00    NaN -18.11848       NaN -16.96770       NaN       NaN    NaN
2011-10-03 02:10:00    NaN -18.11879       NaN -16.95256       NaN       NaN    NaN
2011-10-03 02:20:00    NaN -18.08212       NaN -16.95461       NaN       NaN    NaN
2011-10-03 02:30:00    NaN -18.09060       NaN -16.94141       NaN       NaN    NaN
2011-10-03 02:40:00    NaN -18.07000       NaN -16.93006       NaN       NaN    NaN
2011-10-03 02:50:00    NaN -18.07461       NaN -16.91700       NaN       NaN    NaN
2011-10-03 03:00:00    NaN -18.06039       NaN -16.91466       NaN       NaN    NaN
2011-10-03 03:10:00    NaN -18.04229       NaN -16.89537       NaN       NaN    NaN
2011-10-03 03:20:00    NaN -18.03514       NaN -16.89753       NaN       NaN    NaN
2011-10-03 03:30:00    NaN -18.03014       NaN -16.88813       NaN       NaN    NaN
2011-10-03 03:40:00    NaN -18.00851       NaN -16.88086       NaN       NaN    NaN
2011-10-03 03:50:00    NaN -18.01028       NaN -16.87721       NaN       NaN    NaN
2011-10-03 04:00:00    NaN -18.00227       NaN -16.86687       NaN       NaN    NaN
2011-10-03 04:10:00    NaN -17.98804       NaN -16.85424       NaN       NaN    NaN
2011-10-03 04:20:00    NaN -17.96740       NaN -16.84466       NaN       NaN    NaN
2011-10-03 04:30:00    NaN -17.96451       NaN -16.84205       NaN       NaN    NaN
2011-10-03 04:40:00    NaN -17.95414       NaN -16.82609       NaN       NaN    NaN
2011-10-03 04:50:00    NaN -17.93661       NaN -16.81903       NaN       NaN    NaN
2011-10-03 05:00:00    NaN -17.92905       NaN -16.80737       NaN       NaN    NaN
2011-10-03 05:10:00    NaN -17.92743       NaN -16.80582       NaN       NaN    NaN
2011-10-03 05:20:00    NaN -17.91504       NaN -16.78991       NaN       NaN    NaN
2011-10-03 05:30:00    NaN -17.89965       NaN -16.78469       NaN       NaN    NaN
2011-10-03 05:40:00    NaN -17.89945       NaN -16.77288       NaN       NaN    NaN
2011-10-03 05:50:00    NaN -17.88822       NaN -16.76610       NaN       NaN    NaN
2011-10-03 06:00:00    NaN -17.87259       NaN -16.75742       NaN       NaN    NaN
2011-10-03 06:10:00    NaN -17.87308       NaN       NaN       NaN       NaN    NaN

[173 rows x 7 columns]

要实现这一点，您必须计算 bool每列掩码:

使用 DateTimeIndex 创建数据框在与 df 相同数量的列上重复的值: pd.concat([pd.Series(df.index)] * df.columns.size, axis=1) .这里df.index必须变成 pd.Series用于串联，然后重复以匹配列数 df.columns.size .
使用 < idx.values.T 创建面具本身, 其中values得到 idx作为 numpy.array和 T转置它以便按列与数据框进行比较。
用 df.where(mask.values) 屏蔽数据框，其中使用 values获取掩码为 numpy.array .这是必需的，因为掩码没有与 df 相同的标签.
可选择只保留至少一个值不是 NaN 的行使用 .dropna(how='all')

根据每个时间点之间的差异过滤屏蔽数据

如果我理解得很好，这就是您要在 difference > 0.2 上过滤数据的地方仅在每个时间点之间和选定的时间段内。我仍然有点不清楚，所以如果我误解了，请不要犹豫，在评论中讨论。

这可以通过以下方式完成:

df[df_masked.diff(1) > 0.2]

但不幸的是，对于提供的数据集，没有符合这些条件的值。

>>> df[df_masked.diff(1) > 0.2].any()
Out[]:
A1-24    False
A1-18    False
A1-12    False
A2-24    False
A2-18    False
A2-12    False
A3-24    False
dtype: bool

编辑:将结果可视化为 bool dataframe(评论跟进)

使用 df_masked.diff(1) > 0.2 可以非常简单地将结果可视化为具有索引和列的 bool 数据框.然而，可能会有很多不必要的行只包含 False , 所以你可以这样过滤它:

df_diff = df_masked.diff(1) > 0.1  # Raising the threshold a bit to get some values

>>> df_diff[df_diff.any(axis=1)]
Out[]:
                     A1-24  A1-18  A1-12  A2-24  A2-18  A2-12  A3-24
Timestamp
2011-10-02 06:20:00  False  False   True  False  False  False  False
2011-10-02 06:30:00  False  False   True  False  False  False  False
2011-10-02 06:40:00  False  False   True  False  False  False  False
2011-10-02 06:50:00  False  False   True  False  False  False  False
2011-10-02 07:00:00  False  False   True  False  False  False  False
2011-10-02 07:10:00  False  False   True  False  False  False  False
2011-10-02 07:20:00  False  False   True  False  False  False  False
2011-10-02 07:30:00  False  False   True  False  False  False  False
2011-10-02 07:40:00  False  False   True  False  False  False  False
2011-10-02 07:50:00  False  False   True  False  False  False  False
2011-10-02 08:00:00  False  False   True  False  False  False  False
2011-10-02 08:10:00  False  False   True  False  False  False  False
2011-10-02 08:20:00  False  False   True  False  False  False  False
2011-10-02 08:30:00  False  False   True  False  False  False  False
2011-10-02 08:40:00  False  False   True  False  False  False  False
2011-10-02 08:50:00  False  False   True  False  False  False  False
2011-10-02 09:00:00  False  False   True  False  False  False  False
2011-10-02 09:10:00  False  False   True  False  False  False  False
2011-10-02 09:20:00  False  False   True  False  False  False  False
2011-10-02 09:30:00  False  False   True  False  False  False  False
2011-10-02 12:20:00  False  False  False  False  False   True  False
2011-10-02 12:50:00  False  False  False  False   True   True  False
2011-10-02 13:10:00  False  False  False  False  False   True  False

关于python - Pandas DataFrame 的多列可以被不同的值切片吗，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/46611837/

文章推荐： python - CNTK 和 UserMinibatchSource 预取

文章推荐： html - 在 div 内平均拉伸(stretch) 4 个元素

文章推荐： html - 旋转下拉列表

文章推荐： c++ - BDM Sprite 文件与普通 Sprite 文件

java - 如何解析名称=值^^名称=值^^名称=值
我的问题:非常具体。我正在尝试想出解析以下文本的最简单方法: ^^domain=domain_value^^version=version_value^^account_type=account_ty
Python:尝试创建与(或(值，值，值))的等价物
好吧，这就是我的困境: 我正在为 Reddit 子版 block 开发常见问题解答机器人。我在 bool 逻辑方面遇到了麻烦，需要一双更有经验的眼睛(这是我在 Python 中的第一次冒险)。现在，该
excel - 如何使循环同时运行所有 X 和 Y 值，现在它运行所有 Y 值，然后运行所有 X 值
它首先遍历所有 y 值，然后遍历所有 x 值。我需要 X 和 y 同时改变。 For x = 3 To lr + 1 For y = 2 To lr anyl.Cells(x, 1)
excel - SUMIF(条件，值)、SUMPROD(条件，值)和 SUM(条件*值)之间的区别
假设我有一个包含 2 列的 Excel 表格:单元格 A1 到 A10 中的日期和 B1 到 B10 中的值。我想对五月日期的所有值求和。我有3种可能性: {=SUM((MONTH(A1:A10)=
python - 将 Z 值(Z 值，标准分数)转换为 Python 中正态分布的 p 值
如何转换 Z-score来自 Z-distribution (standard normal distribution, Gaussian distribution)到 p-value ?我还没有找到
javascript( bool 值 ^ bool 值)
我正在重写一些 Javascript 代码以在 Excel VBA 中工作。由于在这个网站上搜索，我已经设法翻译了几乎所有的 Javascript 代码!但是，有些代码我无法准确理解它在做什么。这是一
php - 在php中的数组内添加新的键，值(值= 1)
我遇到过包含日期格式的时间戳日期的情况。然后我想构建一个图表，显示“点击”项目的数量“每天”， //array declaration $array1 = array("Date" => 0); $a
scala - Option(值)和Some(值)之间的差异
我是scala的新手! 我的问题是，是否有包含成员的案例类 myItem:Option[String] 当我构造类时，我需要将字符串内容包装在: Option("some string") 要么 So
php - 从表中选择 * 其中列 = 值 ^ column2 = 值
我正在用 PHP 创建一个登录系统。我需要用户使用他或她的用户名或电子邮件或电话号码登录然后使用密码。因为我知道在 Java 中我们会像 email==user^ username == user 这
c++ - WHERE 列 = 值，仅适用于 INTEGER 值
我在 C++ 项目上使用 sqlite，但是当我在具有文本值的列上使用 WHERE 时出现问题我创建了一个 sqlite 数据库: CREATE TABLE User( id INTEGER
c++ - 类类名(值)；和类类名=值；显式构造函数时的区别
当构造函数是显式时，它不用于隐式转换。在给定的代码片段中，构造函数被标记为 explicit。那为什么在 foo obj1(10.25); 情况下它可以工作，而在 foo obj2=10.25; 情况
c# - : if(! 值) 或 if(flag == 值) 哪个更清晰？
我知道这是一个主观问题，所以如果需要关闭它，我深表歉意，但我觉得它经常出现，让我想知道是否普遍偏爱一种形式而不是另一种形式。显然，最好的答案是“重构代码，这样你就不需要测试是否存在错误”，但有时没有
jquery - [属性~=值] 和 [属性*=值] 有什么区别？
这两个 jQuery 选择器有什么区别？以下是来自 w3schools.com 的定义: [attribute~=value] 选择器选择带有特定属性，其值包含特定字符串。 [attribute*=
CSS [属性|=值] 与 [属性*=值] 选择器
为什么我们需要CSS [attribute|=value] Selector根本当 CSS3 [attribute*=value] Selector基本上完成相同的事情，浏览器兼容性几乎相似？是否存在
java - 正则表达式仅验证 0 值。要验证的单个 0 值
我正在解决 regx 问题。我已经有一个像这样的 regx [0-9]*([.][0-9]{2})。这是 amont 格式验证。现在，通过此验证，我想包括不应提供 0 金额。比如 10 是有效的，但
java - 尽管代码删除了 "0"值，但为什么列表中仍保留 "0"值？
我正在研究计算机科学 A 考试的样题，但无法弄清楚为什么以下问题的正确答案是正确的。考虑以下方法。 public static void mystery(List nums) { for (
perl - 基本的 Perl 散列排序键，值，但也键 AND 值
好的，我正在编写一个 Perl 程序，它有一个我收集的值的哈希值(完全在一个完全独立的程序中)并提供给这个 Perl 脚本。这个散列是 (string,string) 的散列。我想通过 3 种方式对
mysql - 根据其他两列选择一列的 MAX 值，其中一列具有 MAX 值
我有一个表数据如下，来自不同的表。仅当第三列具有值“债务”并且第一列(日期)具有最大值时，我才想从第四列中获取最大值。最终值基于 MAX(DATE) 而不是 MAX(PRICE)。所以用简单的语言来说
php - 代码仅更新数据库中的 false 值，但不更新 true 值
我有一个奇怪的情况，只有错误状态保存到数据库中。当“状态”应该为 true 时，我的查询仍然执行 false。我有具有此功能的 Controller public function change_a
mysql SUM(值) 其中 SUM(值) > 2500
我有一个交易表(针对所需列进行了简化): id client_id value 1 1 200 2 2 150 3 1

太空宇宙

个人简介

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

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城