old_keys = set(old_dict.keys())<br/>
new_keys = set(new_dict.keys())<br/>
#需要更新元素的键<br/>
update_keys = old_keys.intersection(new_keys)<br/>
print(update_keys)<br/>
#需要删除元素的键<br/>
del_keys = old_keys.difference(new_keys)<br/>
#需要添加元素的键<br/>
add_keys = new_keys.difference(old_keys)<br/>
print(del_keys)<br/>
print(add_keys)<br/>
update_keys = list(update_keys)<br/>
for i in update_keys :<br/>
    old_dict[i] = new_dict[i]<br/>
del_keys = list(del_keys)<br/>
for j in del_keys :<br/>
    del old_dict[j]<br/>
for k in list(add_keys) :<br/>
    old_dict[k] = new_dict[k]<br/>
print(old_dict)<br/>
########################################<br/>
{'#3': {'hostname': 'c1', 'cpu_count': , 'mem_capicity': }, '#1': {'hostname': 'c1', 'cpu_count': , 'mem_capicity': }, '#4': {'hostname': 'c2', 'cpu_count': , 'mem_capicity': }}

 ########################################################################<br/>
 ###  Counter<br/>
 ########################################################################
 
 class Counter(dict):<br/>
     '''Dict subclass for counting hashable items.  Sometimes called a bag<br/>
     or multiset.  Elements are stored as dictionary keys and their counts<br/>
     are stored as dictionary values.
 
     >>> c = Counter('abcdeabcdabcaba')  # count elements from a string
 
     >>> c.most_common(3)                # three most common elements<br/>
     [('a', 5), ('b', 4), ('c', 3)]<br/>
     >>> sorted(c)                       # list all unique elements<br/>
     ['a', 'b', 'c', 'd', 'e']<br/>
     >>> ''.join(sorted(c.elements()))   # list elements with repetitions<br/>
     'aaaaabbbbcccdde'<br/>
     >>> sum(c.values())                 # total of all counts
 
     >>> c['a']                          # count of letter 'a'<br/>
     >>> for elem in 'shazam':           # update counts from an iterable<br/>
     ...     c[elem] += 1                # by adding 1 to each element's count<br/>
     >>> c['a']                          # now there are seven 'a'<br/>
     >>> del c['b']                      # remove all 'b'<br/>
     >>> c['b']                          # now there are zero 'b'
 
     >>> d = Counter('simsalabim')       # make another counter<br/>
     >>> c.update(d)                     # add in the second counter<br/>
     >>> c['a']                          # now there are nine 'a'
 
     >>> c.clear()                       # empty the counter<br/>
     >>> c<br/>
     Counter()
 
     Note:  If a count is set to zero or reduced to zero, it will remain<br/>
     in the counter until the entry is deleted or the counter is cleared:
 
     >>> c = Counter('aaabbc')<br/>
     >>> c['b'] -= 2                     # reduce the count of 'b' by two<br/>
     >>> c.most_common()                 # 'b' is still in, but its count is zero<br/>
     [('a', 3), ('c', 1), ('b', 0)]
 
     '''<br/>
     # References:<br/>
     #   http://en.wikipedia.org/wiki/Multiset<br/>
     #   http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html<br/>
     #   http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm<br/>
     #   http://code.activestate.com/recipes/259174/<br/>
     #   Knuth, TAOCP Vol. II section 4.6.3
 
     def __init__(self, iterable=None, **kwds):<br/>
         '''Create a new, empty Counter object.  And if given, count elements<br/>
         from an input iterable.  Or, initialize the count from another mapping<br/>
         of elements to their counts.
 
         >>> c = Counter()                           # a new, empty counter<br/>
         >>> c = Counter('gallahad')                 # a new counter from an iterable<br/>
         >>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping<br/>
         >>> c = Counter(a=4, b=2)                   # a new counter from keyword args
 
         '''<br/>
         super(Counter, self).__init__()<br/>
         self.update(iterable, **kwds)
 
     def __missing__(self, key):<br/>
         """ 对于不存在的元素，返回计数器为0 """<br/>
         'The count of elements not in the Counter is zero.'<br/>
         # Needed so that self[missing_item] does not raise KeyError<br/>
         return 0
 
     def most_common(self, n=None):<br/>
         """ 数量大于等n的所有元素和计数器 """<br/>
         '''List the n most common elements and their counts from the most<br/>
         common to the least.  If n is None, then list all element counts.
 
         >>> Counter('abcdeabcdabcaba').most_common(3)<br/>
         [('a', 5), ('b', 4), ('c', 3)]
 
         '''<br/>
         # Emulate Bag.sortedByCount from Smalltalk<br/>
         if n is None:<br/>
             return sorted(self.iteritems(), key=_itemgetter(1), reverse=True)<br/>
         return _heapq.nlargest(n, self.iteritems(), key=_itemgetter(1))
 
     def elements(self):<br/>
         """ 计数器中的所有元素，注：此处非所有元素集合，而是包含所有元素集合的迭代器 """<br/>
         '''Iterator over elements repeating each as many times as its count.
 
         >>> c = Counter('ABCABC')<br/>
         >>> sorted(c.elements())<br/>
         ['A', 'A', 'B', 'B', 'C', 'C']
 
         # Knuth's example for prime factors of 1836:  2**2 * 3**3 * 17**1<br/>
         >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})<br/>
         >>> product = 1<br/>
         >>> for factor in prime_factors.elements():     # loop over factors<br/>
         ...     product *= factor                       # and multiply them<br/>
         >>> product
 
         Note, if an element's count has been set to zero or is a negative<br/>
         number, elements() will ignore it.
 
         '''<br/>
         # Emulate Bag.do from Smalltalk and Multiset.begin from C++.<br/>
         return _chain.from_iterable(_starmap(_repeat, self.iteritems()))
 
     # Override dict methods where necessary
 
     @classmethod<br/>
     def fromkeys(cls, iterable, v=None):<br/>
         # There is no equivalent method for counters because setting v=1<br/>
         # means that no element can have a count greater than one.<br/>
         raise NotImplementedError(<br/>
             'Counter.fromkeys() is undefined.  Use Counter(iterable) instead.')
 
     def update(self, iterable=None, **kwds):<br/>
         """ 更新计数器，其实就是增加；如果原来没有，则新建，如果有则加一 """<br/>
         '''Like dict.update() but add counts instead of replacing them.
 
         Source can be an iterable, a dictionary, or another Counter instance.
 
         >>> c = Counter('which')<br/>
         >>> c.update('witch')           # add elements from another iterable<br/>
         >>> d = Counter('watch')<br/>
         >>> c.update(d)                 # add elements from another counter<br/>
         >>> c['h']                      # four 'h' in which, witch, and watch
 
         '''<br/>
         # The regular dict.update() operation makes no sense here because the<br/>
         # replace behavior results in the some of original untouched counts<br/>
         # being mixed-in with all of the other counts for a mismash that<br/>
         # doesn't have a straight-forward interpretation in most counting<br/>
         # contexts.  Instead, we implement straight-addition.  Both the inputs<br/>
         # and outputs are allowed to contain zero and negative counts.
 
         if iterable is not None:<br/>
             if isinstance(iterable, Mapping):<br/>
                 if self:<br/>
                     self_get = self.get<br/>
                     for elem, count in iterable.iteritems():<br/>
                         self[elem] = self_get(elem, 0) + count<br/>
                 else:<br/>
                     super(Counter, self).update(iterable) # fast path when counter is empty<br/>
             else:<br/>
                 self_get = self.get<br/>
                 for elem in iterable:<br/>
                     self[elem] = self_get(elem, 0) + 1<br/>
         if kwds:<br/>
             self.update(kwds)
 
     def subtract(self, iterable=None, **kwds):<br/>
         """ 相减，原来的计数器中的每一个元素的数量减去后添加的元素的数量 """<br/>
         '''Like dict.update() but subtracts counts instead of replacing them.<br/>
         Counts can be reduced below zero.  Both the inputs and outputs are<br/>
         allowed to contain zero and negative counts.
 
         Source can be an iterable, a dictionary, or another Counter instance.
 
         >>> c = Counter('which')<br/>
         >>> c.subtract('witch')             # subtract elements from another iterable<br/>
         >>> c.subtract(Counter('watch'))    # subtract elements from another counter<br/>
         >>> c['h']                          # 2 in which, minus 1 in witch, minus 1 in watch<br/>
         >>> c['w']                          # 1 in which, minus 1 in witch, minus 1 in watch<br/>
         -1
 
         '''<br/>
         if iterable is not None:<br/>
             self_get = self.get<br/>
             if isinstance(iterable, Mapping):<br/>
                 for elem, count in iterable.items():<br/>
                     self[elem] = self_get(elem, 0) - count<br/>
             else:<br/>
                 for elem in iterable:<br/>
                     self[elem] = self_get(elem, 0) - 1<br/>
         if kwds:<br/>
             self.subtract(kwds)
 
     def copy(self):<br/>
         """ 拷贝 """<br/>
         'Return a shallow copy.'<br/>
         return self.__class__(self)
 
     def __reduce__(self):<br/>
         """ 返回一个元组（类型，元组） """<br/>
         return self.__class__, (dict(self),)
 
     def __delitem__(self, elem):<br/>
         """ 删除元素 """<br/>
         'Like dict.__delitem__() but does not raise KeyError for missing values.'<br/>
         if elem in self:<br/>
             super(Counter, self).__delitem__(elem)
 
     def __repr__(self):<br/>
         if not self:<br/>
             return '%s()' % self.__class__.__name__<br/>
         items = ', '.join(map('%r: %r'.__mod__, self.most_common()))<br/>
         return '%s({%s})' % (self.__class__.__name__, items)
 
     # Multiset-style mathematical operations discussed in:<br/>
     #       Knuth TAOCP Volume II section 4.6.3 exercise 19<br/>
     #       and at http://en.wikipedia.org/wiki/Multiset<br/>
     #<br/>
     # Outputs guaranteed to only include positive counts.<br/>
     #<br/>
     # To strip negative and zero counts, add-in an empty counter:<br/>
     #       c += Counter()
 
     def __add__(self, other):<br/>
         '''Add counts from two counters.
 
         >>> Counter('abbb') + Counter('bcc')<br/>
         Counter({'b': 4, 'c': 2, 'a': 1})
 
         '''<br/>
         if not isinstance(other, Counter):<br/>
             return NotImplemented<br/>
         result = Counter()<br/>
         for elem, count in self.items():<br/>
             newcount = count + other[elem]<br/>
             if newcount > 0:<br/>
                 result[elem] = newcount<br/>
         for elem, count in other.items():<br/>
             if elem not in self and count > 0:<br/>
                 result[elem] = count<br/>
         return result
 
     def __sub__(self, other):<br/>
         ''' Subtract count, but keep only results with positive counts.
 
         >>> Counter('abbbc') - Counter('bccd')<br/>
         Counter({'b': 2, 'a': 1})
 
         '''<br/>
         if not isinstance(other, Counter):<br/>
             return NotImplemented<br/>
         result = Counter()<br/>
         for elem, count in self.items():<br/>
             newcount = count - other[elem]<br/>
             if newcount > 0:<br/>
                 result[elem] = newcount<br/>
         for elem, count in other.items():<br/>
             if elem not in self and count < 0:<br/>
                 result[elem] = 0 - count<br/>
         return result
 
     def __or__(self, other):<br/>
         '''Union is the maximum of value in either of the input counters.
 
         >>> Counter('abbb') | Counter('bcc')<br/>
         Counter({'b': 3, 'c': 2, 'a': 1})
 
         '''<br/>
         if not isinstance(other, Counter):<br/>
             return NotImplemented<br/>
         result = Counter()<br/>
         for elem, count in self.items():<br/>
             other_count = other[elem]<br/>
             newcount = other_count if count < other_count else count<br/>
             if newcount > 0:<br/>
                 result[elem] = newcount<br/>
         for elem, count in other.items():<br/>
             if elem not in self and count > 0:<br/>
                 result[elem] = count<br/>
         return result
 
     def __and__(self, other):<br/>
         ''' Intersection is the minimum of corresponding counts.
 
         >>> Counter('abbb') & Counter('bcc')<br/>
         Counter({'b': 1})
 
         '''<br/>
         if not isinstance(other, Counter):<br/>
             return NotImplemented<br/>
         result = Counter()<br/>
         for elem, count in self.items():<br/>
             other_count = other[elem]<br/>
             newcount = count if count < other_count else other_count<br/>
             if newcount > 0:<br/>
                 result[elem] = newcount<br/>
         return result
 
 Counter

 class OrderedDict(dict):<br/>
     'Dictionary that remembers insertion order'<br/>
     # An inherited dict maps keys to values.<br/>
     # The inherited dict provides __getitem__, __len__, __contains__, and get.<br/>
     # The remaining methods are order-aware.<br/>
     # Big-O running times for all methods are the same as regular dictionaries.
 
     # The internal self.__map dict maps keys to links in a doubly linked list.<br/>
     # The circular doubly linked list starts and ends with a sentinel element.<br/>
     # The sentinel element never gets deleted (this simplifies the algorithm).<br/>
     # Each link is stored as a list of length three:  [PREV, NEXT, KEY].
 
     def __init__(self, *args, **kwds):<br/>
         '''Initialize an ordered dictionary.  The signature is the same as<br/>
         regular dictionaries, but keyword arguments are not recommended because<br/>
         their insertion order is arbitrary.
 
         '''<br/>
         if len(args) > 1:<br/>
             raise TypeError('expected at most 1 arguments, got %d' % len(args))<br/>
         try:<br/>
             self.__root<br/>
         except AttributeError:<br/>
             self.__root = root = []                     # sentinel node<br/>
             root[:] = [root, root, None]<br/>
             self.__map = {}<br/>
         self.__update(*args, **kwds)
 
     def __setitem__(self, key, value, dict_setitem=dict.__setitem__):<br/>
         'od.__setitem__(i, y) <==> od[i]=y'<br/>
         # Setting a new item creates a new link at the end of the linked list,<br/>
         # and the inherited dictionary is updated with the new key/value pair.<br/>
         if key not in self:<br/>
             root = self.__root<br/>
             last = root[0]<br/>
             last[1] = root[0] = self.__map[key] = [last, root, key]<br/>
         return dict_setitem(self, key, value)
 
     def __delitem__(self, key, dict_delitem=dict.__delitem__):<br/>
         'od.__delitem__(y) <==> del od[y]'<br/>
         # Deleting an existing item uses self.__map to find the link which gets<br/>
         # removed by updating the links in the predecessor and successor nodes.<br/>
         dict_delitem(self, key)<br/>
         link_prev, link_next, _ = self.__map.pop(key)<br/>
         link_prev[1] = link_next                        # update link_prev[NEXT]<br/>
         link_next[0] = link_prev                        # update link_next[PREV]
 
     def __iter__(self):<br/>
         'od.__iter__() <==> iter(od)'<br/>
         # Traverse the linked list in order.<br/>
         root = self.__root<br/>
         curr = root[1]                                  # start at the first node<br/>
         while curr is not root:<br/>
             yield curr[2]                               # yield the curr[KEY]<br/>
             curr = curr[1]                              # move to next node
 
     def __reversed__(self):<br/>
         'od.__reversed__() <==> reversed(od)'<br/>
         # Traverse the linked list in reverse order.<br/>
         root = self.__root<br/>
         curr = root[0]                                  # start at the last node<br/>
         while curr is not root:<br/>
             yield curr[2]                               # yield the curr[KEY]<br/>
             curr = curr[0]                              # move to previous node
 
     def clear(self):<br/>
         'od.clear() -> None.  Remove all items from od.'<br/>
         root = self.__root<br/>
         root[:] = [root, root, None]<br/>
         self.__map.clear()<br/>
         dict.clear(self)
 
     # -- the following methods do not depend on the internal structure --
 
     def keys(self):<br/>
         'od.keys() -> list of keys in od'<br/>
         return list(self)
 
     def values(self):<br/>
         'od.values() -> list of values in od'<br/>
         return [self[key] for key in self]
 
     def items(self):<br/>
         'od.items() -> list of (key, value) pairs in od'<br/>
         return [(key, self[key]) for key in self]
 
     def iterkeys(self):<br/>
         'od.iterkeys() -> an iterator over the keys in od'<br/>
         return iter(self)
 
     def itervalues(self):<br/>
         'od.itervalues -> an iterator over the values in od'<br/>
         for k in self:<br/>
             yield self[k]
 
     def iteritems(self):<br/>
         'od.iteritems -> an iterator over the (key, value) pairs in od'<br/>
         for k in self:<br/>
             yield (k, self[k])
 
     update = MutableMapping.update
 
     __update = update # let subclasses override update without breaking __init__
 
     __marker = object()
 
     def pop(self, key, default=__marker):<br/>
         '''od.pop(k[,d]) -> v, remove specified key and return the corresponding<br/>
         value.  If key is not found, d is returned if given, otherwise KeyError<br/>
         is raised.
 
         '''<br/>
         if key in self:<br/>
             result = self[key]<br/>
             del self[key]<br/>
             return result<br/>
         if default is self.__marker:<br/>
             raise KeyError(key)<br/>
         return default
 
     def setdefault(self, key, default=None):<br/>
         'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'<br/>
         if key in self:<br/>
             return self[key]<br/>
         self[key] = default<br/>
         return default
 
     def popitem(self, last=True):<br/>
         '''od.popitem() -> (k, v), return and remove a (key, value) pair.<br/>
         Pairs are returned in LIFO order if last is true or FIFO order if false.
 
         '''<br/>
         if not self:<br/>
             raise KeyError('dictionary is empty')<br/>
         key = next(reversed(self) if last else iter(self))<br/>
         value = self.pop(key)<br/>
         return key, value
 
     def __repr__(self, _repr_running={}):<br/>
         'od.__repr__() <==> repr(od)'<br/>
         call_key = id(self), _get_ident()<br/>
         if call_key in _repr_running:<br/>
             return '...'<br/>
         _repr_running[call_key] = 1<br/>
         try:<br/>
             if not self:<br/>
                 return '%s()' % (self.__class__.__name__,)<br/>
             return '%s(%r)' % (self.__class__.__name__, self.items())<br/>
         finally:<br/>
             del _repr_running[call_key]
 
     def __reduce__(self):<br/>
         'Return state information for pickling'<br/>
         items = [[k, self[k]] for k in self]<br/>
         inst_dict = vars(self).copy()<br/>
         for k in vars(OrderedDict()):<br/>
             inst_dict.pop(k, None)<br/>
         if inst_dict:<br/>
             return (self.__class__, (items,), inst_dict)<br/>
         return self.__class__, (items,)
 
     def copy(self):<br/>
         'od.copy() -> a shallow copy of od'<br/>
         return self.__class__(self)
 
     @classmethod<br/>
     def fromkeys(cls, iterable, value=None):<br/>
         '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.<br/>
         If not specified, the value defaults to None.
 
         '''<br/>
         self = cls()<br/>
         for key in iterable:<br/>
             self[key] = value<br/>
         return self
 
     def __eq__(self, other):<br/>
         '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive<br/>
         while comparison to a regular mapping is order-insensitive.
 
         '''<br/>
         if isinstance(other, OrderedDict):<br/>
             return dict.__eq__(self, other) and all(_imap(_eq, self, other))<br/>
         return dict.__eq__(self, other)
 
     def __ne__(self, other):<br/>
         'od.__ne__(y) <==> od!=y'<br/>
         return not self == other
 
     # -- the following methods support python 3.x style dictionary views --
 
     def viewkeys(self):<br/>
         "od.viewkeys() -> a set-like object providing a view on od's keys"<br/>
         return KeysView(self)
 
     def viewvalues(self):<br/>
         "od.viewvalues() -> an object providing a view on od's values"<br/>
         return ValuesView(self)
 
     def viewitems(self):<br/>
         "od.viewitems() -> a set-like object providing a view on od's items"<br/>
         return ItemsView(self)
 
 OrderedDict

 class defaultdict(dict):<br/>
     """<br/>
     defaultdict(default_factory[, ...]) --> dict with default factory
 
     The default factory is called without arguments to produce<br/>
     a new value when a key is not present, in __getitem__ only.<br/>
     A defaultdict compares equal to a dict with the same items.<br/>
     All remaining arguments are treated the same as if they were<br/>
     passed to the dict constructor, including keyword arguments.<br/>
     """<br/>
     def copy(self): # real signature unknown; restored from __doc__<br/>
         """ D.copy() -> a shallow copy of D. """<br/>
         pass
 
     def __copy__(self, *args, **kwargs): # real signature unknown<br/>
         """ D.copy() -> a shallow copy of D. """<br/>
         pass
 
     def __getattribute__(self, name): # real signature unknown; restored from __doc__<br/>
         """ x.__getattribute__('name') <==> x.name """<br/>
         pass
 
     def __init__(self, default_factory=None, **kwargs): # known case of _collections.defaultdict.__init__<br/>
         """<br/>
         defaultdict(default_factory[, ...]) --> dict with default factory
 
         The default factory is called without arguments to produce<br/>
         a new value when a key is not present, in __getitem__ only.<br/>
         A defaultdict compares equal to a dict with the same items.<br/>
         All remaining arguments are treated the same as if they were<br/>
         passed to the dict constructor, including keyword arguments.
 
         # (copied from class doc)<br/>
         """<br/>
         pass
 
     def __missing__(self, key): # real signature unknown; restored from __doc__<br/>
         """<br/>
         __missing__(key) # Called by __getitem__ for missing key; pseudo-code:<br/>
           if self.default_factory is None: raise KeyError((key,))<br/>
           self[key] = value = self.default_factory()<br/>
           return value<br/>
         """<br/>
         pass
 
     def __reduce__(self, *args, **kwargs): # real signature unknown<br/>
         """ Return state information for pickling. """<br/>
         pass
 
     def __repr__(self): # real signature unknown; restored from __doc__<br/>
         """ x.__repr__() <==> repr(x) """<br/>
         pass
 
     default_factory = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default<br/>
     """Factory for default value called by __missing__()."""
 
 defaultdict

 values = [11, 22, 33,44,55,66,77,88,99,90]
 
 my_dict = {}
 
 for value in  values:<br/>
     if value>66:<br/>
         if my_dict.has_key('k1'):<br/>
             my_dict['k1'].append(value)<br/>
         else:<br/>
             my_dict['k1'] = [value]<br/>
     else:<br/>
         if my_dict.has_key('k2'):<br/>
             my_dict['k2'].append(value)<br/>
         else:<br/>
             my_dict['k2'] = [value]

 from collections import defaultdict
 
 values = [11, 22, 33,44,55,66,77,88,99,90]
 
 my_dict = defaultdict(list)
 
 for value in  values:<br/>
     if value>66:<br/>
         my_dict['k1'].append(value)<br/>
     else:<br/>
         my_dict['k2'].append(value)
 
 defaultdict字典解决方法
 
 默认字典

class Mytuple(__builtin__.tuple)<br/>
 |  Mytuple(x, y)<br/>
 |<br/>
 |  Method resolution order:<br/>
 |      Mytuple<br/>
 |      __builtin__.tuple<br/>
 |      __builtin__.object<br/>
 |<br/>
 |  Methods defined here:<br/>
 |<br/>
 |  __getnewargs__(self)<br/>
 |      Return self as a plain tuple.  Used by copy and pickle.<br/>
 |<br/>
 |  __getstate__(self)<br/>
 |      Exclude the OrderedDict from pickling<br/>
 |<br/>
 |  __repr__(self)<br/>
 |      Return a nicely formatted representation string<br/>
 |<br/>
 |  _asdict(self)<br/>
 |      Return a new OrderedDict which maps field names to their values<br/>
 |<br/>
 |  _replace(_self, **kwds)<br/>
 |      Return a new Mytuple object replacing specified fields with new values<br/>
 |<br/>
 |  ----------------------------------------------------------------------<br/>
 |  Class methods defined here:<br/>
 |<br/>
 |  _make(cls, iterable, new=<built-in method __new__ of type object>, len=<built-in function len>) from __builtin__.type<br/>
 |      Make a new Mytuple object from a sequence or iterable<br/>
 |<br/>
 |  ----------------------------------------------------------------------<br/>
 |  Static methods defined here:<br/>
 |<br/>
 |  __new__(_cls, x, y)<br/>
 |      Create new instance of Mytuple(x, y)<br/>
 |<br/>
 |  ----------------------------------------------------------------------<br/>
 |  Data descriptors defined here:<br/>
 |<br/>
 |  __dict__<br/>
 |      Return a new OrderedDict which maps field names to their values<br/>
 |<br/>
 |  x<br/>
 |      Alias for field number 0<br/>
 |<br/>
 |  y<br/>
 |      Alias for field number 1<br/>
 |<br/>
 |  ----------------------------------------------------------------------<br/>
 |  Data and other attributes defined here:<br/>
 |<br/>
 |  _fields = ('x', 'y')<br/>
 |<br/>
 |  ----------------------------------------------------------------------<br/>
 |  Methods inherited from __builtin__.tuple:<br/>
 |<br/>
 |  __add__(...)<br/>
 |      x.__add__(y) <==> x+y<br/>
 |<br/>
 |  __contains__(...)<br/>
 |      x.__contains__(y) <==> y in x<br/>
 |<br/>
 |  __eq__(...)<br/>
 |      x.__eq__(y) <==> x==y<br/>
 |<br/>
 |  __ge__(...)<br/>
 |      x.__ge__(y) <==> x>=y<br/>
 |<br/>
 |  __getattribute__(...)<br/>
 |      x.__getattribute__('name') <==> x.name<br/>
 |<br/>
 |  __getitem__(...)<br/>
 |      x.__getitem__(y) <==> x[y]<br/>
 |<br/>
 |  __getslice__(...)<br/>
 |      x.__getslice__(i, j) <==> x[i:j]<br/>
 |<br/>
 |      Use of negative indices is not supported.<br/>
 |<br/>
 |  __gt__(...)<br/>
 |      x.__gt__(y) <==> x>y<br/>
 |<br/>
 |  __hash__(...)<br/>
 |      x.__hash__() <==> hash(x)<br/>
 |<br/>
 |  __iter__(...)<br/>
 |      x.__iter__() <==> iter(x)<br/>
 |<br/>
 |  __le__(...)<br/>
 |      x.__le__(y) <==> x<=y<br/>
 |<br/>
 |  __len__(...)<br/>
 |      x.__len__() <==> len(x)<br/>
 |<br/>
 |  __lt__(...)<br/>
 |      x.__lt__(y) <==> x<y<br/>
 |<br/>
 |  __mul__(...)<br/>
 |      x.__mul__(n) <==> x*n<br/>
 |<br/>
 |  __ne__(...)<br/>
 |      x.__ne__(y) <==> x!=y<br/>
 |<br/>
 |  __rmul__(...)<br/>
 |      x.__rmul__(n) <==> n*x<br/>
 |<br/>
 |  __sizeof__(...)<br/>
 |      T.__sizeof__() -- size of T in memory, in bytes<br/>
 |<br/>
 |  count(...)<br/>
 |      T.count(value) -> integer -- return number of occurrences of value<br/>
 |<br/>
 |  index(...)<br/>
 |      T.index(value, [start, [stop]]) -> integer -- return first index of value.<br/>
 |      Raises ValueError if the value is not present.
 
Mytuple

class deque(object):<br/>
    """<br/>
    deque([iterable[, maxlen]]) --> deque object
 
    Build an ordered collection with optimized access from its endpoints.<br/>
    """<br/>
    def append(self, *args, **kwargs): # real signature unknown<br/>
        """ Add an element to the right side of the deque. """<br/>
        pass
 
    def appendleft(self, *args, **kwargs): # real signature unknown<br/>
        """ Add an element to the left side of the deque. """<br/>
        pass
 
    def clear(self, *args, **kwargs): # real signature unknown<br/>
        """ Remove all elements from the deque. """<br/>
        pass
 
    def count(self, value): # real signature unknown; restored from __doc__<br/>
        """ D.count(value) -> integer -- return number of occurrences of value """<br/>
        return 0
 
    def extend(self, *args, **kwargs): # real signature unknown<br/>
        """ Extend the right side of the deque with elements from the iterable """<br/>
        pass
 
    def extendleft(self, *args, **kwargs): # real signature unknown<br/>
        """ Extend the left side of the deque with elements from the iterable """<br/>
        pass
 
    def pop(self, *args, **kwargs): # real signature unknown<br/>
        """ Remove and return the rightmost element. """<br/>
        pass
 
    def popleft(self, *args, **kwargs): # real signature unknown<br/>
        """ Remove and return the leftmost element. """<br/>
        pass
 
    def remove(self, value): # real signature unknown; restored from __doc__<br/>
        """ D.remove(value) -- remove first occurrence of value. """<br/>
        pass
 
    def reverse(self): # real signature unknown; restored from __doc__<br/>
        """ D.reverse() -- reverse *IN PLACE* """<br/>
        pass
 
    def rotate(self, *args, **kwargs): # real signature unknown<br/>
        """ Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """<br/>
        pass
 
    def __copy__(self, *args, **kwargs): # real signature unknown<br/>
        """ Return a shallow copy of a deque. """<br/>
        pass
 
    def __delitem__(self, y): # real signature unknown; restored from __doc__<br/>
        """ x.__delitem__(y) <==> del x[y] """<br/>
        pass
 
    def __eq__(self, y): # real signature unknown; restored from __doc__<br/>
        """ x.__eq__(y) <==> x==y """<br/>
        pass
 
    def __getattribute__(self, name): # real signature unknown; restored from __doc__<br/>
        """ x.__getattribute__('name') <==> x.name """<br/>
        pass
 
    def __getitem__(self, y): # real signature unknown; restored from __doc__<br/>
        """ x.__getitem__(y) <==> x[y] """<br/>
        pass
 
    def __ge__(self, y): # real signature unknown; restored from __doc__<br/>
        """ x.__ge__(y) <==> x>=y """<br/>
        pass
 
    def __gt__(self, y): # real signature unknown; restored from __doc__<br/>
        """ x.__gt__(y) <==> x>y """<br/>
        pass
 
    def __iadd__(self, y): # real signature unknown; restored from __doc__<br/>
        """ x.__iadd__(y) <==> x+=y """<br/>
        pass
 
    def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__<br/>
        """<br/>
        deque([iterable[, maxlen]]) --> deque object
 
        Build an ordered collection with optimized access from its endpoints.<br/>
        # (copied from class doc)<br/>
        """<br/>
        pass
 
    def __iter__(self): # real signature unknown; restored from __doc__<br/>
        """ x.__iter__() <==> iter(x) """<br/>
        pass
 
    def __len__(self): # real signature unknown; restored from __doc__<br/>
        """ x.__len__() <==> len(x) """<br/>
        pass
 
    def __le__(self, y): # real signature unknown; restored from __doc__<br/>
        """ x.__le__(y) <==> x<=y """<br/>
        pass
 
    def __lt__(self, y): # real signature unknown; restored from __doc__<br/>
        """ x.__lt__(y) <==> x<y """<br/>
        pass
 
    @staticmethod # known case of __new__<br/>
    def __new__(S, *more): # real signature unknown; restored from __doc__<br/>
        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """<br/>
        pass
 
    def __ne__(self, y): # real signature unknown; restored from __doc__<br/>
        """ x.__ne__(y) <==> x!=y """<br/>
        pass
 
    def __reduce__(self, *args, **kwargs): # real signature unknown<br/>
        """ Return state information for pickling. """<br/>
        pass
 
    def __repr__(self): # real signature unknown; restored from __doc__<br/>
        """ x.__repr__() <==> repr(x) """<br/>
        pass
 
    def __reversed__(self): # real signature unknown; restored from __doc__<br/>
        """ D.__reversed__() -- return a reverse iterator over the deque """<br/>
        pass
 
    def __setitem__(self, i, y): # real signature unknown; restored from __doc__<br/>
        """ x.__setitem__(i, y) <==> x[i]=y """<br/>
        pass
 
    def __sizeof__(self): # real signature unknown; restored from __doc__<br/>
        """ D.__sizeof__() -- size of D in memory, in bytes """<br/>
        pass
 
    maxlen = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default<br/>
    """maximum size of a deque or None if unbounded"""
 
    __hash__ = None
 
deque
 
deque

class Queue:<br/>
    """Create a queue object with a given maximum size.
 
    If maxsize is <= 0, the queue size is infinite.<br/>
    """<br/>
    def __init__(self, maxsize=0):<br/>
        self.maxsize = maxsize<br/>
        self._init(maxsize)<br/>
        # mutex must be held whenever the queue is mutating.  All methods<br/>
        # that acquire mutex must release it before returning.  mutex<br/>
        # is shared between the three conditions, so acquiring and<br/>
        # releasing the conditions also acquires and releases mutex.<br/>
        self.mutex = _threading.Lock()<br/>
        # Notify not_empty whenever an item is added to the queue; a<br/>
        # thread waiting to get is notified then.<br/>
        self.not_empty = _threading.Condition(self.mutex)<br/>
        # Notify not_full whenever an item is removed from the queue;<br/>
        # a thread waiting to put is notified then.<br/>
        self.not_full = _threading.Condition(self.mutex)<br/>
        # Notify all_tasks_done whenever the number of unfinished tasks<br/>
        # drops to zero; thread waiting to join() is notified to resume<br/>
        self.all_tasks_done = _threading.Condition(self.mutex)<br/>
        self.unfinished_tasks = 0
 
    def task_done(self):<br/>
        """Indicate that a formerly enqueued task is complete.
 
        Used by Queue consumer threads.  For each get() used to fetch a task,<br/>
        a subsequent call to task_done() tells the queue that the processing<br/>
        on the task is complete.
 
        If a join() is currently blocking, it will resume when all items<br/>
        have been processed (meaning that a task_done() call was received<br/>
        for every item that had been put() into the queue).
 
        Raises a ValueError if called more times than there were items<br/>
        placed in the queue.<br/>
        """<br/>
        self.all_tasks_done.acquire()<br/>
        try:<br/>
            unfinished = self.unfinished_tasks - 1<br/>
            if unfinished <= 0:<br/>
                if unfinished < 0:<br/>
                    raise ValueError('task_done() called too many times')<br/>
                self.all_tasks_done.notify_all()<br/>
            self.unfinished_tasks = unfinished<br/>
        finally:<br/>
            self.all_tasks_done.release()
 
    def join(self):<br/>
        """Blocks until all items in the Queue have been gotten and processed.
 
        The count of unfinished tasks goes up whenever an item is added to the<br/>
        queue. The count goes down whenever a consumer thread calls task_done()<br/>
        to indicate the item was retrieved and all work on it is complete.
 
        When the count of unfinished tasks drops to zero, join() unblocks.<br/>
        """<br/>
        self.all_tasks_done.acquire()<br/>
        try:<br/>
            while self.unfinished_tasks:<br/>
                self.all_tasks_done.wait()<br/>
        finally:<br/>
            self.all_tasks_done.release()
 
    def qsize(self):<br/>
        """Return the approximate size of the queue (not reliable!)."""<br/>
        self.mutex.acquire()<br/>
        n = self._qsize()<br/>
        self.mutex.release()<br/>
        return n
 
    def empty(self):<br/>
        """Return True if the queue is empty, False otherwise (not reliable!)."""<br/>
        self.mutex.acquire()<br/>
        n = not self._qsize()<br/>
        self.mutex.release()<br/>
        return n
 
    def full(self):<br/>
        """Return True if the queue is full, False otherwise (not reliable!)."""<br/>
        self.mutex.acquire()<br/>
        n = 0 < self.maxsize == self._qsize()<br/>
        self.mutex.release()<br/>
        return n
 
    def put(self, item, block=True, timeout=None):<br/>
        """Put an item into the queue.
 
        If optional args 'block' is true and 'timeout' is None (the default),<br/>
        block if necessary until a free slot is available. If 'timeout' is<br/>
        a non-negative number, it blocks at most 'timeout' seconds and raises<br/>
        the Full exception if no free slot was available within that time.<br/>
        Otherwise ('block' is false), put an item on the queue if a free slot<br/>
        is immediately available, else raise the Full exception ('timeout'<br/>
        is ignored in that case).<br/>
        """<br/>
        self.not_full.acquire()<br/>
        try:<br/>
            if self.maxsize > 0:<br/>
                if not block:<br/>
                    if self._qsize() == self.maxsize:<br/>
                        raise Full<br/>
                elif timeout is None:<br/>
                    while self._qsize() == self.maxsize:<br/>
                        self.not_full.wait()<br/>
                elif timeout < 0:<br/>
                    raise ValueError("'timeout' must be a non-negative number")<br/>
                else:<br/>
                    endtime = _time() + timeout<br/>
                    while self._qsize() == self.maxsize:<br/>
                        remaining = endtime - _time()<br/>
                        if remaining <= 0.0:<br/>
                            raise Full<br/>
                        self.not_full.wait(remaining)<br/>
            self._put(item)<br/>
            self.unfinished_tasks += 1<br/>
            self.not_empty.notify()<br/>
        finally:<br/>
            self.not_full.release()
 
    def put_nowait(self, item):<br/>
        """Put an item into the queue without blocking.
 
        Only enqueue the item if a free slot is immediately available.<br/>
        Otherwise raise the Full exception.<br/>
        """<br/>
        return self.put(item, False)
 
    def get(self, block=True, timeout=None):<br/>
        """Remove and return an item from the queue.
 
        If optional args 'block' is true and 'timeout' is None (the default),<br/>
        block if necessary until an item is available. If 'timeout' is<br/>
        a non-negative number, it blocks at most 'timeout' seconds and raises<br/>
        the Empty exception if no item was available within that time.<br/>
        Otherwise ('block' is false), return an item if one is immediately<br/>
        available, else raise the Empty exception ('timeout' is ignored<br/>
        in that case).<br/>
        """<br/>
        self.not_empty.acquire()<br/>
        try:<br/>
            if not block:<br/>
                if not self._qsize():<br/>
                    raise Empty<br/>
            elif timeout is None:<br/>
                while not self._qsize():<br/>
                    self.not_empty.wait()<br/>
            elif timeout < 0:<br/>
                raise ValueError("'timeout' must be a non-negative number")<br/>
            else:<br/>
                endtime = _time() + timeout<br/>
                while not self._qsize():<br/>
                    remaining = endtime - _time()<br/>
                    if remaining <= 0.0:<br/>
                        raise Empty<br/>
                    self.not_empty.wait(remaining)<br/>
            item = self._get()<br/>
            self.not_full.notify()<br/>
            return item<br/>
        finally:<br/>
            self.not_empty.release()
 
    def get_nowait(self):<br/>
        """Remove and return an item from the queue without blocking.
 
        Only get an item if one is immediately available. Otherwise<br/>
        raise the Empty exception.<br/>
        """<br/>
        return self.get(False)
 
    # Override these methods to implement other queue organizations<br/>
    # (e.g. stack or priority queue).<br/>
    # These will only be called with appropriate locks held
 
    # Initialize the queue representation<br/>
    def _init(self, maxsize):<br/>
        self.queue = deque()
 
    def _qsize(self, len=len):<br/>
        return len(self.queue)
 
    # Put a new item in the queue<br/>
    def _put(self, item):<br/>
        self.queue.append(item)
 
    # Get an item from the queue<br/>
    def _get(self):<br/>
        return self.queue.popleft()
 
Queue.Queue