检查给定元素是否在队列中

Question

我创建了一个队列，我需要检查给定的元素是否在该队列中，并根据它运行程序！以下是我的代码，它没有执行我想要的操作，它为所有输入提供 "duplicate" ！请帮忙！

def Arrival(vehicle):

    if vehicle in q1.items:
        print "duplicate!"

    else:

        if q1.size()<10:
            if q3.isEmpty()==False:
                EnterOld=q3.dequeue()
                q1.enqueue(EnterOld)
                print "The car number "+str(EnterOld)+" can enter now from the waiting line!"
        else:
            print"the car number "+str(vehicle)+" can enter the park!"

Answer 1

问题出在您的 if 语句中。

if vehicle in q1.items or q3.items:

它的作用是检查 'is vehicle an element of q1.items'，如果不是，它会在评估为布尔值时检查“is q3.items”True?

你应该这样做：

if vehicle in q1.items or vehicle in q3.items:

Answer 2

据我所知，如果车辆同时在 q1 和 q3 中，则该车辆是重复的，所以这应该是

如果 q1.items 中的车辆和 q3.items 中的车辆：

Answer 3

class queue:
def __init__(self):
    self.items = []

def __iter__(self):
    for i in self.items:
        yield i

def isEmpty(self):
    return self.items == []

def enqueue(self,item):
    self.items.insert(0,item)

def dequeue(self):
    return self.items.pop()

def size(self):
    return len(self.items)

def front(self):
    return self.items[len(self.items)-1]

def index(self,item):
    return self.items.index(item)

Answer 4

这是我的代码。希望它可以帮助某人。

我将集合作为缓存添加到队列 class。此缓存用于任务唯一性检查。而且，它被用来在Queueclass.

中实现__contains__魔术方法

唯一性可以通过两种方式定义。首先，任务在队列的整个生命周期中都是唯一的。换句话说，队列拒绝接受重复的任务，即使任务完成并从队列中删除也是如此。我将其实现为“be_unique_in_all_items”。其次，任务仅在队列中的现有任务中是唯一的。这意味着任务完成后可以接受。我将其实现为“be_unique_in_existing_items”。

from queue import Queue
from traceback import print_exc


class MQueue(Queue):

    def __init__(self,
                 **kwargs):
        super().__init__(maxsize=kwargs.get("maxsize", 0))

        self._be_unique_in_existing_items = kwargs.get("be_unique_in_existing_items", False)
        self._be_unique_in_all_items = kwargs.get("be_unique_in_all_items", False)

        if self._be_unique_in_existing_items and self._be_unique_in_all_items:
            raise ValueError("Choose one criteria")

        self.cache = set()

    def get(self, *args, **kwargs):
        result = super().get(*args, **kwargs)

        if result:
            if self._be_unique_in_existing_items:
                self.cache.remove(result)

        return result

    def put(self, item, *args, **kwargs):
        if self._be_unique_in_existing_items or self._be_unique_in_all_items:
            if item in self.cache:
                raise ValueError("The given item exists in cache.")
            self.cache.add(item)

        return super().put(item, *args, **kwargs)

    def __contains__(self, item):
        if self._be_unique_in_existing_items or self._be_unique_in_all_items:
            return self.cache.__contains__(item)
        else:
            return Queue.__contains__(item)  # will raise you error


if __name__ == "__main__":
    # ordinary queue
    ordinary_queue_obj = MQueue(maxsize=0)

    ordinary_queue_obj.put(1)
    ordinary_queue_obj.put(1)

    try:
        print(1 in ordinary_queue_obj)
    except Exception:
        print_exc()

    # be unique in existing queue
    unique_in_existing_queue_obj = MQueue(maxsize=0,
                                          be_unique_in_existing_items=True)

    unique_in_existing_queue_obj.put(1)

    print(1 in unique_in_existing_queue_obj)

    try:
        unique_in_existing_queue_obj.put(1)
    except ValueError:
        print_exc()

    task = unique_in_existing_queue_obj.get()
    unique_in_existing_queue_obj.task_done()
    unique_in_existing_queue_obj.put(task)

    # be unique in all queue
    unique_in_all_queue_obj = MQueue(maxsize=0,
                                     be_unique_in_all_items=True)

    unique_in_all_queue_obj.put(1)
    print(1 in unique_in_all_queue_obj)

    try:
        unique_in_all_queue_obj.put(1)
    except ValueError:
        print_exc()

    task = unique_in_all_queue_obj.get()
    unique_in_all_queue_obj.task_done()
    try:
        print(task in unique_in_all_queue_obj)
        unique_in_all_queue_obj.put(task)
    except ValueError:
        print_exc()

注意： 集合只能包含可哈希对象。对于不可散列的对象，请改用列表。

检查给定元素是否在队列中

Check whether a given element is inside queue

python

queue

python-2.7