Question

我遇到了滑动窗口问题的变化！

通常我们设置要滑动的元素数量，但在我的情况下我想滑动时间！

我想达到的目标是一个函数（在这种情况下是线程）能够创造一个＆＃34;时间＆＃34;几秒钟的窗口（由用户提供）。

在这种情况下从队列的第一个元素开始：

[datetime.time（7,6,14,537370），584 add 5秒 - ＆gt; 7：6：19.537370（结束点）并对此区间内的所有元素求和：

 [datetime.time(7, 6, 14, 537370), 584]
 [datetime.time(7, 6, 18, 542798), 761]

总计：584 + 761 = 1345

然后创建另一个＆＃34; windows＆＃34;与第二个元素继续。重要提示：一个项目可以是多个窗口的一部分。同时生成项目，一个具有睡眠n秒然后刷新队列的函数的naif解决方案对我的问题不利。

我认为这是这篇文章的一个变种： Flexible sliding window (in Python)

但仍然无法解决问题！任何帮助或建议将不胜感激。谢谢！

元素列表示例：

 [datetime.time(7, 6, 14, 537370), 584]
 [datetime.time(7, 6, 18, 542798), 761]
 [datetime.time(7, 6, 20, 546007), 848]
 [datetime.time(7, 6, 24, 550969), 20]
 [datetime.time(7, 6, 27, 554370), 478]
 [datetime.time(7, 6, 27, 554628), 12]
 [datetime.time(7, 6, 31, 558919), 29]
 [datetime.time(7, 6, 31, 559562), 227]
 [datetime.time(7, 6, 32, 560863), 379]
 [datetime.time(7, 6, 35, 564863), 132]
 [datetime.time(7, 6, 37, 567276), 651]
 [datetime.time(7, 6, 38, 568652), 68]
 [datetime.time(7, 6, 40, 569861), 100]
 [datetime.time(7, 6, 41, 571459), 722]
 [datetime.time(7, 6, 44, 574802), 560]

...

代码：

 import random
 import time
 import threading
 import datetime
 from multiprocessing import Queue

 q = Queue()

 #this is a producer that put elements in queue

 def t1():
     element = [0,0]
     while True:
         time.sleep(random.randint(0, 5))
         element[0] = datetime.datetime.now().time()
         element[1] = random.randint(0, 1000)
         q.put(element)


 #this is a consumer that sum elements inside a window of n seconds
 #Ineed something a sliding window time of ten seconds that sum all elements for n seconds

 def t2():
     windowsize = 5 #size of the window 5 seconds
     while not queue.empty():
         e = q.get()
         start = e[0] #the first element is the beginning point
         end = start + datetime.timedelta(seconds=windowsize) #ending point
         sum += e[1]
         #some code that solve the problem :)



 a = threading.Thread(target=t1)
 a.start()

 b = threading.Thread(target=t2)
 b.start()

 while True:
     time.sleep(1)

Answer 1

会这样吗？这就是我理解你的问题的方式。这样做是因为它创建了一个跟踪事物的类。您可以通过tw.insert（）或与tw.sum_window（秒）相加来添加此项。

初始化TimeWindow时，可以给它一个max size参数，默认为10秒。当您添加元素或计算总和时，它会进行清理，以便在每次插入或求和操作之前，第一个元素时间e [0] [0]和最后一个元素时间e [n] [0]彼此相差10秒以内。较旧的条目被清除。可以使用“轮询”线程来跟踪您的请求。

我添加了两个队列，因为我不知道您打算如何处理结果。现在，如果您希望将来从现在开始请求数据到5秒，您可以创建一个请求并将其放入队列中。该请求具有随机ID，以便您可以将其与结果匹配。您的主线程需要监视结果队列，五秒后，发送到队列的每个请求都返回相同的id和总和。

如果这不是你想要做的，那么我只是不明白你试图在这里实现什么。即使这已经相当复杂，可能有一种更简单的方法来实现您打算做的事情。

import random
import time
import threading
import datetime
import Queue
import uuid

from collections import deque

q_lock = threading.RLock()


class TimeWindow(object):
    def __init__(self, max_size=10):
        self.max_size = max_size
        self.q = deque()

    def expire(self):
        time_now = datetime.datetime.now()
        while True:
            try:
                oldest_element = self.q.popleft()
                oe_time = oldest_element[0]
                if oe_time + datetime.timedelta(seconds=self.max_size) > time_now:
                    self.q.appendleft(oldest_element)
                    break

            except IndexError:
                break

    def insert(self,elm):
        self.expire()
        self.q.append(elm)

    def sum_window(self, start, end):
        self.expire()
        try:
            _ = self.q[0]
        except IndexError:
            return 0
        result=0
        for f in self.q:
            if start < f[0] < end:
                result += f[1]
            else:
                pass
        return result


tw = TimeWindow()


def t1():
    while True:
        time.sleep(random.randint(0, 3))
        element = [datetime.datetime.now(), random.randint(0,1000)]
        with q_lock:
            tw.insert(element)


def poller(in_q, out_q):
    pending = []
    while True:
        try:
            new_request = in_q.get(0.1)
            new_request["end"] = new_request["start"] + datetime.timedelta(seconds=new_request["frame"])
            pending.append(new_request)
        except Queue.Empty:
            pass

        new_pending = []
        for a in pending:
            if a["end"] < datetime.datetime.now():
                with q_lock:
                    r_sum = tw.sum_window(a["start"], a["end"])
                r_structure = {"id": a["id"], "result": r_sum}
                out_q.put(r_structure)
            else:
                new_pending.append(a)
        pending = new_pending


a = threading.Thread(target=t1)
a.daemon = True
a.start()
in_queue = Queue.Queue()
result_queue = Queue.Queue()

po = threading.Thread(target=poller, args=(in_queue, result_queue,))
po.daemon = True
po.start()

while True:
    time.sleep(1)
    newr = {"id": uuid.uuid4(), "frame": 5, "start": datetime.datetime.now()}
    in_queue.put(newr)
    try:
        ready = result_queue.get(0)
        print ready
    except Queue.Empty:
        pass

Answer 2

garim@wof:~$ python solution.py
1 t1 produce element:  16:09:30.472497   1
2 t1 produce element:  16:09:33.475714   9
3 t1 produce element:  16:09:34.476922   10
4 t1 produce element:  16:09:37.480100   7
solution:  16:09:37.481171   {'id': UUID('adff334f-a97a-459d-8dcc-f28309e25574'), 'result': 19}
5 t1 produce element:  16:09:38.481352   10
solution:  16:09:38.482687   {'id': UUID('0a7481e5-e993-439a-9f7e-2c5aeef86155'), 'result': 19}

它仍然可以工作:(我为函数t1插入的每个元素添加一个计数器。目标是在此时执行求和（result_queue.get）：

16：09：35.472497 ---＆gt; 16：09：30.472497 + 5秒

之前没有。只有这样元素就会消失。下次总和将在以下时间完成：

16：09：35.475714 ---＆gt; 16：09：33.475714 + 5秒

我理解这很难解释..随着你的两个解决方案的时间窗口滑动所以我可以考虑问题解决了:)我将尝试改进功能总和将被执行时，时间触发很重要。我获得了很多有用的知识。谢谢你的帮助。

python时间滑动窗口的变化

2 个答案: