Python:类编程和排队 [英] Python : class programming and queuing

问题描述

我遇到了问题.我找到了一个我在下面解释的解决方案，但我想要一些正确的建议来解决它.

问题来了:

我有一个名为 Item 的类对象.这个Item 有一个方法，调用make_request，它在服务器上发出一个GET 请求，并保存结果.现在，我已经实现了 3 个调用 make_request 的 Item 对象.Item 对象将每 3 分钟调用一次该方法，但是这些 make_requests 必须比前一个对象的调用延迟 1 分钟.

示例:

• 14:00 - Item0.make_request
• 14:01 - Item1.make_request
• 14:02 - Item2.make_request
• 14:03 - Item0.make_request
• 14:04 - Item1.make_request
• 14:05 - Item2.make_request
• 14:06 - Item0.make_request
• 14:07 - Item1.make_request
• 14:08 - Item2.make_request
• 14:09 - Item0.make_request
• 14:10 - Item1.make_request
• 14:11 - Item2.make_request
• 14:12 - Item0.make_request
• 14:13 - Item1.make_request
• 14:14 - Item2.make_request...等

我实际上做的是一个 while 循环，我在其中检查时间分钟并调用正确对象的方法.

from datetime import datetime项目0 = 项目(名称=项目0")项目 1 = 项目(名称 =项目 1")项目 2 = 项目(名称 =项目 2")为真:如果 str(datetime.now().time.minute[-1]) 在 ['0', '3', '6']:Item0.make_request()如果 str(datetime.now().time.minute[-1]) 在 ['1', '4', '7']:Item1.make_request()如果 str(datetime.now().time.minute[-1]) 在 ['2', '5', '8']:Item2.make_request()

这是一个解决方案，但它不干净，我不喜欢它.它也缺少1分钟.我在考虑使用队列.

我在等你的建议:)

更强大的东西

非常感谢您的回答.我为第一个问题找到了一个很好的解决方案.

现在，我问自己是否可以在相同的上下文中使用队列.这个想法是独立于前一个 make_request 的结果调用 make_request.

例如:在 14:00:00 我调用 Item0.make_request.不幸的是，获得Item0.make_request 的结果需要60 多秒，但我希望我的Item1.make_request 在14:01:00 被独立调用.>

有时会发生

解决方案

通常，当你有多个项目要做同样的事情时，最好把它们放在一个列表中:

items = [Item(name=Item0"), Item(name=Item1"), Item(name=Item2")]

然后，不需要特殊的逻辑来查看当前分钟是哪一分钟.只需按顺序运行它们，延迟 1 分钟:

虽然为真:对于项目中的项目:item.make_request()time.sleep(60) # 60 秒

有一个缺点，您可能会也可能不会在意:实际上，两个请求之间的时间将是 60 秒加上 make_request() 所花费的时间.有很多方法可以避免这种情况，但您可能并不关心这些细节.

I facing a problem. I found a solution I'm explaining below but I want some advice aout to right way to resolve it.

Here is the problem:

I have a class object called Item. This Item has a method, call make_request which makes a GET request on a server, and save the result. Now, I have implemented 3 Item object which calls make_request. The Item objects gonna call the method each 3 minutes, but these make_requests must be delayed by 1 minutes from the previous object's call.

Example :

• 14:00 - Item0.make_request
• 14:01 - Item1.make_request
• 14:02 - Item2.make_request
• 14:03 - Item0.make_request
• 14:04 - Item1.make_request
• 14:05 - Item2.make_request
• 14:06 - Item0.make_request
• 14:07 - Item1.make_request
• 14:08 - Item2.make_request
• 14:09 - Item0.make_request
• 14:10 - Item1.make_request
• 14:11 - Item2.make_request
• 14:12 - Item0.make_request
• 14:13 - Item1.make_request
• 14:14 - Item2.make_request ... etc

What I do actully is a while loop where I check the time minute and call the right object's method.

from datetime import datetime

Item0 = Item(name="Item0")
Item1 = Item(name="Item1")
Item2 = Item(name="Item2")

while True:
   if str(datetime.now().time.minute[-1]) in ['0', '3', '6']: 
      Item0.make_request()
   if str(datetime.now().time.minute[-1]) in ['1', '4', '7']: 
      Item1.make_request()
   if str(datetime.now().time.minute[-1]) in ['2', '5', '8']: 
      Item2.make_request()

This is a solution, but it's not clean and I don't like it. It is also missing 1 minute. I was thinking about using Queue.

I'm waiting for your advice :)

EDIT : something more robust

Thank a lot for your answers. I found a good solution for the first problem.

Now, I'm asking myself if I can, in the same context, use a Queue. The idea is to call the make_request independently of the result of the previous make_request.

For example: At 14:00:00 I call Item0.make_request. Unfortunately, it takes more than 60 seconds to get the result of Item0.make_request but I want my Item1.make_request to be called independently at 14:01:00.

It happens sometimes

解决方案

Usually, when you have a number of items, on which the same thing is to be done, it is best to keep them in a list:

items = [Item(name="Item0"), Item(name="Item1"), Item(name="Item2")]

Then, no special logic is needed to see which the current minute is. Just run them sequentially with 1 minute delay:

while True:
    for item in items:
        item.make_request()
        time.sleep(60)  # 60 seconds

There is one drawback, about which you may or may not care: as it is, the time between two requests will be 60 seconds plus the time taken by make_request(). There are ways to avoid that, but perhaps you don't care about such details.

这篇关于Python:类编程和排队的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！