Python Queue.peek方法代码示例

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

    def __init__(self):
        self.dogs = Queue()
        self.cats = Queue()
        self.ordinal = 0

    def enqueue(self, animal):
        queue = self.dogs if animal.type_ == Animal.DOG else self.cats
        queue.enqueue((self.ordinal, animal))
        self.ordinal += 1

    def dequeue_dog(self):
        return self.dogs.dequeue()[1]

    def dequeue_cat(self):
        return self.cats.dequeue()[1]

    def dequeue_any(self):
        try:
            dog_ord, _ = self.dogs.peek()
        except ValueError:
            dog_ord = sys.maxint
        try:
            cat_ord, _ = self.cats.peek()
        except ValueError:
            cat_ord = sys.maxint
        queue = self.dogs if dog_ord < cat_ord else self.cats
        return queue.dequeue()[1]

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import peek [as 别名]
class Shunting(object):
	def __init__(self, input):
		self.inputQueue = Queue()
		self.outputQueue = Queue()
		self.operatorStack = Stack()
		self.input = input
		self.operators = ["^", "*", "/", "%", "//", "+", "-", "(", ")"]
		
		self.processInput(self.input)
		print(self.inputQueue.peek())
		self.shunt()

	def processInput(self, input):
		holdItem = ""
		for i in range(0, len(input)):
			if input[i] in self.operators:
				if holdItem <> "":
					self.inputQueue.enqueue(holdItem)
				self.inputQueue.enqueue(input[i])
				holdItem = ""
			else:
				holdItem = holdItem + input[i]
		if holdItem <> "":
			self.inputQueue.enqueue(holdItem)
	
	def shunt(self):
		while self.inputQueue.peek() <> []:
			holdItem = ""
			holdItem = self.inputQueue.dequeue()
	
			if holdItem == "(":
				self.operatorStack.push(holdItem)
			elif holdItem == ")":
				temp = self.operatorStack.pop()
				while temp <> "(":
					self.outputQueue.enqueue(temp)
					temp = self.operatorStack.pop()
			elif holdItem in self.operators:
				if self.operatorStack.peek() == []:
					self.operatorStack.push(holdItem)
				else:
					while holdItem <> "":
						if self.operatorStack.peek() == []:
							self.operatorStack.push(holdItem)
							holdItem =""
						else:	
							result = compareOperators(holdItem, self.operatorStack.peek()[0])
							if result == 1:
								self.operatorStack.push(holdItem)
								holdItem = ""
							elif result == -1:
								self.outputQueue.enqueue(self.operatorStack.pop())

			else:
				self.outputQueue.enqueue(holdItem)

		while self.operatorStack.peek() <> []:
			self.outputQueue.enqueue(self.operatorStack.pop())

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import peek [as 别名]
def main():
	q = Queue()
	q.isEmpty()
	q.enqueue(9)
	q.enqueue(2)
	q.enqueue(3)
	q.isEmpty()
	q.size()
	q.peek()
	q.print_list()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import peek [as 别名]
 def test_peek(self):
     q = Queue()
     with self.assertRaises(IndexError) as context:
         q.peek()
     self.assertEqual(context.exception.message,
                      'Queue is empty, cannot peek.')
     q.enqueue(1)
     q.enqueue('a')
     q.enqueue('bob')
     q.enqueue(1.0)
     self.assertEquals(q.peek(), 1)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import peek [as 别名]
def test_enqueue_and_peek(li, result):
    """Test enqueue method."""
    from queue import Queue
    new_list = Queue()
    for item in li[::-1]:
        new_list.enqueue(item)
    assert new_list.peek() == result

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import peek [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 peek [as 别名]
def test_peek():
    """Return the next value in the queue."""
    from queue import Queue
    my_queue = Queue()
    my_queue.enqueue('monkey')
    my_queue.enqueue('chicken')
    my_queue.enqueue('baby')
    assert my_queue.peek() == 'chicken'

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import peek [as 别名]
def test_size_with_remove():
    queue = Queue()
    queue.enqueue("Bacon")
    queue.enqueue("Beer")
    queue.enqueue("Cow")
    queue.enqueue("Whiskey")
    assert queue.dequeue() == "Bacon"
    assert queue.peek() == "Beer"

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import peek [as 别名]
def test_basics():
  q = Queue()

  for i in range(10):
    q.push(i)

  items = list(reversed(range(10)))
  while(q.peek() != None):
    assert q.pop() == items.pop()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import peek [as 别名]
def createTree(allNodes):
	"""Takes in dictionary of Huffman nodes. Creates a Huffman Tree based on each node's frequencies."""
	listNodes = allNodes.values()
	listNodes.sort(compareHuffNodes)
		
	singleNodes = Queue() # will contain all HTNodes at first
	comboNodes = Queue() # will contain trees - nodes with others hanging off
	while len(listNodes) > 0:
		singleNodes.enqueue(listNodes.pop(0)) # these will be sorted with least weight at front
	
	
	while len(singleNodes) + len(comboNodes) > 1:
		i = 0
		temp = [None, None]
		for i in range(2): # tiny for loop saves code!
		
			singleNodeWeight = None
			comboNodeWeight = None
			if singleNodes.peek() != None:
				singleNodeWeight = singleNodes.peek().getWeight()
			if comboNodes.peek() != None:
				comboNodeWeight = comboNodes.peek().getWeight()
				
			if singleNodeWeight == None:
				temp[i] = comboNodes.dequeue()
			elif comboNodeWeight < singleNodeWeight and comboNodeWeight != None:
				temp[i] = comboNodes.dequeue()
			else: # they can't both be None, so no need to check if singleNodeWeight is None
				temp[i] = singleNodes.dequeue()
					
		parent = HuffmanTreeNode()
		parent.setLeftChild(temp[0]) 
		parent.setRightChild(temp[1])
		comboNodes.enqueue(parent)
		
	root = comboNodes.dequeue() # should only be one left
	
	tree = HuffmanTree(root)
	return tree

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import peek [as 别名]
class Stack(object):
    def __init__(self):
        self.myQueue = Queue()
        self.mySize = 0

    def push(self, value):
        self.myQueue.push(value)
        self.mySize = self.mySize + 1

    def size(self):
        return self.mySize

    def peek(self):
        last = None

        while True:
            popped = self.myQueue.peek()

            if not popped:
                break

            last = popped

        return last

    def pop(self):
        last = None

        newQueue = Queue()

        poppedFromQueue = 0
        queueSize = self.myQueue.size()

        while True:
            popped = self.myQueue.pop()

            if poppedFromQueue != queueSize:
                newQueue.push(popped)

            poppedFromQueue += 1

            if not popped:
                break

            last = popped

        self.mySize = self.mySize - 1
        self.myQueue = newQueue
        return last

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import peek [as 别名]
class Deque(object):
    """Make deque object."""
    def __init__(self, val=None):
        """Make new deque."""
        self._container_q = Queue(val)

    def pop(self):
        """Pop item from end of deque."""
        return self._container_q._container.shift()

    def pop_left(self):
        """Pop item from beginning of deque."""
        return self._container_q._container.pop()

    def append(self, val):
        """Append item to end of deque."""
        self._container_q._container.append(val)

    def append_left(self, val):
        """Append item to beginning of deque."""
        self._container_q._container.insert(val)

    def peek(self):
        """Return value at end of deque."""
        cur = self._container_q._container.head
        if cur == self._container_q._container._mark:
            return None
        while cur.next_node != self._container_q._container._mark:
            cur = cur.next_node
        return cur.get_data()

    def peek_left(self):
        """Return value at beginning of deque."""
        cur = self._container_q._container.head
        if cur == self._container_q._container._mark:
            return None
        return self._container_q.peek()

    def size(self):
        """Return size of deque."""
        return self._container_q.size()

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

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

    def test_init(self):
        self.assertEqual(self.queue.get_size(), 0)
        new_queue = Queue("Bob")
        self.assertEqual(new_queue.get_size(), 1)

    def test_enqueue(self):
        self.queue.enqueue("Bob")
        self.assertEqual(self.queue.get_size(), 1)

    def test_dequeue(self):
        self.queue.enqueue("Bob")
        dequeued_item = self.queue.dequeue()
        self.assertEqual(dequeued_item, "Bob")
        another_dequeued_item = self.queue.dequeue()
        self.assertIsNone(another_dequeued_item)

    def test_peek(self):
        self.queue.enqueue("Bob")
        self.queue.enqueue("Bill")
        self.queue.enqueue("Boris")
        peeked_item = self.queue.peek()
        self.assertEqual(peeked_item, "Bob")

    def test_clear(self):
        for i in range(0, 100):
            self.queue.enqueue("Bob")
        self.assertEqual(self.queue.get_size(), 100)
        self.queue.clear()
        self.assertEqual(self.queue.get_size(), 0)

    def test_get_size(self):
        self.assertEqual(self.queue.get_size(), self.queue.linked_list.size)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import peek [as 别名]
class Deque(object):
    """Create a deque data structure."""
    def __init__(self):
        self.q = Queue()
        # name q's container attribute 'dll' (which is a doubly linked list)
        self.dll = self.q.container

    def append(self, value):
        """Insert value at tail of deque."""
        self.dll.append(value)

    def appendleft(self, value):
        """Insert value at head of deque."""
        self.dll.insert(value)

    def pop(self):
        """Return right/tail value and removes from deque."""
        return self.dll.shift()

    def popleft(self):
        """Return left/head value and removes from deque."""
        return self.dll.pop()

    def peek(self):
        """Return tail value in deque without removing it."""
        return self.q.peek()

    def peekleft(self):
        """Return head value in deque without removing it."""
        if self.dll.head_node is None:
            return None
        return self.dll.head_node.value

    def size(self):
        """Return size of deque, 0 if empty."""
        return self.q.size()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import peek [as 别名]
class Printer():
 
    def __init__(self, speed):
        self.speed = speed
        self.queue = Queue()
    
    def isIdle(self):
        return self.queue.isEmpty()
    
    def addTask(self, t):
        self.queue.enqueue(t)
        
    def removeTask(self):
        if not self.queue.isEmpty():
            return self.queue.dequeue()
    
    def getQueueSize(self):
        return self.queue.size()
    
    def getTimeToFinishCurrentTask(self):
        if self.queue.isEmpty():
            return 0
        else:
            return self.queue.peek().getPage() / float(self.speed)