Python Queue.is_empty方法代码示例

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import is_empty [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 is_empty [as 别名]
def test_multiple_empty_dequeues():
	queue = Queue()
	eq_(queue.is_empty(), True)
	eq_(queue.dequeue(), None)
	eq_(queue.dequeue(), None)
	eq_(queue.dequeue(), None)
	eq_(queue.is_empty(), True)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import is_empty [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 is_empty [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 is_empty [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 is_empty [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 is_empty [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 is_empty [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 is_empty [as 别名]
class TestQueue(unittest.TestCase):

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

    def test_basic_initialization_and_repr(self):
        self.assertEqual(repr(self.queue), '[]')

    def test_push(self):
        self.queue.push("!")
        self.assertEqual(repr(self.queue), "['!']")
        self.queue.push("world")
        self.assertEqual(repr(self.queue), "['!', 'world']")
        self.queue.push("Hello")
        self.assertEqual(repr(self.queue), "['!', 'world', 'Hello']")

    def test_pop(self):
        self.queue.push("!")
        self.queue.push("world")
        self.queue.push("Hello")
        self.assertEqual(repr(self.queue), "['!', 'world', 'Hello']")
        self.assertEqual(self.queue.pop(), '!')
        self.assertEqual(repr(self.queue), "['world', 'Hello']")
        self.assertEqual(self.queue.pop(), 'world')
        self.assertEqual(repr(self.queue), "['Hello']")

    def test_peek(self):
        self.queue.push("!")
        self.assertEqual(self.queue.peek(), '!')
        self.queue.push("world")
        self.assertEqual(self.queue.peek(), '!')

    def test_is_empty(self):
        self.assertTrue(self.queue.is_empty())
        self.queue.push("Hello world!")
        self.assertFalse(self.queue.is_empty())

    def test_get_length(self):
        self.assertEqual(self.queue.get_length(), 0)
        self.queue.push("Hello world!")
        self.assertEqual(self.queue.get_length(), 1)
        self.queue.push("Hello world!")
        self.assertEqual(self.queue.get_length(), 2)
        self.queue.pop()
        self.assertEqual(self.queue.get_length(), 1)
        self.queue.pop()
        self.assertEqual(self.queue.get_length(), 0)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import is_empty [as 别名]
 def breadthfirst(self):
     # Generate a breadth first iteration of all nodes in the tree.
     if not self.is_empty():
         fringe = Queue()    # Known nodes not yet yielded.
         fringe.enqueue(self.root())     # start with the root.
         while not fringe.is_empty():
             node = fringe.dequeue()     # Remove node from start of the queue
             yield node                  # Return this node
             for child in self.children(node):
                 fringe.enqueue(child)   # Add children to the back of the queue

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import is_empty [as 别名]
    def show(self):
        if self.root:
            q = Queue()
            q.enqueue(self.root)
            while not q.is_empty():
                childs = Queue()
                display = []
                while not q.is_empty():
                    node = q.dequeue()
                    display.append(node.get_data())
                    childs.enqueue(node)
                print display
                del display[:]

                while not childs.is_empty():
                    node = childs.dequeue()
                    if node.get_left_node():
                        q.enqueue(node.get_left_node())
                    if node.get_right_node():
                        q.enqueue(node.get_right_node())

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import is_empty [as 别名]
class SuperMarket(object):
    
    def __init__(self):
        r.seed()
        self.n_customers = 0
        self.done = False
        self.time_taken = 0
        self.checkouts = []
        for k in range(10):     # build list of checkout queues
            q = Queue()
            self.checkouts.append(q)
        self.staging_queue = Queue()
    
    def add_customer(self):
        # assign a new customer to the staging queue
        c = Customer(r.randint(1, 5))
        self.staging_queue.enqueue(c)
        self.n_customers += 1       # increment n_customers
        
    def clock_a_minute(self):
        self.time_taken += 1
        # add a customer every two minutes.
        if self.n_customers <= 1000 and self.time_taken % 2 == 0:
            self.add_customer()
        # decrement time required for the people at a checkout.
        # place the next customer at any empty checkout
        for checkout in self.checkouts:
            if checkout.is_empty():
                if not self.staging_queue.is_empty(): 
                    checkout.enqueue(self.staging_queue.dequeue())
            else:
                # decrement time left for the customer
                checkout.first().checkout_time -= 1
                if checkout.first().checkout_time <= 0:
                    # if the customer has finished, pull them off the queue
                    checkout.dequeue()
        # assess whether or not we have customers left to deal with
        self.done = self.queues_empty()

    def queues_empty(self):
        # check to ensure that we've still got customers to deal with
        empty = True
        if self.n_customers < 1000:
            empty = False
        else:
            for checkout in self.checkouts:
                if not checkout.is_empty():
                    empty = False
        return empty

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import is_empty [as 别名]
class WordLadderSolver(object):

    def __init__(self):
        self.unprocessed_q = Queue()
        self.alphabet = 'abcdefghijklmnopqrstuvwxyz'
        self.ladder_dict = {}
        self.legal_words = set()
        with open('dictionary.txt', 'r') as f:
            for word in [line.rstrip('\n') for line in f]:
                self.legal_words.add(word)

    def direct_derivs(self, word):
        '''yield valid words with 1 char difference to word.'''
        for i, c in enumerate(word):
            for x in self.alphabet:
                if x == c:
                    pass
                else:
                    new_word = word[:i] + x + word[i + 1:]
                    if new_word in self.legal_words and\
                            new_word not in self.ladder_dict:
                        yield new_word

    def solve(self, start, end):
        # put start word in queue.
        self.unprocessed_q.enqueue(start)
        check_end = start
        self.ladder_dict[start] = None
        # loop until queue is empty.
        while not self.unprocessed_q.is_empty() and check_end != end:
            # pop the next word from the queue.
            next_word = self.unprocessed_q.dequeue()
            # add derivs of next_word to queue.
            for deriv in self.direct_derivs(next_word):
                self.unprocessed_q.enqueue(deriv)
                self.ladder_dict[deriv] = next_word
            check_end = next_word
        # did we find a path to the end word?
        if check_end == end:
            # return the path.
            path = [end]
            next_key = self.ladder_dict[end]
            while next_key is not None:
                path.append(next_key)
                next_key = self.ladder_dict[next_key]
            return path
        else:
            return 'No path found.'

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import is_empty [as 别名]
def simulation(num_seconds, pages_per_minute):
	lab_printer = Printer(pages_per_minute)
	print_queue = Queue()
	waiting_times = []
	for current_second in range(num_seconds):
		if new_print_task():
			task = Task(current_second)
			print_queue.enqueue(task)
		if (not lab_printer.busy()) and (not print_queue.is_empty()):
			next_task = print_queue.dequeue()
			waiting_times.append(next_task.wait_time(current_second))
			lab_printer.start_next(next_task)
		lab_printer.tick()
	average_wait = sum(waiting_times) / len(waiting_times)
	print("Average Wait %6.2f secs %3d tasks remaining."
				%(average_wait, print_queue.size()))

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import is_empty [as 别名]
def bfs(graph, start_vertex):
    start_vertex.distance = 0
    start_vertex.color = "gray"
    start_vertex.predecessor = None
    queue = Queue()
    queue.enqueue(start_vertex)
    while not queue.is_empty():
        vertex = queue.dequeue()
        for neighbour_key in vertex.get_neighbours():
            neighbour = graph.get_vertex(neighbour_key)
            if neighbour.color != "white":
                continue
            neighbour.distance = vertex.distance + 1
            neighbour.color = "gray"
            neighbour.predecessor = vertex
            queue.enqueue(neighbour)
        vertex.color = "black"