Python Queue.enqueue方法代码示例

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
def test_enqueue():
    """Fill an empty contructor argument and assert len, deque)"""
    filling_this = Queue(())
    for i in xrange(40):
        filling_this.enqueue(i)
    assert len(filling_this) == 40
    assert filling_this.dequeue() == 0

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
 def pop(self): 
     temp = Queue()
     while self.__q.count() > 1:
         temp.enqueue(self.__q.dequeue())
     result = self.__q.dequeue()
     self.__q = temp    
     return result

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
class TestMaxSizeQueue(unittest.TestCase):

	def setUp(self):
		self.max_size = 10
		self.obj = Queue(max_size=self.max_size)


	def tearDown(self):
		self.obj = Queue(max_size=self.max_size)


	def test_queue_empty(self):
		self.assertTrue(self.obj.is_empty())


	def test_raises_queue_full_error(self):
		for i in range(self.max_size):
			self.obj.enqueue(i)

		self.assertRaises(QueueFullError, lambda: self.obj.enqueue(20))


	def test_queue_top_item(self):
		items = [2, 4, 5, 5]

		for item in items:
			self.obj.enqueue(item)

		self.assertEqual(self.obj.dequeue(), items[0])

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
class QueueAllTestCase(unittest.TestCase):
    """Tests of (non-empty) Queue."""

    def setUp(self):
        """Set up an empty queue."""

        self.queue = Queue()

    def tearDown(self):
        """Clean up."""

        self.queue = None

    def testAll(self):
        """Test enqueueing and dequeueing multiple elements."""

        for item in range(20):
            self.queue.enqueue(item)
            self.assertFalse(self.queue.is_empty(), \
                            'is_empty() returned True on a non-empty Queue!')

        expect = 0
        while not self.queue.is_empty():
            self.assertEqual(self.queue.dequeue(), expect, \
                             'Something wrong on top of the Queue! Expected ' \
                             + str(expect) + '.')
            expect = expect + 1

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
class TestQueue(unittest.TestCase):

	def setUp(self):
		self.obj = Queue()


	def tearDown(self):
		self.obj = Queue()


	def test_empty_queue(self):
		self.assertTrue(self.obj.is_empty())


	def test_raises_queue_empty_error(self):
		self.assertRaises(QueueEmptyError, lambda: self.obj.dequeue())


	def test_queue_size(self):
		size = 20
		for i in range(size):
			self.obj.enqueue(i)

		self.assertEqual(self.obj.size(), size)


	def test_queue_top_item(self):
		size = 20
		for i in range(size):
			self.obj.enqueue(i)

		self.assertEqual(self.obj.dequeue(), 0)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
def simulation(seconds, ppm):

    printer = Printer(ppm)
    q = Queue()
    waittimes = []

    for currentSecond in range(seconds):

        if newPrintTask():
            task = Task(currentSecond)
            q.enqueue(task)

        if (not printer.isBusy()) and (not q.isEmpty()):
            nextTask = q.dequeue()
            waittimes.append(nextTask.getTimeWaited(currentSecond))

            printer.startNextTask(nextTask)


        printer.countdown()

    averageWait = sum(waittimes)/len(waittimes)

    print "Average wait of %6.2f seconds; %3d tasks remaining." \
            % (averageWait, q.size())
    return

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
    def breadth_first_search(self, tree, parent, visited=[]):

        # create a queue from a list
        queue = Queue()

        # add the parent node to the queue
        queue.enqueue(parent)

        # mark node as visited to ensure it's not traversed again
        visited = visited + [parent]

        # exit when the queue is empty
        while queue.is_empty() == False:

            # dequeue element            
            parent = queue.dequeue()

            # get the children of the parent
            children = tree[parent]

            # iterates through all the children
            for child in children:

                # only traverse nodes not already visited
                if child not in visited:
                
                    # add child to queue for exporation
                    queue.enqueue(child)

                    # visit child node
                    visited = visited + [child]

        # return all visited
        return visited

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
def test_enqueue_nonempty():
    """Test enqueue on non-empty list."""
    from queue import Queue
    my_queue = Queue()
    my_queue.enqueue('chicken')
    my_queue.enqueue('monkey')
    assert my_queue.container.head.val == 'monkey'

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
    def test_Queue_dequeue(self):
        q1 = Queue()

        q1.enqueue(0)
        q1.enqueue(1.2)
        q1.enqueue("3.4")
        q1.enqueue([5, 6])
        q1.enqueue((7, 8))
        q1.enqueue({9, 10})

        self.assertEqual(q1.size(), 6)
        self.assertEqual(q1.dequeue(), 0)
        self.assertEqual(q1.size(), 5)
        self.assertEqual(q1.dequeue(), 1.2)
        self.assertEqual(q1.size(), 4)
        self.assertEqual(q1.dequeue(), "3.4")
        self.assertEqual(q1.size(), 3)
        self.assertEqual(q1.dequeue(), [5, 6])
        self.assertEqual(q1.size(), 2)
        self.assertEqual(q1.dequeue(), (7, 8))
        self.assertEqual(q1.size(), 1)
        self.assertEqual(q1.dequeue(), {9, 10})
        self.assertEqual(q1.size(), 0)

        with self.assertRaises(ValueError):
            q1.dequeue()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
def bfsreduceall(sudokuObject):
    source = sudokuObject.solutiondriverNoGuess()
    if source == "Bad Response":
        return None
    elif type(source) is Sudoku:
        return source

    Q = Queue([sudokuObject])
    loop = 1
    startminnodes = None
    while not Q.isempty():
        # print("loop no",loop)
        if loop > 2: return dfsreduceall(sudokuObject)
        # if startminnodes is not None:
        #     for node in startminnodes:print(node.allowedset,node.id)
        # print("Q.unqueue()",Q)
        v = Q.unqueue()
        unfnodes = v.getOrderedMinnodesUnfilled()  # unfinished nodes
        if loop == 1: startminnodes = unfnodes
        for minnode in unfnodes:
            for permutedvalue in minnode.allowedset:
                global numsudokuobjects
                numsudokuobjects += 1
                newsudokuObject = sudokuObject.__deepcopy__()
                newsudokuObject.nodes[minnode.id].setValue(permutedvalue)
                postsolveobject = newsudokuObject.solutiondriverNoGuess()
                if type(postsolveobject) is Sudoku:
                    return postsolveobject
                elif postsolveobject != "Bad Response":
                    Q.enqueue(newsudokuObject)
                loop += 1

    return None

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
    def bfs(self, src=None, onnode=lambda x: x):
        if len(self.vertices) == 0:
            return None

        if src is None:
            src = self.vertices[0]

        q = Queue()

        for v in self.vertices:
            v.distance = sys.maxint
            v.parent = None

        src.distance = 0
        q.enqueue(src)

        while not q.empty():

            d = q.dequeue()
            onnode(d)
            for node in d.outputs:
                if node.distance == sys.maxint:
                    node.distance = d.distance + 1
                    node.parent = d
                    q.enqueue(node)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
 def bfs(cls, G, s):
     '''广度优先搜索,注意是从特定点出发的，所以广度优先搜索不一定访问到
     图中的所有节点，只能访问到该点可到达的节点
     '''
     bfs_visit_oder = []
     color = {}
     d = {}
     pi = {}
     for node in G.nodes():
         color[node] = cls.white
         d[node] = float("inf")
         pi[node] = None
     color[s] = cls.gray
     d[s]    = 0
     Q = Queue( len(G) ) #队列的长度等于图的节点数目，也就是图的长度
     Q.enqueue(s)
     while not Q.is_empty() :
         u = Q.dequeue()
         for eachsucc in G.succ(u):
             if color[eachsucc] == cls.white:
                 color[eachsucc] = cls.gray
                 d[eachsucc] += 1
                 pi[eachsucc] = u
                 Q.enqueue(eachsucc)
         color[u] = cls.black
         bfs_visit_oder.append(u)
     return bfs_visit_oder

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
def test_enqueue_dequeue_one_item():
	queue = Queue()
	queue.enqueue(5)	
	eq_(queue.is_empty(),False)
	eq_(queue.dequeue(), 5)
	eq_(queue.is_empty(),True)
	eq_(queue.dequeue(), None)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
    def bfs(self):

        queue = Queue()

        visited = []

        queue.enqueue(self.head)
        visited.append(self.head)

        while not queue.is_empty():

            vertex = queue.front().data
            queue.dequeue()

            print vertex

            node = self.adj[vertex].head

            while node is not None:

                adj_vertex = node.data

                if adj_vertex not in visited:

                    visited.append(adj_vertex)

                    queue.enqueue(adj_vertex)

                node = node.next

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import enqueue [as 别名]
def test_enqueue():
    my_queue = Queue()
    my_queue.enqueue(1)
    my_queue.enqueue(2)
    my_queue.enqueue(3)
    assert my_queue.container.head.value == 1
    assert my_queue.tail.value == 3