linux遍历双向队列,python 双向队列与单向队列

5、双向队列(deque)

一个线程安全的双向队列

class deque(object):

"""

deque([iterable[, maxlen]]) --> deque object

Build an ordered collection with optimized access from its endpoints.

"""

def append(self, *args, **kwargs): # real signature unknown

""" Add an element to the right side of the deque. """

pass

def appendleft(self, *args, **kwargs): # real signature unknown

""" Add an element to the left side of the deque. """

pass

def clear(self, *args, **kwargs): # real signature unknown

""" Remove all elements from the deque. """

pass

def count(self, value): # real signature unknown; restored from __doc__

""" D.count(value) -> integer -- return number of occurrences of value """

return 0

def extend(self, *args, **kwargs): # real signature unknown

""" Extend the right side of the deque with elements from the iterable """

pass

def extendleft(self, *args, **kwargs): # real signature unknown

""" Extend the left side of the deque with elements from the iterable """

pass

def pop(self, *args, **kwargs): # real signature unknown

""" Remove and return the rightmost element. """

pass

def popleft(self, *args, **kwargs): # real signature unknown

""" Remove and return the leftmost element. """

pass

def remove(self, value): # real signature unknown; restored from __doc__

""" D.remove(value) -- remove first occurrence of value. """

pass

def reverse(self): # real signature unknown; restored from __doc__

""" D.reverse() -- reverse *IN PLACE* """

pass

def rotate(self, *args, **kwargs): # real signature unknown

""" Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """

pass

def __copy__(self, *args, **kwargs): # real signature unknown

""" Return a shallow copy of a deque. """

pass

def __delitem__(self, y): # real signature unknown; restored from __doc__

""" x.__delitem__(y) <==> del x[y] """

pass

def __eq__(self, y): # real signature unknown; restored from __doc__

""" x.__eq__(y) <==> x==y """

pass

def __getattribute__(self, name): # real signature unknown; restored from __doc__

""" x.__getattribute__('name') <==> x.name """

pass

def __getitem__(self, y): # real signature unknown; restored from __doc__

""" x.__getitem__(y) <==> x[y] """

pass

def __ge__(self, y): # real signature unknown; restored from __doc__

""" x.__ge__(y) <==> x>=y """

pass

def __gt__(self, y): # real signature unknown; restored from __doc__

""" x.__gt__(y) <==> x>y """

pass

def __iadd__(self, y): # real signature unknown; restored from __doc__

""" x.__iadd__(y) <==> x+=y """

pass

def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__

"""

deque([iterable[, maxlen]]) --> deque object

Build an ordered collection with optimized access from its endpoints.

# (copied from class doc)

"""

pass

def __iter__(self): # real signature unknown; restored from __doc__

""" x.__iter__() <==> iter(x) """

pass

def __len__(self): # real signature unknown; restored from __doc__

""" x.__len__() <==> len(x) """

pass

def __le__(self, y): # real signature unknown; restored from __doc__

""" x.__le__(y) <==> x<=y """

pass

def __lt__(self, y): # real signature unknown; restored from __doc__

""" x.__lt__(y) <==> x

pass

@staticmethod # known case of __new__

def __new__(S, *more): # real signature unknown; restored from __doc__

""" T.__new__(S, ...) -> a new object with type S, a subtype of T """

pass

def __ne__(self, y): # real signature unknown; restored from __doc__

""" x.__ne__(y) <==> x!=y """

pass

def __reduce__(self, *args, **kwargs): # real signature unknown

""" Return state information for pickling. """

pass

def __repr__(self): # real signature unknown; restored from __doc__

""" x.__repr__() <==> repr(x) """

pass

def __reversed__(self): # real signature unknown; restored from __doc__

""" D.__reversed__() -- return a reverse iterator over the deque """

pass

def __setitem__(self, i, y): # real signature unknown; restored from __doc__

""" x.__setitem__(i, y) <==> x[i]=y """

pass

def __sizeof__(self): # real signature unknown; restored from __doc__

""" D.__sizeof__() -- size of D in memory, in bytes """

pass

maxlen = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

"""maximum size of a deque or None if unbounded"""

__hash__ = None

deque

既然有双向队列，也有单项队列(先进先出 FIFO )

class Queue:

"""Create a queue object with a given maximum size.

If maxsize is <= 0, the queue size is infinite.

"""

def __init__(self, maxsize=0):

self.maxsize = maxsize

self._init(maxsize)

self.mutex = _threading.Lock()

self.not_empty = _threading.Condition(self.mutex)

self.not_full = _threading.Condition(self.mutex)

self.all_tasks_done = _threading.Condition(self.mutex)

self.unfinished_tasks = 0

def task_done(self):

self.all_tasks_done.acquire()

try:

unfinished = self.unfinished_tasks - 1

if unfinished <= 0:

if unfinished 

raise ValueError('task_done() called too many times')

self.all_tasks_done.notify_all()

self.unfinished_tasks = unfinished

finally:

self.all_tasks_done.release()

def join(self):

self.all_tasks_done.acquire()

try:

while self.unfinished_tasks:

self.all_tasks_done.wait()

finally:

self.all_tasks_done.release()

def qsize(self):

"""Return the approximate size of the queue (not reliable!)."""

self.mutex.acquire()

n = self._qsize()

self.mutex.release()

return n

def empty(self):

"""Return True if the queue is empty, False otherwise (not reliable!)."""

self.mutex.acquire()

n = not self._qsize()

self.mutex.release()

return n

def full(self):

"""Return True if the queue is full, False otherwise (not reliable!)."""

self.mutex.acquire()

n = 0 

self.mutex.release()

return n

def put(self, item, block=True, timeout=None):

self.not_full.acquire()

try:

if self.maxsize > 0:

if not block:

if self._qsize() == self.maxsize:

raise Full

elif timeout is None:

while self._qsize() == self.maxsize:

self.not_full.wait()

elif timeout 

raise ValueError("'timeout' must be a non-negative number")

else:

endtime = _time() + timeout

while self._qsize() == self.maxsize:

remaining = endtime - _time()

if remaining <= 0.0:

raise Full

self.not_full.wait(remaining)

self._put(item)

self.unfinished_tasks += 1

self.not_empty.notify()

finally:

self.not_full.release()

def put_nowait(self, item):

"""Put an item into the queue without blocking.

Only enqueue the item if a free slot is immediately available.

Otherwise raise the Full exception.

"""

return self.put(item, False)

def get(self, block=True, timeout=None):

self.not_empty.acquire()

try:

if not block:

if not self._qsize():

raise Empty

elif timeout is None:

while not self._qsize():

self.not_empty.wait()

elif timeout 

raise ValueError("'timeout' must be a non-negative number")

else:

endtime = _time() + timeout

while not self._qsize():

remaining = endtime - _time()

if remaining <= 0.0:

raise Empty

self.not_empty.wait(remaining)

item = self._get()

self.not_full.notify()

return item

finally:

self.not_empty.release()

def get_nowait(self):

"""Remove and return an item from the queue without blocking.

Only get an item if one is immediately available. Otherwise

raise the Empty exception.

"""

return self.get(False)

def _init(self, maxsize):

self.queue = deque()

def _qsize(self, len=len):

return len(self.queue)

# Put a new item in the queue

def _put(self, item):

self.queue.append(item)

# Get an item from the queue

def _get(self):

return self.queue.popleft()

Queue.Queue