Pc@sxdddddgZddlTddlZeej7ZddlmZmZdd lmZmZ dd l m Z ddl ZddlZdd lmZmZmZmZmZydd lmZWn!ek rdd lmZnXd Z de!e"fdYZ#e$e$dZ%de!fdYZ&e'dkrtddl(m)Z)m*Z*e%dde+Z,e,ddddZ-e-e)e*e-kst.de%ddfdYZ,x/e,dde,dddfD] Z-e-GHqWde%ddfd YZ,e,d!d"j/dd#GHe%d$e,j0d%fZ1e1j2GHddl3Z3e%d&d'Z4e4e3j5GHndS((tCountertdequet defaultdictt namedtuplet OrderedDicti(t*N(RR(t itemgetterteq(t iskeyword(trepeattchaintstarmaptifiltertimap(t get_identcsUtfd}td|_td|_td|_|S(sCDecorator to make a repr function return "..." for a recursive callcsWt|tf}|kr%dSj|z|}Wdj|X|S(Ns...(tidRtaddtdiscard(tselftkeytresult(t repr_runningt user_function(s..\python\lib\collections.pytwrappers  t __module__t__doc__t__name__(tsettgetattrRRR(RR((RRs..\python\lib\collections.pyt_recursive_reprs   cBs%eZdZdZddejdZddejdZdddZdddZd Z d Z e j Z e j Z e jZe jZe jZe jZe jZe jZe jZe jZd Zd Zd ZedZedZdZeddZ dZ!RS(s)Dictionary that remembers insertion ordercOst|dkr+tdt|ny |jWnNtk rdddg|_}d}d}|||<|| od[i]=yN(R R#(RRtvalueR(R)t dict_setitemR'tlast((s..\python\lib\collections.pyt __setitem__Ls    )cCsK||||jj|}||}||}|||<||| del od[y]N(R#tpop(RRR(R)t dict_delitemtlinkt link_prevt link_next((s..\python\lib\collections.pyt __delitem__Vs     iccs=|j}||}x#||k r8||V||}qWdS(sod.__iter__() <==> iter(od)N(R (RR)tKEYR'tcurr((s..\python\lib\collections.pyt__iter__as    ccs=|j}||}x#||k r8||V||}qWdS(s#od.__reversed__() <==> reversed(od)N(R (RR(R5R'R6((s..\python\lib\collections.pyt __reversed__js    cCsg|D]}|||g^q}|j|jf}|`|`t|j}|\|_|_|r~|j|f|fS|j|ffS(s%Return state information for pickling(R#R tvarstcopyt __class__(Rtktitemsttmpt inst_dict((s..\python\lib\collections.pyt __reduce__ss# cCsmyHx|jjD] }|2qW|j|jdg|j(|jjWntk r[nXtj|dS(s.od.clear() -> None. Remove all items from od.N(R#t itervaluesR R"tclearR!tdict(Rtnode((s..\python\lib\collections.pyRB~s cCs t|S(s@od.viewkeys() -> a set-like object providing a view on od's keys(tKeysView(R((s..\python\lib\collections.pytviewkeysscCs t|S(s<od.viewvalues() -> an object providing a view on od's values(t ValuesView(R((s..\python\lib\collections.pyt viewvaluesscCs t|S(sBod.viewitems() -> a set-like object providing a view on od's items(t ItemsView(R((s..\python\lib\collections.pyt viewitemsscCsR|stdnt|r*t|n t|}|j|}||fS(sod.popitem() -> (k, v), return and remove a (key, value) pair. Pairs are returned in LIFO order if last is true or FIFO order if false. sdictionary is empty(tKeyErrortnexttreversedtiterR/(RR-RR+((s..\python\lib\collections.pytpopitems $cCs1|sd|jjfSd|jj|jfS(sod.__repr__() <==> repr(od)s%s()s%s(%r)(R;RR=(R((s..\python\lib\collections.pyt__repr__scCs |j|S(s!od.copy() -> a shallow copy of od(R;(R((s..\python\lib\collections.pyR:scCs(|}x|D]}||| New ordered dictionary with keys from S and values equal to v (which defaults to None). ((tclstiterableR+tdR((s..\python\lib\collections.pytfromkeyss  cCsYt|trIt|t|koHttt|j|jStj||S(sod.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive while comparison to a regular mapping is order-insensitive. ( t isinstanceRRtallt_imapt_eqt iteritemsRCt__eq__(Rtother((s..\python\lib\collections.pyRZs"N("RRRR*RCR.R4R7R8R@RBtMutableMappingt setdefaultR$R/tkeystvaluesR=titerkeysRARYt__ne__RFRHRJtTrueRORRPR:t classmethodR"RTRZ(((s..\python\lib\collections.pyR.s6                    c Bs/e|er*|jddj}neee|}|re|}e}xe |D]\}}e d|D se |s| s|dj s|j ds||krd|||Returns a new subclass of tuple with named fields. >>> Point = namedtuple('Point', 'x y') >>> Point.__doc__ # docstring for the new class 'Point(x, y)' >>> p = Point(11, y=22) # instantiate with positional args or keywords >>> p[0] + p[1] # indexable like a plain tuple 33 >>> x, y = p # unpack like a regular tuple >>> x, y (11, 22) >>> p.x + p.y # fields also accessable by name 33 >>> d = p._asdict() # convert to a dictionary >>> d['x'] 11 >>> Point(**d) # convert from a dictionary Point(x=11, y=22) >>> p._replace(x=100) # _replace() is like str.replace() but targets named fields Point(x=100, y=22) t,t css'|]}|jp|dkVqdS(t_N(tisalnum(t.0tc((s..\python\lib\collections.pys siRfs_%dcss'|]}|jp|dkVqdS(RfN(Rg(RhRi((s..\python\lib\collections.pys ssWType names and field names can only contain alphanumeric characters and underscores: %rs2Type names and field names cannot be a keyword: %rs9Type names and field names cannot start with a number: %rs/Field names cannot start with an underscore: %rs$Encountered duplicate field name: %rt'tiis, css|]}d|VqdS(s%s=%%rN((Rhtname((s..\python\lib\collections.pys ssclass %(typename)s(tuple): '%(typename)s(%(argtxt)s)' __slots__ = () _fields = %(field_names)r def __new__(_cls, %(argtxt)s): 'Create new instance of %(typename)s(%(argtxt)s)' return _tuple.__new__(_cls, (%(argtxt)s)) @classmethod def _make(cls, iterable, new=tuple.__new__, len=len): 'Make a new %(typename)s object from a sequence or iterable' result = new(cls, iterable) if len(result) != %(numfields)d: raise TypeError('Expected %(numfields)d arguments, got %%d' %% len(result)) return result def __repr__(self): 'Return a nicely formatted representation string' return '%(typename)s(%(reprtxt)s)' %% self def _asdict(self): 'Return a new OrderedDict which maps field names to their values' return OrderedDict(zip(self._fields, self)) def _replace(_self, **kwds): 'Return a new %(typename)s object replacing specified fields with new values' result = _self._make(map(kwds.pop, %(field_names)r, _self)) if kwds: raise ValueError('Got unexpected field names: %%r' %% kwds.keys()) return result def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) sI %s = _property(_itemgetter(%d), doc='Alias for field number %d') t _itemgetterRs namedtuple_%sRt _propertyt_tuples: t__main__( RUt basestringtreplacetsplitttupletmaptstrtlistRt enumerateRVt _iskeywordtisdigitt startswithRt ValueErrorRtreprtjointlocalsRCRmRtpropertyt SyntaxErrortmessaget_syst _getframet f_globalstgetRR!(ttypenamet field_namestverbosetrenametnamestseentiRlt seen_namest numfieldstargtxttreprtxtttemplatet namespaceteR((s..\python\lib\collections.pyRs^  #&         %cBseZdZddZdZddZdZeddZ ddZ ddZ dZ d Z d Zd Zd Zd ZdZRS(sDict subclass for counting hashable items. Sometimes called a bag or multiset. Elements are stored as dictionary keys and their counts are stored as dictionary values. >>> c = Counter('abracadabra') # count elements from a string >>> c.most_common(3) # three most common elements [('a', 5), ('r', 2), ('b', 2)] >>> sorted(c) # list all unique elements ['a', 'b', 'c', 'd', 'r'] >>> ''.join(sorted(c.elements())) # list elements with repetitions 'aaaaabbcdrr' >>> sum(c.values()) # total of all counts 11 >>> c['a'] # count of letter 'a' 5 >>> for elem in 'shazam': # update counts from an iterable ... c[elem] += 1 # by adding 1 to each element's count >>> c['a'] # now there are seven 'a' 7 >>> del c['r'] # remove all 'r' >>> c['r'] # now there are zero 'r' 0 >>> d = Counter('simsalabim') # make another counter >>> c.update(d) # add in the second counter >>> c['a'] # now there are nine 'a' 9 >>> c.clear() # empty the counter >>> c Counter() Note: If a count is set to zero or reduced to zero, it will remain in the counter until the entry is deleted or the counter is cleared: >>> c = Counter('aaabbc') >>> c['b'] -= 2 # reduce the count of 'b' by two >>> c.most_common() # 'b' is still in, but its count is zero [('a', 3), ('c', 1), ('b', 0)] cKs|j||dS(s Create a new, empty Counter object. And if given, count elements from an input iterable. Or, initialize the count from another mapping of elements to their counts. >>> c = Counter() # a new, empty counter >>> c = Counter('gallahad') # a new counter from an iterable >>> c = Counter({'a': 4, 'b': 2}) # a new counter from a mapping >>> c = Counter(a=4, b=2) # a new counter from keyword args N(R$(RRRR&((s..\python\lib\collections.pyR*ys cCsdS(s1The count of elements not in the Counter is zero.i((RR((s..\python\lib\collections.pyt __missing__scCsP|dkr.t|jdtddtStj||jdtdS(sList the n most common elements and their counts from the most common to the least. If n is None, then list all element counts. >>> Counter('abracadabra').most_common(3) [('a', 5), ('r', 2), ('b', 2)] RitreverseN(R"tsortedRYRmRbt_heapqtnlargest(Rtn((s..\python\lib\collections.pyt most_commons "cCstjtt|jS(sIterator over elements repeating each as many times as its count. >>> c = Counter('ABCABC') >>> sorted(c.elements()) ['A', 'A', 'B', 'B', 'C', 'C'] # Knuth's example for prime factors of 1836: 2**2 * 3**3 * 17**1 >>> prime_factors = Counter({2: 2, 3: 3, 17: 1}) >>> product = 1 >>> for factor in prime_factors.elements(): # loop over factors ... product *= factor # and multiply them >>> product 1836 Note, if an element's count has been set to zero or is a negative number, elements() will ignore it. (t_chaint from_iterablet_starmapt_repeatRY(R((s..\python\lib\collections.pytelementsscCstddS(Ns@Counter.fromkeys() is undefined. Use Counter(iterable) instead.(tNotImplementedError(RQRRtv((s..\python\lib\collections.pyRTscKs|dk rt|trt|ra|j}xD|jD]#\}}||d|||>> c = Counter('which') >>> c.update('witch') # add elements from another iterable >>> d = Counter('watch') >>> c.update(d) # add elements from another counter >>> c['h'] # four 'h' in which, witch, and watch 4 iiN(R"RUtMappingRRYRCR$(RRRR&tself_gettelemtcount((s..\python\lib\collections.pyR$s    cKs|dk r|j}t|tr[x\|jD]#\}}||d|||>> c = Counter('which') >>> c.subtract('witch') # subtract elements from another iterable >>> c.subtract(Counter('watch')) # subtract elements from another counter >>> c['h'] # 2 in which, minus 1 in witch, minus 1 in watch 0 >>> c['w'] # 1 in which, minus 1 in witch, minus 1 in watch -1 iiN(R"RRURR=tsubtract(RRRR&RRR((s..\python\lib\collections.pyRs   cCs t|S(sBLike dict.copy() but returns a Counter instance instead of a dict.(R(R((s..\python\lib\collections.pyR:scCs#||krtj||ndS(sGLike dict.__delitem__() but does not raise KeyError for missing values.N(RCR4(RR((s..\python\lib\collections.pyR4s cCsI|sd|jjSdjtdj|j}d|jj|fS(Ns%s()s, s%r: %rs%s({%s})(R;RR~Rut__mod__R(RR=((s..\python\lib\collections.pyRPs!cCslt|tstSt}xIt|t|BD]1}||||}|dkr3|||>> Counter('abbb') + Counter('bcc') Counter({'b': 4, 'c': 2, 'a': 1}) i(RURtNotImplementedR(RR[RRtnewcount((s..\python\lib\collections.pyt__add__ s  cCslt|tstSt}xIt|t|BD]1}||||}|dkr3|||>> Counter('abbbc') - Counter('bccd') Counter({'b': 2, 'a': 1}) i(RURRR(RR[RRR((s..\python\lib\collections.pyt__sub__s  cCst|tstSt}xdt|t|BD]L}||||}}||kr`|n|}|dkr3|||>> Counter('abbb') | Counter('bcc') Counter({'b': 3, 'c': 2, 'a': 1}) i(RURRR(RR[RRtptqR((s..\python\lib\collections.pyt__or__-s  cCst|tstSt}t|t|krD||}}nx`t|j|D]L}||||}}||kr|n|}|dkrW|||>> Counter('abbb') & Counter('bcc') Counter({'b': 1}) i(RURRRt_ifiltert __contains__(RR[RRRRR((s..\python\lib\collections.pyt__and__>s  N(RRRR"R*RRRRcRTR$RR:R4RPRRRR(((s..\python\lib\collections.pyRFs +   #       Rp(tloadstdumpstPointsx, ytxi tyisx ycBs&eZdZedZdZRS(cCs|jd|jddS(Nig?(RR(R((s..\python\lib\collections.pythypot\scCsd|j|j|jfS(Ns$Point: x=%6.3f y=%6.3f hypot=%6.3f(RRR(R((s..\python\lib\collections.pyt__str___s((RRt __slots__RRR(((s..\python\lib\collections.pyRZsiiiig@cBs/eZdZdZeejZedZ RS(sHPoint class with optimized _make() and _replace() without error-checkingcKs|j||jd|S(NRR(RR(t_makeR(Rt_mapR&((s..\python\lib\collections.pyt_replaceis(( RRRRRcRtt__new__RRuR(((s..\python\lib\collections.pyResi iidtPoint3Dtzt TestResultssfailed attempted(6t__all__t_abcollt _collectionsRRtoperatorRRmRRXtkeywordRRytsysRtheapqRt itertoolsR RR RR RR RR RWtthreadRt ImportErrort dummy_threadRRCR\RtFalseRRRtcPickleRRRbRRtAssertionErrorRt_fieldsRRtdoctestRttestmod(((s..\python\lib\collections.pytsB     (  v )