Python Queue.pop方法代码示例

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

        # Act + Assert
        with self.assertRaises(ValueError):
            q.pop()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import pop [as 别名]
def isShuffle(str1, str2, str3):
    A = Queue() # First in, first out (FIFO queue)
    B = Queue()
    
    for i in range(len(str1)-1, 0):
        A.push(str1[i])
    
    for j in range(len(str2)-1, 0):
        B.push(str1[i])
    
    for c in str3:
        if c in A:
            # non supported operation in Python for queues: we can do:
            # while A.size()>0, A.pop(), but it is too late once popped if
            # the letter is not the one we are processing in word c.
            # We use lists instead and increment indexes accordingly.
            if not c == A.pop():
                if not c == B.pop():
                    return False
        elif c in B:
            if not c == B.pop():
                if not c == A.pop():
                    return False
        else:
            return False

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import pop [as 别名]
class CallCenter:
    def __init__(self):
        self.active_calls = []
        self.waiting_calls = Queue()
        self.respondents = []
        self.free_respondents = Queue()
        self.managers = []
        self.directors = []

    def dispatch_call(self, call):
        '''dispatches a new call'''
        if len(self.free_respondents) == 0:
            self.waiting_calls.enqueue(call)
            return  # all respondents are currently busy, please wait

        self._dispatch_call(call)

    def escalate(self, call):
        '''escalates a call to the next employee level. can be because the employee is busy or
        not equipped to handle the call'''
        current_employee = call.employee
        next_employee = current_employee.boss

        if not next_employee.free:
            next_employee = next_employee.boss  # simplification: assume director is free

        call.employee = next_employee
        next_employee.free = False
        current_employee.free = True
        if current_employee.role == Role.respondent:
            self.free_respondents.append(current_employee)

    def call_end_receiver(self, call):
        '''listens for signal that call has ended'''
        self.active_calls.remove(call)
        call.employee.free = True

    def employee_free_receiver(self, employee):
        '''listens for signal that employee has become free'''
        self.free_respondents.append(employee)
        next_call = self.waiting_calls.pop()
        if next_call:
            self._dispatch_call(next_call)

    def _dispatch_call(self, call):
        if call.employee:
            return  # the call is already dispatched

        free_respondent = self.free_respondents.pop()
        call.employee = free_respondent
        free_respondent.free = False
        call.start()
        self.active_calls.append(call)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import pop [as 别名]
class Queue2Stack:

	def __init__(self,size1,size2):
		self.queue1 = Queue(size1)
		self.queue2 = Queue(size2)

	def push(self,data):
		self.queue1.push(data)

	def pop(self):
		while self.queue1.size!=1:
			self.queue2.push(self.queue1.pop())
		result = self.queue1.pop()
		while not self.queue2.isEmpty():
			self.queue1.push(self.queue2.pop())
		return result

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import pop [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 pop [as 别名]
    def test_push_complex(self):
        # Arrange
        q = Queue()

        # Act
        q.push('a')
        q.push('b')
        q.push('c')
        q.pop()
        q.pop()
        q.pop()
        q.push('d')
        q.push('e')

        # Assert
        self.assertEqual(2, len(q))
        self.assertEqual('d', q.pop())
        self.assertEqual('e', q.pop())
        self.assertEqual(0, len(q))

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import pop [as 别名]
    def pop(self):
        q = Queue()
        while self.values.size > 1:
            q.push(self.values.pop())
        last_element = self.values.pop()

        while q.size > 0:
            self.values.push(q.pop())

        return last_element

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

        # Act
        q.push('a')

        # Assert
        self.assertEqual(1, len(q))
        self.assertEqual('a', q.pop())
        self.assertEqual(0, len(q))

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

        # Act
        q.push('a')
        q.push('b')
        q.push('c')

        # Assert
        self.assertEqual(3, len(q))
        self.assertEqual('a', q.pop())
        self.assertEqual(2, len(q))

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

    # Adds value to the end of the Stack.
    # Complexity: O(1)
    def push(self, value):
        self.values.push(value)

    # Returns value from the end of the Stack and removes it.
    # Complexity: O(1)
    def pop(self):
        q = Queue()
        while self.values.size > 1:
            q.push(self.values.pop())
        last_element = self.values.pop()

        while q.size > 0:
            self.values.push(q.pop())

        return last_element

    # Returns value from the end of the Stack without removing it.
    # Complexity: O(1)
    def peek(self):
        if self.values.size >= 1:
            last_element = self.pop()
            self.push(last_element)
            return last_element

        else:
            return None

    # Returns the number of elements in the Stack.
    # Complexity: O(1)
    def size(self):
        return self.values.size

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import pop [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 pop [as 别名]
	def traverse_breadth(self):
		if self.root is None:
			return []

		q = Queue()
		q.push(self.root)		
		values = []
		while not q.is_empty:
			node = q.pop()
			values.append(node.value)
			if node.lt is not None:
				q.push(node.lt)
			if node.gt is not None:
				q.push(node.gt)
		return values

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import pop [as 别名]
class ThreadPool(object):
    def __init__(self, core_threads=10, max_threads=20, wait_time=1):
        self._queue = Queue()
        self.core_threads = core_threads
        self.max_threads = max_threads
        self._threads = set()
        self._thread_lock = Lock()
        self._shutdown = False
        self._wait_time = wait_time

    @class_method
    def get_instance(cls):
        if hasattr(cls, '_instance'):
            return cls._instance

        with Lock():
            if hasattr(cls, '_instance'):
                return cls._instance

            cls._instance = ThreadPool()

        return cls._instance

    def submit_task(self, func, *arg, **kwarg):
        """\brief 对外暴露的提交任务的接口
        """
        self_queue.put((func, arg, kwarg))
        self._adjust_threads()

    def _thread_run(self, core):
        block = self._wait_time > 0 if core else False
        timeout = self._wait_time if core else None
        while True:
            try:
                func, arg, kwarg = self._queue.pop(block, timeout)
            except Empty:
                break

            if self._shutdown:
                break

            try:
                func(*arg, **kwarg)
            except Exception, e:
                raise e

        with self._thread_lock:
            self._threads.remove(CurrentThread())

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import pop [as 别名]
    def extract_rules(self, tree):
        tree_rules = []
        tree = ptn.parse(tree)
        queue = Queue()
        queue.push(tree)
        i = 0
        while not queue.empty():
            t = queue.pop()
            rule = Rule(t.node_type, [])

            for child in t.children:
                queue.push(child)
                rule.add_child(child.node_type)

            tree_rules.append(rule)

        if None in tree_rules:
            raw_input('>>>')

        return np.array(tree_rules)

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