我有这个数据框：

In[1]df = pd.DataFrame([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15],[16,17,18,19,20],[21,22,23,24,25]])
In[2]df
Out[2]: 
    0   1   2   3   4
0   1   2   3   4   5
1   6   7   8   9  10
2  11  12  13  14  15
3  16  17  18  19  20
4  21  22  23  24  25

我需要实现这一点：

1. 对于我的数据框中的每一行，
2. 如果任何 3 个连续单元格中的 2 个或更多值大于 10，
3. 那么这 3 个单元格中的最后一个应标记为 True。

根据上述标准，生成的数据帧 df1 应与其中的 True 或 False 大小相同：

In[3]df1
Out[3]: 
    0   1      2      3      4
0 NaN NaN  False  False  False
1 NaN NaN  False  False  False
2 …

TL;DR：我的问题是如何改进我的功能以超越熊猫自己的最大移动功能？

背景资料：

所以我正在处理很多移动平均线、移动最大值和移动最小值等，到目前为止我发现的唯一像特征一样的移动窗口是在pandas.rolling 方法中。问题是：我拥有的数据是 numpy 数组，我想要的最终结果也必须在 numpy 数组中；就像我想简单地将它转换为熊猫系列并返回到 numpy 数组来完成这样的工作：

result2_max = pd.Series(data_array).rolling(window).max().to_numpy()

，这太非pythonic了，因为转换数据类型似乎没有必要，而且可能有一些方法可以纯粹在numpy实现中做完全相同的事情。

然而，尽管它看起来不像 Python，但它比我在网上提出或看到的任何方法都要快。我将在下面给出一些小基准：

import numpy as np
import pandas as pd

def numpy_rolling_max(data, window):

    data = data[::-1]
    data_strides = data.strides[0]

    movin_window = np.lib.stride_tricks.as_strided(data, 
                                                    shape=(data.shape[0] - window +1, window), 
                                                    strides = (data_strides ,data_strides)
                                                    )[::-1]
    max_window =np.amax(movin_window, axis = 1)#this line seems to be the bottleneck


    nan_array = np.full(window - 1, np.nan)
    return np.hstack((nan_array, max_window))


def pandas_rolling_max(data, window):
    return pd.Series(data).rolling(window).max().to_numpy()

length = 120000
window = 190
data …

I have a pandas dataframe containing string values and a datetime index, like so:

from datetime import datetime as dt
import pandas as pd

df = pd.DataFrame(['a', 'b', 'b', 'c', 'b', 'b', 'b'], 
                  [dt(2019, 1, 1), dt(2019, 1, 2), 
                   dt(2019, 1, 3), dt(2019, 1, 4), 
                   dt(2019, 1, 5), dt(2019, 1, 6), 
                   dt(2019, 1, 7)])

If I wanted to compute the number of instances that each value occurs over all times, I can simply call:

>>> print(df[0].value_counts())
b    5
c    1 …

我有一个 dt：

library(data.table)

DT <- data.table(a = c(1,2,3,4,5), b = c(4,5,6,7,8), c = c("X","X","X","Y","Y") ) 

我想在每组 C 列中添加一列 d：

• 第一行值应与b[i]，
• 每个组中的倒数第二行应该是 d[i-1] + 2*b[i]

预期结果：

   a b c d
1: 1 4 X 4
2: 2 5 X 14
3: 3 6 X 26
4: 4 7 Y 7
5: 5 8 Y 23

我尝试使用诸如 shift 之类的函数，但我很难在这里动态更新行（可以这么说），想知道是否有任何优雅的 data.table 样式解决方案？

初始问题陈述

使用 pandas，我想应用可用于 resample() 的函数，但不适用于rolling()。

这有效：

df1 = df.resample(to_freq,
                  closed='left',
                  kind='period',
                   ).agg(OrderedDict([('Open', 'first'),
                                      ('Close', 'last'),
                                                        ]))

这不会：

df2 = df.rolling(my_indexer).agg(
                 OrderedDict([('Open', 'first'),
                              ('Close', 'last') ]))
>>> AttributeError: 'first' is not a valid function for 'Rolling' object

df3 = df.rolling(my_indexer).agg(
                 OrderedDict([
                              ('Close', 'last') ]))
>>> AttributeError: 'last' is not a valid function for 'Rolling' object

您对将滚动窗口的第一个和最后一个值保留在两个不同的列中有何建议？

编辑 1 - 使用可用的输入数据

import pandas as pd
from random import seed
from random import randint
from collections import OrderedDict

# DataFrame
ts_1h = pd.date_range(start='2020-01-01 …

我有一个data.table喜欢：

DT = data.table(ColumnA = c(1.51, 1.86, 3.54, 3.79, 7.7))

我正在尝试创建ColumnB它的下一个值ColumnA：

    columnA      ColumnB  

     1.51          1.86
     1.86          3.54   
     3.54          3.79
     3.79          7.70
     7.70

我尝试了以下操作并且它正在工作，但是现在它不起作用：

          ``` DT[, ColumnB:=c(NA,ColumnA[.I + 2]) ]```

我收到此错误：

.Call() 中的错误：提供了 18391 个项目以分配给“ColumnB”列的 18390 个项目。如果您希望“回收” RHS，请使用 rep() 向您的代码读者明确说明这一意图。

我想知道是否可以在 Postgresql 中使用基于时间的窗口查询。

原始数据位于前三列（日期、销售员、金额）：

第四列表示该销售员在过去三个滚动日内的总金额。

Pandas 有内置函数可以做到这一点，但我想不出任何方法可以使用内置sum() over ()语法在 Postgresql 中做到这一点。我能够做到的唯一方法是使用横向连接和子查询的复杂组合以及时间增量比较的条件，至少可以说这是不优雅的。

Pandas\' 方式（根据记忆，确切的语法可能略有不同） \xe2\x80\x94 无法获得任何简洁的信息：

df.groupby(\'salesman\').rolling(\'3d\').sum()\n

我想总结熊猫系列或每个元素的任何列表的下 5 个到下一个 10 个值的值。例如：

x = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
output = [40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 74, 57, 39, 20, 0, 0 ,0 ,0 ,0]

40 是 6、7、8、9、10 的总和。我并不真正关心最后一个值，它们可以是 nans 或后缀为 0 的可用值的总和。

我知道滚动功能并尝试过：

pd.Series(x).shift(-10).rolling(10, min_periods =1 ).sum()-pd.Series(x).shift(-5).rolling(5, min_periods =1 ).sum()

但它给出了错误的值。如果可以根据变量给出答案（5 和 10 用 x,y 替换）会很有帮助，但我自己也可以弄清楚。请帮忙。

df <- data.frame(date = as.Date(c(rep("2022-01-01", 3), 
                                  rep("2022-02-01", 3),
                                  rep("2022-03-01", 4))),
                 flavor = c("Almond", "Apple", "Apricot", 
                            "Almond", "Maple", "Mint",
                            "Apricot", "Pecan", "Praline", "Pumpkin"))
#>          date  flavor
#> 1  2022-01-01  Almond
#> 2  2022-01-01   Apple
#> 3  2022-01-01 Apricot
#> 4  2022-02-01  Almond
#> 5  2022-02-01   Maple
#> 6  2022-02-01    Mint
#> 7  2022-03-01 Apricot
#> 8  2022-03-01   Pecan
#> 9  2022-03-01 Praline
#> 10 2022-03-01 Pumpkin

上面的 R 数据框逐月跟踪冰淇淋店的冰淇淋口味。2 月份添加了 1 月份没有的两种口味（枫、薄荷），并删除了 1 月份存在的两种口味（苹果、杏）。三月份添加了二月份没有的四种口味（杏子、山核桃、果仁糖、南瓜），并删除了二月份出现的三种口味（杏仁、枫树、薄荷）。

#>          date  flavors.added  flavors.removed
#> 1  2022-01-01 …

我有一个像这样的数据框：

Product_ID    Quantity    Year    Quarter   
  1             100       2021      1          
  1             100       2021      2         
  1              50       2021      3          
  1             100       2021      4          
  1             100       2022      1         
  2             100       2021      1          
  2             100       2021      2          
  3             100       2021      1          
  3             100       2021      2         

我想获取每个 Product_ID 的过去三个月（不包括当月）的总和。

因此我尝试了这个：

df['Qty_Sum_3qrts'] = (df.groupby('Product_ID'['Quantity'].shift(1,fill_value=0)
                         .rolling(3).sum().reset_index(0,drop=True)
                       )

# Shifting 1, because I want to exclude the current row. 
# Rolling 3, because I want to have the 3 'rows' before 
# Grouping by, because I want to …