Yf $ @ s d Z d d d d d d d d d g Z d
d l Td
d l Z e e j 7Z d
d
l m Z m Z d
d l m Z
d
d l Z d
d l
Z d
d l m Z d
d l m Z m Z m Z d
d l m Z y d
d l m Z Wn e k
r Yn Xe j e y d
d l m! Z! Wn e k
r"Yn XGd d d e" Z# Gd d d e$ Z% Gd d d e& Z' Gd d d e( Z) Gd d d e* Z+ y d
d l m+ Z+ Wn e k
rYn Xd Z, d Z- d Z. d! d! d" d Z/ d# d$ Z0 y d
d% l m0 Z0 Wn e k
rYn XGd& d d e* Z1 Gd' d d e2 Z3 Gd( d d e2 Z4 Gd) d d e Z5 Gd* d d e6 Z7 d S)+a? This module implements specialized container datatypes providing
alternatives to Python's general purpose built-in containers, dict,
list, set, and tuple.
* namedtuple factory function for creating tuple subclasses with named fields
* deque list-like container with fast appends and pops on either end
* ChainMap dict-like class for creating a single view of multiple mappings
* Counter dict subclass for counting hashable objects
* OrderedDict dict subclass that remembers the order entries were added
* defaultdict dict subclass that calls a factory function to supply missing values
* UserDict wrapper around dictionary objects for easier dict subclassing
* UserList wrapper around list objects for easier list subclassing
* UserString wrapper around string objects for easier string subclassing
deque defaultdict
namedtupleUserDictUserList
UserStringCounter OrderedDictChainMap )*N)
itemgettereq) iskeyword)proxy)repeatchainstarmap)recursive_repr)r )r c @ s e Z d Z d d Z d S)_OrderedDictKeysViewc c s t | j Ed Hd S)N)reversed_mapping)self r 9/opt/alt/python35/lib64/python3.5/collections/__init__.py __reversed__5 s z!_OrderedDictKeysView.__reversed__N)__name__
__module__ __qualname__r r r r r r 3 s r c @ s e Z d Z d d Z d S)_OrderedDictItemsViewc c s0 x) t | j D] } | | j | f Vq Wd S)N)r r )r keyr r r r : s z"_OrderedDictItemsView.__reversed__N)r r r r r r r r r 8 s r c @ s e Z d Z d d Z d S)_OrderedDictValuesViewc c s* x# t | j D] } | j | Vq Wd S)N)r r )r r r r r r @ s z#_OrderedDictValuesView.__reversed__N)r r r r r r r r r > s r c @ s e Z d Z d Z d S)_Linkprevnextr __weakref__N)r" r# r r$ )r r r __slots__r r r r r! D s r! c @ sI e Z d Z d Z d d Z e j e e d d Z e j d d Z d d Z
d
d Z d d
Z d d d Z
d d d Z d d Z e j Z Z d d Z d d Z d d Z e j Z e Z e d d Z d d d Z e d d! Z d" d# Z d$ d% Z e d d& d' Z d( d) Z! d S)*r z)Dictionary that remembers insertion orderc O s | s t d | ^ } } t | d k rF t d t | y | j WnM t k
r t | _ t | j | _ } | | _ | _ i | _ Yn X| j
| | d S)zInitialize an ordered dictionary. The signature is the same as
regular dictionaries, but keyword arguments are not recommended because
their insertion order is arbitrary.
z?descriptor '__init__' of 'OrderedDict' object needs an argument z$expected at most 1 arguments, got %dN) TypeErrorlen_OrderedDict__rootAttributeErrorr! _OrderedDict__hardroot_proxyr" r# _OrderedDict__map_OrderedDict__update)argskwdsr rootr r r __init__V s
zOrderedDict.__init__c C s{ | | k rg | | j | <} | j } | j } | | | | _ | _ | _ | | _ | | | _ | | | | d S)z!od.__setitem__(i, y) <==> od[i]=yN)r- r) r" r# r ) r r valueZ dict_setitemr ZLinklinkr1 lastr r r __setitem__k s zOrderedDict.__setitem__c C sY | | | | j j | } | j } | j } | | _ | | _ d | _ d | _ d S)z od.__delitem__(y) <==> del od[y]N)r- popr" r# )r r Z dict_delitemr4 link_prev link_nextr r r __delitem__y s
zOrderedDict.__delitem__c c s: | j } | j } x! | | k r5 | j V| j } q Wd S)zod.__iter__() <==> iter(od)N)r) r# r )r r1 currr r r __iter__ s
zOrderedDict.__iter__c c s: | j } | j } x! | | k r5 | j V| j } q Wd S)z#od.__reversed__() <==> reversed(od)N)r) r" r )r r1 r; r r r r s
zOrderedDict.__reversed__c C s7 | j } | | _ | _ | j j t j | d S)z.od.clear() -> None. Remove all items from od.N)r) r" r# r- cleardict)r r1 r r r r= s
zOrderedDict.clearTc C s | s t d | j } | rH | j } | j } | | _ | | _ n$ | j } | j } | | _ | | _ | j } | j | =t j | | } | | f S)zod.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.
zdictionary is empty)KeyErrorr) r" r# r r- r> r7 )r r5 r1 r4 r8 r9 r r3 r r r popitem s
zOrderedDict.popitemc C s | j | } | j } | j } | j } | | _ | | _ | j } | ry | j } | | _ | | _ | | _ | | _ n- | j } | | _ | | _ | | _ | | _ d S)zMove an existing element to the end (or beginning if last==False).
Raises KeyError if the element does not exist.
When last=True, acts like a fast version of self[key]=self.pop(key).
N)r- r" r# r) ) r r r5 r4 r8 r9 Z soft_linkr1 firstr r r move_to_end s$
zOrderedDict.move_to_endc C sq t j } t | d } | | j } | | | j d 7} | | | j | 7} | | | j | 7} | S)Nr& )_sys getsizeofr( __dict__r- r+ r) )r Zsizeofnsizer r r
__sizeof__ s zOrderedDict.__sizeof__c C s
t | S)z:D.keys() -> a set-like object providing a view on D's keys)r )r r r r keys s zOrderedDict.keysc C s
t | S)z a set-like object providing a view on D's items)r )r r r r items s zOrderedDict.itemsc C s
t | S)z6D.values() -> an object providing a view on D's values)r )r r r r values s zOrderedDict.valuesc C s@ | | k r! | | } | | =| S| | j k r< t | | S)zod.pop(k[,d]) -> v, remove specified key and return the corresponding
value. If key is not found, d is returned if given, otherwise KeyError
is raised.
)_OrderedDict__markerr? )r r defaultresultr r r r7 s
zOrderedDict.popNc C s" | | k r | | S| | | <| S)zDod.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in odr )r r rN r r r
setdefault s
zOrderedDict.setdefaultc C s7 | s d | j j f Sd | j j t | j f S)zod.__repr__() <==> repr(od)z%s()z%s(%r)) __class__r listrK )r r r r __repr__ s zOrderedDict.__repr__c C sd t | j } x' t t D] } | j | d q" W| j f | pN d d t | j f S)z%Return state information for picklingN)varscopyr r7 rQ iterrK )r Z inst_dictkr r r
__reduce__ s zOrderedDict.__reduce__c C s
| j | S)z!od.copy() -> a shallow copy of od)rQ )r r r r rU s zOrderedDict.copyc C s( | } x | D] } | | | New ordered dictionary with keys from S.
If not specified, the value defaults to None.
r )clsiterabler3 r r r r r fromkeys s
zOrderedDict.fromkeysc C sG t | t r7 t j | | o6 t t t | | St j | | S)zod.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive
while comparison to a regular mapping is order-insensitive.
)
isinstancer r> __eq__allmap_eq)r otherr r r r] s (zOrderedDict.__eq__)"r r r __doc__r2 r> r6 r, r! r: r< r r= r@ rB rI MutableMappingupdater. rJ rK rL __ne__objectrM r7 rP _recursive_reprrS rX rU classmethodr[ r] r r r r r G s0
)r a from builtins import property as _property, tuple as _tuple
from operator import itemgetter as _itemgetter
from collections import OrderedDict
class {typename}(tuple):
'{typename}({arg_list})'
__slots__ = ()
_fields = {field_names!r}
def __new__(_cls, {arg_list}):
'Create new instance of {typename}({arg_list})'
return _tuple.__new__(_cls, ({arg_list}))
@classmethod
def _make(cls, iterable, new=tuple.__new__, len=len):
'Make a new {typename} object from a sequence or iterable'
result = new(cls, iterable)
if len(result) != {num_fields:d}:
raise TypeError('Expected {num_fields:d} arguments, got %d' % len(result))
return result
def _replace(_self, **kwds):
'Return a new {typename} 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' % list(kwds))
return result
def __repr__(self):
'Return a nicely formatted representation string'
return self.__class__.__name__ + '({repr_fmt})' % self
def _asdict(self):
'Return a new OrderedDict which maps field names to their values.'
return OrderedDict(zip(self._fields, self))
def __getnewargs__(self):
'Return self as a plain tuple. Used by copy and pickle.'
return tuple(self)
{field_defs}
z {name}=%rzW {name} = _property(_itemgetter({index:d}), doc='Alias for field number {index:d}')
Fc
C s t | t r' | j d d j } t t t | } t | } | r t } xi t | D][ \ } } | j s t | s | j
d s | | k r d | | | <| j | qd Wxk | g | D]\ } t | t k r t
d | j st d | t | r t d | q Wt } x] | D]U } | j
d rm| rmt d | | | k rt d | | j | qAWt j d
| d t | d t | d
t t | j d d d d d d j d d | D d d j d d t | D } t d d | } t | | | | } | | _ | rpt | j y% t j d j j d d | _ Wn t t f k
rYn X| S) aC 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 accessible 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)
, _z_%dz*Type names and field names must be stringsz8Type names and field names must be valid identifiers: %rz2Type names and field names cannot be a keyword: %rz/Field names cannot start with an underscore: %rz$Encountered duplicate field name: %rtypename field_names
num_fieldsarg_list' r& repr_fmtz, c s s! | ] } t j d | Vq d S)nameN)_repr_templateformat).0rs r r r s z namedtuple..
field_defs
c s s- | ]# \ } } t j d | d | Vq d S)indexrs N)_field_templateru )rv rz rs r r r rw s r z
namedtuple_%s__main__) r\ strreplacesplitrR r_ set enumerate isidentifier
_iskeyword
startswithaddtyper'
ValueError_class_templateru tupler( reprjoinr> exec_sourceprintrD _getframe f_globalsgetr r* )
rl rm verboserenameseenrz rs class_definition namespacerO r r r r g sd
(
%c C s5 | j } x% | D] } | | d d | | >> c = Counter('abcdeabcdabcaba') # count elements from a string
>>> c.most_common(3) # three most common elements
[('a', 5), ('b', 4), ('c', 3)]
>>> sorted(c) # list all unique elements
['a', 'b', 'c', 'd', 'e']
>>> ''.join(sorted(c.elements())) # list elements with repetitions
'aaaaabbbbcccdde'
>>> sum(c.values()) # total of all counts
15
>>> 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['b'] # remove all 'b'
>>> c['b'] # now there are zero 'b'
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)]
c sm | s t d | ^ } } t | d k rF t d t | t t | j | j | | d S)a 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
z;descriptor '__init__' of 'Counter' object needs an argumentr& z$expected at most 1 arguments, got %dN)r' r( superr r2 rd )r/ r0 r )rQ r r r2 s zCounter.__init__c C s d S)z1The count of elements not in the Counter is zero.r
r )r r r r r __missing__ s zCounter.__missing__Nc C sP | d k r. t | j d t d d d St j | | j d t d S)zList 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('abcdeabcdabcaba').most_common(3)
[('a', 5), ('b', 4), ('c', 3)]
Nr r& reverseT)sortedrK _itemgetter_heapqnlargest)r rG r r r most_common s "zCounter.most_commonc C s t j t t | j S)a Iterator 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.
)_chain
from_iterable_starmap_repeatrK )r r r r elements) s zCounter.elementsc C s t d d S)Nz@Counter.fromkeys() is undefined. Use Counter(iterable) instead.)NotImplementedError)rY rZ vr r r r[ A s zCounter.fromkeysc s | s t d | ^ } } t | d k rF t d t | | rV | d n d } | d k r t | t r | r | j } xJ | j D]# \ } } | | | 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
z9descriptor 'update' of 'Counter' object needs an argumentr& z$expected at most 1 arguments, got %dr
N)
r' r( r\ Mappingr rK r r rd r )r/ r0 r rZ self_getr count)rQ r r rd H s
zCounter.updatec O s | s t d | ^ } } t | d k rF t d t | | rV | d n d } | d k r | j } t | t r x\ | j D]# \ } } | | 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
z;descriptor 'subtract' of 'Counter' object needs an argumentr& z$expected at most 1 arguments, got %dr
N)r' r( r r\ r rK subtract)r/ r0 r rZ r r r r r r r p s
zCounter.subtractc C s
| j | S)zReturn a shallow copy.)rQ )r r r r rU s z Counter.copyc C s | j t | f f S)N)rQ r> )r r r r rX s zCounter.__reduce__c s | | k r t j | d S)zGLike dict.__delitem__() but does not raise KeyError for missing values.N)r r: )r r )rQ r r r: s zCounter.__delitem__c C s | s d | j j Sy9 d j t d j | j } d | j j | f SWn. t k
r} d j | j j t | SYn Xd S)Nz%s()z, z%r: %rz%s({%s})z
{0}({1!r})) rQ r r r_ __mod__r r' ru r> )r rK r r r rS s !
zCounter.__repr__c C s t | t s t St } x> | j D]0 \ } } | | | } | d k r) | | | >> Counter('abbb') + Counter('bcc')
Counter({'b': 4, 'c': 2, 'a': 1})
r
)r\ r NotImplementedrK )r ra rO r r newcountr r r __add__ s zCounter.__add__c C s t | t s t St } x> | j D]0 \ } } | | | } | d k r) | | | >> Counter('abbbc') - Counter('bccd')
Counter({'b': 2, 'a': 1})
r
)r\ r r rK )r ra rO r r r r r r __sub__ s zCounter.__sub__c C s t | t s t St } xR | j D]D \ } } | | } | | k rQ | n | } | d k r) | | | >> Counter('abbb') | Counter('bcc')
Counter({'b': 3, 'c': 2, 'a': 1})
r
)r\ r r rK )r ra rO r r other_countr r r r __or__ s
zCounter.__or__c C su t | t s t St } xR | j D]D \ } } | | } | | k rQ | n | } | d k r) | | | >> Counter('abbb') & Counter('bcc')
Counter({'b': 1})
r
)r\ r r rK )r ra rO r r r r r r r __and__ s
zCounter.__and__c C s@ t } x0 | j D]" \ } } | d k r | | | s z*Counter._keep_positive..)rK )r nonpositiver r r r _keep_positive s
zCounter._keep_positivec C s5 x( | j D] \ } } | | | 7>> c = Counter('abbb')
>>> c += Counter('bcc')
>>> c
Counter({'b': 4, 'c': 2, 'a': 1})
)rK r )r ra r r r r r __iadd__ s zCounter.__iadd__c C s5 x( | j D] \ } } | | | 8>> c = Counter('abbbc')
>>> c -= Counter('bccd')
>>> c
Counter({'b': 2, 'a': 1})
)rK r )r ra r r r r r __isub__# s zCounter.__isub__c C sG x: | j D], \ } } | | } | | k r
| | | >> c = Counter('abbb')
>>> c |= Counter('bcc')
>>> c
Counter({'b': 3, 'c': 2, 'a': 1})
)rK r )r ra r r r r r r __ior__0 s
zCounter.__ior__c C sG x: | j D], \ } } | | } | | k r
| | | >> c = Counter('abbb')
>>> c &= Counter('bcc')
>>> c
Counter({'b': 1})
)rK r )r ra r r r r r r __iand__? s
zCounter.__iand__)r r r rb r2 r r r rh r[ rd r rU rX r: rS r r r r r r r r r r r r r )rQ r r s0 +
( "
c @ s e Z d Z d Z d d Z d d Z d d Z d d d
Z d d Z d
d Z d d Z
d d Z e d d Z
e d d Z d d Z e Z d d d Z e d d Z d d Z d d Z d! d" Z d# d$ Z d% d& Z d S)'r a A ChainMap groups multiple dicts (or other mappings) together
to create a single, updateable view.
The underlying mappings are stored in a list. That list is public and can
be accessed or updated using the *maps* attribute. There is no other
state.
Lookups search the underlying mappings successively until a key is found.
In contrast, writes, updates, and deletions only operate on the first
mapping.
c G s t | p i g | _ d S)zInitialize a ChainMap by setting *maps* to the given mappings.
If no mappings are provided, a single empty dictionary is used.
N)rR maps)r r r r r r2 a s zChainMap.__init__c C s t | d S)N)r? )r r r r r r h s zChainMap.__missing__c C sB x2 | j D]' } y | | SWq
t k
r0 Yq
Xq
W| j | S)N)r r? r )r r r r r r __getitem__k s
zChainMap.__getitem__Nc C s | | k r | | S| S)Nr )r r rN r r r r s s z ChainMap.getc C s t t j | j S)N)r( r unionr )r r r r __len__v s zChainMap.__len__c C s t t j | j S)N)rV r r r )r r r r r< y s zChainMap.__iter__c s t f d d | j D S)Nc 3 s | ] } | k Vq d S)Nr )rv m)r r r rw } s z(ChainMap.__contains__..)anyr )r r r )r r __contains__| s zChainMap.__contains__c C s
t | j S)N)r r )r r r r __bool__ s zChainMap.__bool__c C s% d j | d j t t | j S)Nz{0.__class__.__name__}({1})z, )ru r r_ r r )r r r r rS s zChainMap.__repr__c G s | t j | | S)z?Create a ChainMap with a single dict created from the iterable.)r> r[ )rY rZ r/ r r r r[ s zChainMap.fromkeysc C s* | j | j d j | j d d S)zHNew ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]r
r& N)rQ r rU )r r r r rU s z
ChainMap.copyc C s% | d k r i } | j | | j S)zyNew ChainMap with a new map followed by all previous maps.
If no map is provided, an empty dict is used.
N)rQ r )r r r r r new_child s zChainMap.new_childc C s | j | j d d S)zNew ChainMap from maps[1:].r& N)rQ r )r r r r parents s zChainMap.parentsc C s | | j d | z0Passing 'dict' as keyword argument is deprecated
stacklevelrC )r' r( r7 warningswarnPendingDeprecationWarningdatard )r/ kwargsr r> r r r r r2 s$
zUserDict.__init__c C s
t | j S)N)r( r )r r r r r s zUserDict.__len__c C sO | | j k r | j | St | j d r? | j j | | St | d S)Nr )r hasattrrQ r r? )r r r r r r s
zUserDict.__getitem__c C s | | j | d, d- Z d. d/ Z d0 d1 Z d2 d3 Z d4 d5 Z d6 d7 Z d8 d9 Z d: d; Z d< d= Z! d S)?r zAA more or less complete user-defined wrapper around list objects.Nc C s g | _ | d k r t | t | j k rF | | j d d s z
UserList.sortc C s9 t | t r% | j j | j n | j j | d S)N)r\ r r extend)r ra r r r r ? s zUserList.extendr} )"r r r rb r2 rS r r r] r r r r r r r6 r: r r r r __rmul__r r r r7 r r= rU r rz r r r r r r r r s>
c @ s e Z d Z d d Z d d Z d d Z d d Z d d
Z d d Z d
d Z d d Z
d d Z d d Z d d Z
d d Z d d Z d d Z d d Z d d Z d! d" Z d# d$ Z d% d& Z e Z d' d( Z d) d* Z d+ d, Z d- d. Z d/ d0 Z d1 e j d2 d3 Z d4 d4 d5 d6 Z d1 e j d7 d8 Z d9 d: d; Z! d1 e j d< d= Z" d> d? Z# d@ dA Z$ d1 e j dB dC Z% dD dE Z& dF dG Z' dH dI Z( dJ dK Z) dL dM Z* dN dO Z+ dP dQ Z, dR dS Z- dT dU Z. dV dW Z/ dX dY Z0 dZ d[ Z1 d\ d] Z2 d^ d_ Z3 d4 d` da Z4 e5 j6 Z6 db dc Z7 d de df Z8 d1 e j dg dh Z9 d1 e j di dj Z: dk dl Z; dm dn Z< d4 do dp Z= d4 d dq dr Z> d4 d ds dt Z? du dv dw Z@ d1 e j dx dy ZA d4 dz d{ ZB d| d} ZC d~ d ZD d d ZE d d ZF d d ZG d4 S)r c C sV t | t r | | _ n7 t | t rC | j d d | _ n t | | _ d S)N)r\ r~ r r )r seqr r r r2 L s
zUserString.__init__c C s
t | j S)N)r~ r )r r r r __str__S s zUserString.__str__c C s
t | j S)N)r r )r r r r rS T s zUserString.__repr__c C s
t | j S)N)intr )r r r r __int__U s zUserString.__int__c C s
t | j S)N)floatr )r r r r __float__V s zUserString.__float__c C s
t | j S)N)complexr )r r r r __complex__W s zUserString.__complex__c C s
t | j S)N)hashr )r r r r __hash__X s zUserString.__hash__c C s | j d d f S)N)r )r r r r __getnewargs__Y s zUserString.__getnewargs__c C s, t | t r | j | j k S| j | k S)N)r\ r r )r stringr r r r] \ s zUserString.__eq__c C s, t | t r | j | j k S| j | k S)N)r\ r r )r r r r r r ` s zUserString.__lt__c C s, t | t r | j | j k S| j | k S)N)r\ r r )r r r r r r d s zUserString.__le__c C s, t | t r | j | j k S| j | k S)N)r\ r r )r r r r r r h s zUserString.__gt__c C s, t | t r | j | j k S| j | k S)N)r\ r r )r r r r r r l s zUserString.__ge__c C s% t | t r | j } | | j k S)N)r\ r r )r charr r r r q s zUserString.__contains__c C s
t | j S)N)r( r )r r r r r v s zUserString.__len__c C s | j | j | S)N)rQ r )r rz r r r r w s zUserString.__getitem__c C sc t | t r& | j | j | j St | t rI | j | j | S| j | j t | S)N)r\ r rQ r r~ )r ra r r r r x s
zUserString.__add__c C s= t | t r# | j | | j S| j t | | j S)N)r\ r~ rQ r )r ra r r r r ~ s zUserString.__radd__c C s | j | j | S)N)rQ r )r rG r r r r s zUserString.__mul__c C s | j | j | S)N)rQ r )r r/ r r r r s zUserString.__mod__c C s | j | t S)N)rQ r/ )r ru r r r __rmod__ s zUserString.__rmod__c C s | j | j j S)N)rQ r
capitalize)r r r r r s zUserString.capitalizec C s | j | j j S)N)rQ r casefold)r r r r r s zUserString.casefoldc G s | j | j j | | S)N)rQ r center)r widthr/ r r r r s zUserString.centerr
c C s. t | t r | j } | j j | | | S)N)r\ r r r )r substartendr r r r s zUserString.countNc C sW | rA | r( | j | j j | | S| j | j j | S| j | j j S)N)rQ r encode)r encodingerrorsr r r r s
zUserString.encodec C s | j j | | | S)N)r endswith)r suffixr r r r r r s zUserString.endswith c C s | j | j j | S)N)rQ r
expandtabs)r tabsizer r r r s zUserString.expandtabsc C s. t | t r | j } | j j | | | S)N)r\ r r find)r r r r r r r r s zUserString.findc O s | j j | | S)N)r ru )r r/ r0 r r r ru s zUserString.formatc C s | j j | S)N)r
format_map)r r r r r r s zUserString.format_mapc C s | j j | | | S)N)r rz )r r r r r r r rz s zUserString.indexc C s
| j j S)N)r isalpha)r r r r r s zUserString.isalphac C s
| j j S)N)r isalnum)r r r r r s zUserString.isalnumc C s
| j j S)N)r isdecimal)r r r r r s zUserString.isdecimalc C s
| j j S)N)r isdigit)r r r r r s zUserString.isdigitc C s
| j j S)N)r r )r r r r r s zUserString.isidentifierc C s
| j j S)N)r islower)r r r r r s zUserString.islowerc C s
| j j S)N)r isnumeric)r r r r r
s zUserString.isnumericc C s
| j j S)N)r isprintable)r r r r r s zUserString.isprintablec C s
| j j S)N)r isspace)r r r r r s zUserString.isspacec C s
| j j S)N)r istitle)r r r r r
s zUserString.istitlec C s
| j j S)N)r isupper)r r r r r s zUserString.isupperc C s | j j | S)N)r r )r r r r r r s zUserString.joinc G s | j | j j | | S)N)rQ r ljust)r r r/ r r r r s zUserString.ljustc C s | j | j j S)N)rQ r lower)r r r r r s zUserString.lowerc C s | j | j j | S)N)rQ r lstrip)r charsr r r r s zUserString.lstripc C s | j j | S)N)r partition)r sepr r r r s zUserString.partitionr& c C sO t | t r | j } t | t r0 | j } | j | j j | | | S)N)r\ r r rQ r )r oldnewmaxsplitr r r r s
zUserString.replacec C s. t | t r | j } | j j | | | S)N)r\ r r rfind)r r r r r r r r s zUserString.rfindc C s | j j | | | S)N)r rindex)r r r r r r r r s zUserString.rindexc G s | j | j j | | S)N)rQ r rjust)r r r/ r r r r s zUserString.rjustc C s | j j | S)N)r
rpartition)r r r r r r s zUserString.rpartitionc C s | j | j j | S)N)rQ r rstrip)r r r r r r s zUserString.rstripc C s | j j | | S)N)r r )r r r r r r r s zUserString.splitc C s | j j | | S)N)r rsplit)r r r r r r r s zUserString.rsplitFc C s | j j | S)N)r
splitlines)r keependsr r r r s zUserString.splitlinesc C s | j j | | | S)N)r r )r prefixr r r r r r s zUserString.startswithc C s | j | j j | S)N)rQ r strip)r r r r r r! s zUserString.stripc C s | j | j j S)N)rQ r swapcase)r r r r r" s zUserString.swapcasec C s | j | j j S)N)rQ r title)r r r r r# s zUserString.titlec G s | j | j j | S)N)rQ r translate)r r/ r r r r$ s zUserString.translatec C s | j | j j S)N)rQ r upper)r r r r r% s zUserString.upperc C s | j | j j | S)N)rQ r zfill)r r r r r r& s zUserString.zfillr} r} r} )Hr r r r2 r rS r r r r r r] r r r r r r r r r r r r r r r r rD maxsizer r r r r ru r rz r r r r r r r
r r r
r r r r r r~ maketransr r r r r r r r r r r r! r" r# r$ r% r& r r r r r K s )8rb __all___collections_abcoperatorr r r
r` keywordr r sysrD heapqr _weakrefr r, itertoolsr r r r r r reprlibr rg _collectionsr ImportErrorMutableSequenceregisterr KeysViewr ItemsViewr
ValuesViewr rf r! r> r r rt r{ r r r rc r r r Sequencer r r r r sZ
3^
lCI