"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
""
"default object formatter"
"x.__getattribute__(\'name\') <==> x.name"
"x.__getitem__(y) <==> x[y]"
"x.__getslice__(i, j) <==> x[i:j]\n \n Use of negative indices is not supported."
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
""
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
""
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
""
""
"Common base class for all exceptions"
""
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
"default object formatter"
"x.__getattribute__(\'name\') <==> x.name"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"Type basestring cannot be instantiated; it is the base for str and unicode."
"x.__abs__() <==> abs(x)"
"x.__add__(y) <==> x+y"
"x.__and__(y) <==> x&y"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__cmp__(y) <==> cmp(x,y)"
"x.__coerce__(y) <==> coerce(x, y)"
"x.__delattr__(\'name\') <==> del x.name"
"x.__div__(y) <==> x/y"
"x.__divmod__(y) <==> divmod(x, y)"
"x.__float__() <==> float(x)"
"x.__floordiv__(y) <==> x//y"
""
"x.__getattribute__(\'name\') <==> x.name"
""
"x.__hash__() <==> hash(x)"
"x.__hex__() <==> hex(x)"
"x[y:z] <==> x[y.__index__():z.__index__()]"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__int__() <==> int(x)"
"x.__invert__() <==> ~x"
"x.__long__() <==> long(x)"
"x.__lshift__(y) <==> x<<y"
"x.__mod__(y) <==> x%y"
"x.__mul__(y) <==> x*y"
"x.__neg__() <==> -x"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"x.__nonzero__() <==> x != 0"
"x.__oct__() <==> oct(x)"
"x.__or__(y) <==> x|y"
"x.__pos__() <==> +x"
"x.__pow__(y[, z]) <==> pow(x, y[, z])"
"x.__radd__(y) <==> y+x"
"x.__rand__(y) <==> y&x"
"x.__rdiv__(y) <==> y/x"
"x.__rdivmod__(y) <==> divmod(y, x)"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__rfloordiv__(y) <==> y//x"
"x.__rlshift__(y) <==> y<<x"
"x.__rmod__(y) <==> y%x"
"x.__rmul__(y) <==> y*x"
"x.__ror__(y) <==> y|x"
"y.__rpow__(x[, z]) <==> pow(x, y[, z])"
"x.__rrshift__(y) <==> y>>x"
"x.__rshift__(y) <==> x>>y"
"x.__rsub__(y) <==> y-x"
"x.__rtruediv__(y) <==> y/x"
"x.__rxor__(y) <==> y^x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"x.__sub__(y) <==> x-y"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"x.__truediv__(y) <==> x/y"
"Truncating an Integral returns itself."
"x.__xor__(y) <==> x^y"
"int.bit_length() -> int\n\nNumber of bits necessary to represent self in binary.\n>>> bin(37)\n\'0b100101\'\n>>> (37).bit_length()\n6"
"Returns self, the complex conjugate of any int."
"the denominator of a rational number in lowest terms"
"bool(x) -> bool\n\nReturns True when the argument x is true, False otherwise.\nThe builtins True and False are the only two instances of the class bool.\nThe class bool is a subclass of the class int, and cannot be subclassed."
"the imaginary part of a complex number"
"the numerator of a rational number in lowest terms"
"the real part of a complex number"
"x.__add__(y) <==> x+y"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__cmp__(y) <==> cmp(x,y)"
"x.__delattr__(\'name\') <==> del x.name"
"x.__delitem__(y) <==> del x[y]"
"x.__delslice__(i, j) <==> del x[i:j]\n \n Use of negative indices is not supported."
"default object formatter"
"x.__getattribute__(\'name\') <==> x.name"
"x.__getitem__(y) <==> x[y]"
"x.__getslice__(i, j) <==> x[i:j]\n \n Use of negative indices is not supported."
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__len__() <==> len(x)"
"x.__mul__(n) <==> x*n"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__rmul__(n) <==> n*x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"x.__setitem__(i, y) <==> x[i]=y"
"x.__setslice__(i, j, y) <==> x[i:j]=y\n \n Use of negative indices is not supported."
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"buffer(object [, offset[, size]])\n\nCreate a new buffer object which references the given object.\nThe buffer will reference a slice of the target object from the\nstart of the object (or at the specified offset). The slice will\nextend to the end of the target object (or with the specified size)."
"x.__add__(y) <==> x+y"
"B.__alloc__() -> int\n\nReturns the number of bytes actually allocated."
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__contains__(y) <==> y in x"
"x.__delattr__(\'name\') <==> del x.name"
"x.__delitem__(y) <==> del x[y]"
"x.__eq__(y) <==> x==y"
"default object formatter"
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
"x.__getitem__(y) <==> x[y]"
"x.__gt__(y) <==> x>y"
"x.__hash__() <==> hash(x)"
"x.__iadd__(y) <==> x+=y"
"x.__imul__(y) <==> x*=y"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__iter__() <==> iter(x)"
"x.__le__(y) <==> x<=y"
"x.__len__() <==> len(x)"
"x.__lt__(y) <==> x<y"
"x.__mul__(n) <==> x*n"
"x.__ne__(y) <==> x!=y"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"Return state information for pickling."
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__rmul__(n) <==> n*x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"x.__setitem__(i, y) <==> x[i]=y"
"B.__sizeof__() -> int\n \nReturns the size of B in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"B.append(int) -> None\n\nAppend a single item to the end of B."
"B.capitalize() -> copy of B\n\nReturn a copy of B with only its first character capitalized (ASCII)\nand the rest lower-cased."
"B.center(width[, fillchar]) -> copy of B\n\nReturn B centered in a string of length width. Padding is\ndone using the specified fill character (default is a space)."
"B.count(sub [,start [,end]]) -> int\n\nReturn the number of non-overlapping occurrences of subsection sub in\nbytes B[start:end]. Optional arguments start and end are interpreted\nas in slice notation."
"B.decode([encoding[, errors]]) -> unicode object.\n\nDecodes B using the codec registered for encoding. encoding defaults\nto the default encoding. errors may be given to set a different error\nhandling scheme. Default is \'strict\' meaning that encoding errors raise\na UnicodeDecodeError. Other possible values are \'ignore\' and \'replace\'\nas well as any other name registered with codecs.register_error that is\nable to handle UnicodeDecodeErrors."
"bytearray(iterable_of_ints) -> bytearray.\nbytearray(string, encoding[, errors]) -> bytearray.\nbytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray.\nbytearray(memory_view) -> bytearray.\n\nConstruct an mutable bytearray object from:\n - an iterable yielding integers in range(256)\n - a text string encoded using the specified encoding\n - a bytes or a bytearray object\n - any object implementing the buffer API.\n\nbytearray(int) -> bytearray.\n\nConstruct a zero-initialized bytearray of the given length."
"B.endswith(suffix [,start [,end]]) -> bool\n\nReturn True if B ends with the specified suffix, False otherwise.\nWith optional start, test B beginning at that position.\nWith optional end, stop comparing B at that position.\nsuffix can also be a tuple of strings to try."
"B.expandtabs([tabsize]) -> copy of B\n\nReturn a copy of B where all tab characters are expanded using spaces.\nIf tabsize is not given, a tab size of 8 characters is assumed."
"B.extend(iterable int) -> None\n\nAppend all the elements from the iterator or sequence to the\nend of B."
"B.find(sub [,start [,end]]) -> int\n\nReturn the lowest index in B where subsection sub is found,\nsuch that sub is contained within s[start,end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure."
"bytearray.fromhex(string) -> bytearray\n\nCreate a bytearray object from a string of hexadecimal numbers.\nSpaces between two numbers are accepted.\nExample: bytearray.fromhex(\'B9 01EF\') -> bytearray(b\'\\xb9\\x01\\xef\')."
"B.index(sub [,start [,end]]) -> int\n\nLike B.find() but raise ValueError when the subsection is not found."
"B.insert(index, int) -> None\n\nInsert a single item into the bytearray before the given index."
"B.isalnum() -> bool\n\nReturn True if all characters in B are alphanumeric\nand there is at least one character in B, False otherwise."
"B.isalpha() -> bool\n\nReturn True if all characters in B are alphabetic\nand there is at least one character in B, False otherwise."
"B.isdigit() -> bool\n\nReturn True if all characters in B are digits\nand there is at least one character in B, False otherwise."
"B.islower() -> bool\n\nReturn True if all cased characters in B are lowercase and there is\nat least one cased character in B, False otherwise."
"B.isspace() -> bool\n\nReturn True if all characters in B are whitespace\nand there is at least one character in B, False otherwise."
"B.istitle() -> bool\n\nReturn True if B is a titlecased string and there is at least one\ncharacter in B, i.e. uppercase characters may only follow uncased\ncharacters and lowercase characters only cased ones. Return False\notherwise."
"B.isupper() -> bool\n\nReturn True if all cased characters in B are uppercase and there is\nat least one cased character in B, False otherwise."
"B.join(iterable_of_bytes) -> bytes\n\nConcatenates any number of bytearray objects, with B in between each pair."
"B.ljust(width[, fillchar]) -> copy of B\n\nReturn B left justified in a string of length width. Padding is\ndone using the specified fill character (default is a space)."
"B.lower() -> copy of B\n\nReturn a copy of B with all ASCII characters converted to lowercase."
"B.lstrip([bytes]) -> bytearray\n\nStrip leading bytes contained in the argument.\nIf the argument is omitted, strip leading ASCII whitespace."
"B.partition(sep) -> (head, sep, tail)\n\nSearches for the separator sep in B, and returns the part before it,\nthe separator itself, and the part after it. If the separator is not\nfound, returns B and two empty bytearray objects."
"B.pop([index]) -> int\n\nRemove and return a single item from B. If no index\nargument is given, will pop the last value."
"B.remove(int) -> None\n\nRemove the first occurance of a value in B."
"B.replace(old, new[, count]) -> bytes\n\nReturn a copy of B with all occurrences of subsection\nold replaced by new. If the optional argument count is\ngiven, only the first count occurrences are replaced."
"B.reverse() -> None\n\nReverse the order of the values in B in place."
"B.rfind(sub [,start [,end]]) -> int\n\nReturn the highest index in B where subsection sub is found,\nsuch that sub is contained within s[start,end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure."
"B.rindex(sub [,start [,end]]) -> int\n\nLike B.rfind() but raise ValueError when the subsection is not found."
"B.rjust(width[, fillchar]) -> copy of B\n\nReturn B right justified in a string of length width. Padding is\ndone using the specified fill character (default is a space)"
"B.rpartition(sep) -> (head, sep, tail)\n\nSearches for the separator sep in B, starting at the end of B,\nand returns the part before it, the separator itself, and the\npart after it. If the separator is not found, returns two empty\nbytearray objects and B."
"B.rsplit(sep[, maxsplit]) -> list of bytearray\n\nReturn a list of the sections in B, using sep as the delimiter,\nstarting at the end of B and working to the front.\nIf sep is not given, B is split on ASCII whitespace characters\n(space, tab, return, newline, formfeed, vertical tab).\nIf maxsplit is given, at most maxsplit splits are done."
"B.rstrip([bytes]) -> bytearray\n\nStrip trailing bytes contained in the argument.\nIf the argument is omitted, strip trailing ASCII whitespace."
"B.split([sep[, maxsplit]]) -> list of bytearray\n\nReturn a list of the sections in B, using sep as the delimiter.\nIf sep is not given, B is split on ASCII whitespace characters\n(space, tab, return, newline, formfeed, vertical tab).\nIf maxsplit is given, at most maxsplit splits are done."
"B.splitlines([keepends]) -> list of lines\n\nReturn a list of the lines in B, breaking at line boundaries.\nLine breaks are not included in the resulting list unless keepends\nis given and true."
"B.startswith(prefix [,start [,end]]) -> bool\n\nReturn True if B starts with the specified prefix, False otherwise.\nWith optional start, test B beginning at that position.\nWith optional end, stop comparing B at that position.\nprefix can also be a tuple of strings to try."
"B.strip([bytes]) -> bytearray\n\nStrip leading and trailing bytes contained in the argument.\nIf the argument is omitted, strip ASCII whitespace."
"B.swapcase() -> copy of B\n\nReturn a copy of B with uppercase ASCII characters converted\nto lowercase ASCII and vice versa."
"B.title() -> copy of B\n\nReturn a titlecased version of B, i.e. ASCII words start with uppercase\ncharacters, all remaining cased characters have lowercase."
"B.translate(table[, deletechars]) -> bytearray\n\nReturn a copy of B, where all characters occurring in the\noptional argument deletechars are removed, and the remaining\ncharacters have been mapped through the given translation\ntable, which must be a bytes object of length 256."
"B.upper() -> copy of B\n\nReturn a copy of B with all ASCII characters converted to uppercase."
"B.zfill(width) -> copy of B\n\nPad a numeric string B with zeros on the left, to fill a field\nof the specified width. B is never truncated."
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
"default object formatter"
""
"descr.__get__(obj[, type]) -> value"
"x.__getattribute__(\'name\') <==> x.name"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"classmethod(function) -> method\n\nConvert a function to be a class method.\n\nA class method receives the class as implicit first argument,\njust like an instance method receives the instance.\nTo declare a class method, use this idiom:\n\n class C:\n def f(cls, arg1, arg2, ...): ...\n f = classmethod(f)\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()). The instance is ignored except for its class.\nIf a class method is called for a derived class, the derived class\nobject is passed as the implied first argument.\n\nClass methods are different than C++ or Java static methods.\nIf you want those, see the staticmethod builtin."
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__cmp__(y) <==> cmp(x,y)"
"x.__delattr__(\'name\') <==> del x.name"
"x.__eq__(y) <==> x==y"
"default object formatter"
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
"x.__gt__(y) <==> x>y"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__le__(y) <==> x<=y"
"x.__lt__(y) <==> x<y"
"x.__ne__(y) <==> x!=y"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
""
""
""
""
""
""
""
""
""
""
""
""
""
""
"code(argcount, nlocals, stacksize, flags, codestring, constants, names,\n varnames, filename, name, firstlineno, lnotab[, freevars[, cellvars]])\n\nCreate a code object. Not for the faint of heart."
"x.__abs__() <==> abs(x)"
"x.__add__(y) <==> x+y"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__coerce__(y) <==> coerce(x, y)"
"x.__delattr__(\'name\') <==> del x.name"
"x.__div__(y) <==> x/y"
"x.__divmod__(y) <==> divmod(x, y)"
"x.__eq__(y) <==> x==y"
"x.__float__() <==> float(x)"
"x.__floordiv__(y) <==> x//y"
"complex.__format__() -> str\n\nConverts to a string according to format_spec."
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
""
"x.__gt__(y) <==> x>y"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__int__() <==> int(x)"
"x.__le__(y) <==> x<=y"
"x.__long__() <==> long(x)"
"x.__lt__(y) <==> x<y"
"x.__mod__(y) <==> x%y"
"x.__mul__(y) <==> x*y"
"x.__ne__(y) <==> x!=y"
"x.__neg__() <==> -x"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"x.__nonzero__() <==> x != 0"
"x.__pos__() <==> +x"
"x.__pow__(y[, z]) <==> pow(x, y[, z])"
"x.__radd__(y) <==> y+x"
"x.__rdiv__(y) <==> y/x"
"x.__rdivmod__(y) <==> divmod(y, x)"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__rfloordiv__(y) <==> y//x"
"x.__rmod__(y) <==> y%x"
"x.__rmul__(y) <==> y*x"
"y.__rpow__(x[, z]) <==> pow(x, y[, z])"
"x.__rsub__(y) <==> y-x"
"x.__rtruediv__(y) <==> y/x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"x.__sub__(y) <==> x-y"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"x.__truediv__(y) <==> x/y"
"complex.conjugate() -> complex\n\nReturns the complex conjugate of its argument. (3-4j).conjugate() == 3+4j."
"complex(real[, imag]) -> complex number\n\nCreate a complex number from a real part and an optional imaginary part.\nThis is equivalent to (real + imag*1j) where imag defaults to 0."
"the imaginary part of a complex number"
"the real part of a complex number"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__cmp__(y) <==> cmp(x,y)"
"D.__contains__(k) -> True if D has a key k, else False"
"x.__delattr__(\'name\') <==> del x.name"
"x.__delitem__(y) <==> del x[y]"
"x.__eq__(y) <==> x==y"
"default object formatter"
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
"x.__getitem__(y) <==> x[y]"
"x.__gt__(y) <==> x>y"
""
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__iter__() <==> iter(x)"
"x.__le__(y) <==> x<=y"
"x.__len__() <==> len(x)"
"x.__lt__(y) <==> x<y"
"x.__ne__(y) <==> x!=y"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"x.__setitem__(i, y) <==> x[i]=y"
"D.__sizeof__() -> size of D in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"D.clear() -> None. Remove all items from D."
"D.copy() -> a shallow copy of D"
"dict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object\'s\n (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n d = {}\n for k, v in iterable:\n d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n in the keyword argument list. For example: dict(one=1, two=2)"
"dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.\nv defaults to None."
"D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None."
"D.has_key(k) -> True if D has a key k, else False"
"D.items() -> list of D\'s (key, value) pairs, as 2-tuples"
"D.iteritems() -> an iterator over the (key, value) items of D"
"D.iterkeys() -> an iterator over the keys of D"
"D.itervalues() -> an iterator over the values of D"
"D.keys() -> list of D\'s keys"
"D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\nIf key is not found, d is returned if given, otherwise KeyError is raised"
"D.popitem() -> (k, v), remove and return some (key, value) pair as a\n2-tuple; but raise KeyError if D is empty."
"D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D"
"D.update(E, **F) -> None. Update D from dict/iterable E and F.\nIf E has a .keys() method, does: for k in E: D[k] = E[k]\nIf E lacks .keys() method, does: for (k, v) in E: D[k] = v\nIn either case, this is followed by: for k in F: D[k] = F[k]"
"D.values() -> list of D\'s values"
"D.viewitems() -> a set-like object providing a view on D\'s items"
"D.viewkeys() -> a set-like object providing a view on D\'s keys"
"D.viewvalues() -> an object providing a view on D\'s values"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
"default object formatter"
"x.__getattribute__(\'name\') <==> x.name"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__iter__() <==> iter(x)"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"enumerate(iterable[, start]) -> iterator for index, value of iterable\n\nReturn an enumerate object. iterable must be another object that supports\niteration. The enumerate object yields pairs containing a count (from\nstart, which defaults to zero) and a value yielded by the iterable argument.\nenumerate is useful for obtaining an indexed list:\n (0, seq[0]), (1, seq[1]), (2, seq[2]), ..."
"x.next() -> the next value, or raise StopIteration"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
"__enter__() -> self."
"__exit__(*excinfo) -> None. Closes the file."
"default object formatter"
"x.__getattribute__(\'name\') <==> x.name"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__iter__() <==> iter(x)"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"close() -> None or (perhaps) an integer. Close the file.\n\nSets data attribute .closed to True. A closed file cannot be used for\nfurther I/O operations. close() may be called more than once without\nerror. Some kinds of file objects (for example, opened by popen())\nmay return an exit status upon closing."
"True if the file is closed"
"file(name[, mode[, buffering]]) -> file object\n\nOpen a file. The mode can be \'r\', \'w\' or \'a\' for reading (default),\nwriting or appending. The file will be created if it doesn\'t exist\nwhen opened for writing or appending; it will be truncated when\nopened for writing. Add a \'b\' to the mode for binary files.\nAdd a \'+\' to the mode to allow simultaneous reading and writing.\nIf the buffering argument is given, 0 means unbuffered, 1 means line\nbuffered, and larger numbers specify the buffer size. The preferred way\nto open a file is with the builtin open() function.\nAdd a \'U\' to mode to open the file for input with universal newline\nsupport. Any line ending in the input file will be seen as a \'\\n\'\nin Python. Also, a file so opened gains the attribute \'newlines\';\nthe value for this attribute is one of None (no newline read yet),\n\'\\r\', \'\\n\', \'\\r\\n\' or a tuple containing all the newline types seen.\n\n\'U\' cannot be combined with \'w\' or \'+\' mode.\n"
"file encoding"
"Unicode error handler"
"fileno() -> integer \"file descriptor\".\n\nThis is needed for lower-level file interfaces, such os.read()."
"flush() -> None. Flush the internal I/O buffer."
"isatty() -> true or false. True if the file is connected to a tty device."
"file mode (\'r\', \'U\', \'w\', \'a\', possibly with \'b\' or \'+\' added)"
"file name"
"end-of-line convention used in this file"
"x.next() -> the next value, or raise StopIteration"
"read([size]) -> read at most size bytes, returned as a string.\n\nIf the size argument is negative or omitted, read until EOF is reached.\nNotice that when in non-blocking mode, less data than what was requested\nmay be returned, even if no size parameter was given."
"readinto() -> Undocumented. Don\'t use this; it may go away."
"readline([size]) -> next line from the file, as a string.\n\nRetain newline. A non-negative size argument limits the maximum\nnumber of bytes to return (an incomplete line may be returned then).\nReturn an empty string at EOF."
"readlines([size]) -> list of strings, each a line from the file.\n\nCall readline() repeatedly and return a list of the lines so read.\nThe optional size argument, if given, is an approximate bound on the\ntotal number of bytes in the lines returned."
"seek(offset[, whence]) -> None. Move to new file position.\n\nArgument offset is a byte count. Optional argument whence defaults to\n0 (offset from start of file, offset should be >= 0); other values are 1\n(move relative to current position, positive or negative), and 2 (move\nrelative to end of file, usually negative, although many platforms allow\nseeking beyond the end of a file). If the file is opened in text mode,\nonly offsets returned by tell() are legal. Use of other offsets causes\nundefined behavior.\nNote that not all file objects are seekable."
"flag indicating that a space needs to be printed; used by print"
"tell() -> current file position, an integer (may be a long integer)."
"truncate([size]) -> None. Truncate the file to at most size bytes.\n\nSize defaults to the current file position, as returned by tell()."
"write(str) -> None. Write string str to file.\n\nNote that due to buffering, flush() or close() may be needed before\nthe file on disk reflects the data written."
"writelines(sequence_of_strings) -> None. Write the strings to the file.\n\nNote that newlines are not added. The sequence can be any iterable object\nproducing strings. This is equivalent to calling write() for each string."
"xreadlines() -> returns self.\n\nFor backward compatibility. File objects now include the performance\noptimizations previously implemented in the xreadlines module."
"x.__abs__() <==> abs(x)"
"x.__add__(y) <==> x+y"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__coerce__(y) <==> coerce(x, y)"
"x.__delattr__(\'name\') <==> del x.name"
"x.__div__(y) <==> x/y"
"x.__divmod__(y) <==> divmod(x, y)"
"x.__eq__(y) <==> x==y"
"x.__float__() <==> float(x)"
"x.__floordiv__(y) <==> x//y"
"float.__format__(format_spec) -> string\n\nFormats the float according to format_spec."
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
"float.__getformat__(typestr) -> string\n\nYou probably don\'t want to use this function. It exists mainly to be\nused in Python\'s test suite.\n\ntypestr must be \'double\' or \'float\'. This function returns whichever of\n\'unknown\', \'IEEE, big-endian\' or \'IEEE, little-endian\' best describes the\nformat of floating point numbers used by the C type named by typestr."
""
"x.__gt__(y) <==> x>y"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__int__() <==> int(x)"
"x.__le__(y) <==> x<=y"
"x.__long__() <==> long(x)"
"x.__lt__(y) <==> x<y"
"x.__mod__(y) <==> x%y"
"x.__mul__(y) <==> x*y"
"x.__ne__(y) <==> x!=y"
"x.__neg__() <==> -x"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"x.__nonzero__() <==> x != 0"
"x.__pos__() <==> +x"
"x.__pow__(y[, z]) <==> pow(x, y[, z])"
"x.__radd__(y) <==> y+x"
"x.__rdiv__(y) <==> y/x"
"x.__rdivmod__(y) <==> divmod(y, x)"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__rfloordiv__(y) <==> y//x"
"x.__rmod__(y) <==> y%x"
"x.__rmul__(y) <==> y*x"
"y.__rpow__(x[, z]) <==> pow(x, y[, z])"
"x.__rsub__(y) <==> y-x"
"x.__rtruediv__(y) <==> y/x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"float.__setformat__(typestr, fmt) -> None\n\nYou probably don\'t want to use this function. It exists mainly to be\nused in Python\'s test suite.\n\ntypestr must be \'double\' or \'float\'. fmt must be one of \'unknown\',\n\'IEEE, big-endian\' or \'IEEE, little-endian\', and in addition can only be\none of the latter two if it appears to match the underlying C reality.\n\nOverrides the automatic determination of C-level floating point type.\nThis affects how floats are converted to and from binary strings."
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"x.__sub__(y) <==> x-y"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"x.__truediv__(y) <==> x/y"
"Returns the Integral closest to x between 0 and x."
"float.as_integer_ratio() -> (int, int)\n\nReturns a pair of integers, whose ratio is exactly equal to the original\nfloat and with a positive denominator.\nRaises OverflowError on infinities and a ValueError on NaNs.\n\n>>> (10.0).as_integer_ratio()\n(10, 1)\n>>> (0.0).as_integer_ratio()\n(0, 1)\n>>> (-.25).as_integer_ratio()\n(-1, 4)"
"Returns self, the complex conjugate of any float."
"float(x) -> floating point number\n\nConvert a string or number to a floating point number, if possible."
"float.fromhex(string) -> float\n\nCreate a floating-point number from a hexadecimal string.\n>>> float.fromhex(\'0x1.ffffp10\')\n2047.984375\n>>> float.fromhex(\'-0x1p-1074\')\n-4.9406564584124654e-324"
"float.hex() -> string\n\nReturn a hexadecimal representation of a floating-point number.\n>>> (-0.1).hex()\n\'-0x1.999999999999ap-4\'\n>>> 3.14159.hex()\n\'0x1.921f9f01b866ep+1\'"
"the imaginary part of a complex number"
"Returns True if the float is an integer."
"the real part of a complex number"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
"default object formatter"
"x.__getattribute__(\'name\') <==> x.name"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"F.__sizeof__() -> size of F in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
""
""
""
""
""
""
""
""
""
""
""
""
""
"x.__and__(y) <==> x&y"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__cmp__(y) <==> cmp(x,y)"
"x.__contains__(y) <==> y in x."
"x.__delattr__(\'name\') <==> del x.name"
"x.__eq__(y) <==> x==y"
"default object formatter"
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
"x.__gt__(y) <==> x>y"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__iter__() <==> iter(x)"
"x.__le__(y) <==> x<=y"
"x.__len__() <==> len(x)"
"x.__lt__(y) <==> x<y"
"x.__ne__(y) <==> x!=y"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"x.__or__(y) <==> x|y"
"x.__rand__(y) <==> y&x"
"Return state information for pickling."
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__ror__(y) <==> y|x"
"x.__rsub__(y) <==> y-x"
"x.__rxor__(y) <==> y^x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"S.__sizeof__() -> size of S in memory, in bytes"
"x.__str__() <==> str(x)"
"x.__sub__(y) <==> x-y"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"x.__xor__(y) <==> x^y"
"Return a shallow copy of a set."
"Return the difference of two or more sets as a new set.\n\n(i.e. all elements that are in this set but not the others.)"
"frozenset() -> empty frozenset object\nfrozenset(iterable) -> frozenset object\n\nBuild an immutable unordered collection of unique elements."
"Return the intersection of two or more sets as a new set.\n\n(i.e. elements that are common to all of the sets.)"
"Return True if two sets have a null intersection."
"Report whether another set contains this set."
"Report whether this set contains another set."
"Return the symmetric difference of two sets as a new set.\n\n(i.e. all elements that are in exactly one of the sets.)"
"Return the union of sets as a new set.\n\n(i.e. all elements that are in either set.)"
"x.__call__(...) <==> x(...)"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
""
""
""
"x.__delattr__(\'name\') <==> del x.name"
""
"default object formatter"
"descr.__get__(obj[, type]) -> value"
"x.__getattribute__(\'name\') <==> x.name"
""
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"str(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object."
"str(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object."
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"function(code, globals[, name[, argdefs[, closure]]])\n\nCreate a function object from a code object and a dictionary.\nThe optional name string overrides the name from the code object.\nThe optional argdefs tuple specifies the default argument values.\nThe optional closure tuple supplies the bindings for free variables."
""
""
""
""
""
""
""
"x.__call__(...) <==> x(...)"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__cmp__(y) <==> cmp(x,y)"
"x.__delattr__(\'name\') <==> del x.name"
"default object formatter"
"the function (or other callable) implementing a method"
"descr.__get__(obj[, type]) -> value"
"x.__getattribute__(\'name\') <==> x.name"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"the instance to which a method is bound; None for unbound methods"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"instancemethod(function, instance, class)\n\nCreate an instance method object."
"the class associated with a method"
"the function (or other callable) implementing a method"
"the instance to which a method is bound; None for unbound methods"
"x.__abs__() <==> abs(x)"
"x.__add__(y) <==> x+y"
"x.__and__(y) <==> x&y"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__cmp__(y) <==> cmp(x,y)"
"x.__coerce__(y) <==> coerce(x, y)"
"x.__delattr__(\'name\') <==> del x.name"
"x.__div__(y) <==> x/y"
"x.__divmod__(y) <==> divmod(x, y)"
"x.__float__() <==> float(x)"
"x.__floordiv__(y) <==> x//y"
""
"x.__getattribute__(\'name\') <==> x.name"
""
"x.__hash__() <==> hash(x)"
"x.__hex__() <==> hex(x)"
"x[y:z] <==> x[y.__index__():z.__index__()]"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__int__() <==> int(x)"
"x.__invert__() <==> ~x"
"x.__long__() <==> long(x)"
"x.__lshift__(y) <==> x<<y"
"x.__mod__(y) <==> x%y"
"x.__mul__(y) <==> x*y"
"x.__neg__() <==> -x"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"x.__nonzero__() <==> x != 0"
"x.__oct__() <==> oct(x)"
"x.__or__(y) <==> x|y"
"x.__pos__() <==> +x"
"x.__pow__(y[, z]) <==> pow(x, y[, z])"
"x.__radd__(y) <==> y+x"
"x.__rand__(y) <==> y&x"
"x.__rdiv__(y) <==> y/x"
"x.__rdivmod__(y) <==> divmod(y, x)"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__rfloordiv__(y) <==> y//x"
"x.__rlshift__(y) <==> y<<x"
"x.__rmod__(y) <==> y%x"
"x.__rmul__(y) <==> y*x"
"x.__ror__(y) <==> y|x"
"y.__rpow__(x[, z]) <==> pow(x, y[, z])"
"x.__rrshift__(y) <==> y>>x"
"x.__rshift__(y) <==> x>>y"
"x.__rsub__(y) <==> y-x"
"x.__rtruediv__(y) <==> y/x"
"x.__rxor__(y) <==> y^x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"x.__sub__(y) <==> x-y"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"x.__truediv__(y) <==> x/y"
"Truncating an Integral returns itself."
"x.__xor__(y) <==> x^y"
"int.bit_length() -> int\n\nNumber of bits necessary to represent self in binary.\n>>> bin(37)\n\'0b100101\'\n>>> (37).bit_length()\n6"
"Returns self, the complex conjugate of any int."
"the denominator of a rational number in lowest terms"
"int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible. A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!) When converting a string, use\nthe optional base. It is an error to supply a base when converting a\nnon-string. If base is zero, the proper base is guessed based on the\nstring content. If the argument is outside the integer range a\nlong object will be returned instead."
"the imaginary part of a complex number"
"the numerator of a rational number in lowest terms"
"the real part of a complex number"
"x.__add__(y) <==> x+y"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__contains__(y) <==> y in x"
"x.__delattr__(\'name\') <==> del x.name"
"x.__delitem__(y) <==> del x[y]"
"x.__delslice__(i, j) <==> del x[i:j]\n \n Use of negative indices is not supported."
"x.__eq__(y) <==> x==y"
"default object formatter"
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
"x.__getitem__(y) <==> x[y]"
"x.__getslice__(i, j) <==> x[i:j]\n \n Use of negative indices is not supported."
"x.__gt__(y) <==> x>y"
""
"x.__iadd__(y) <==> x+=y"
"x.__imul__(y) <==> x*=y"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__iter__() <==> iter(x)"
"x.__le__(y) <==> x<=y"
"x.__len__() <==> len(x)"
"x.__lt__(y) <==> x<y"
"x.__mul__(n) <==> x*n"
"x.__ne__(y) <==> x!=y"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"L.__reversed__() -- return a reverse iterator over the list"
"x.__rmul__(n) <==> n*x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"x.__setitem__(i, y) <==> x[i]=y"
"x.__setslice__(i, j, y) <==> x[i:j]=y\n \n Use of negative indices is not supported."
"L.__sizeof__() -- size of L in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"L.append(object) -- append object to end"
"L.count(value) -> integer -- return number of occurrences of value"
"list() -> new empty list\nlist(iterable) -> new list initialized from iterable\'s items"
"L.extend(iterable) -- extend list by appending elements from the iterable"
"L.index(value, [start, [stop]]) -> integer -- return first index of value.\nRaises ValueError if the value is not present."
"L.insert(index, object) -- insert object before index"
"L.pop([index]) -> item -- remove and return item at index (default last).\nRaises IndexError if list is empty or index is out of range."
"L.remove(value) -- remove first occurrence of value.\nRaises ValueError if the value is not present."
"L.reverse() -- reverse *IN PLACE*"
"L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;\ncmp(x, y) -> -1, 0, 1"
"x.__abs__() <==> abs(x)"
"x.__add__(y) <==> x+y"
"x.__and__(y) <==> x&y"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__cmp__(y) <==> cmp(x,y)"
"x.__coerce__(y) <==> coerce(x, y)"
"x.__delattr__(\'name\') <==> del x.name"
"x.__div__(y) <==> x/y"
"x.__divmod__(y) <==> divmod(x, y)"
"x.__float__() <==> float(x)"
"x.__floordiv__(y) <==> x//y"
""
"x.__getattribute__(\'name\') <==> x.name"
""
"x.__hash__() <==> hash(x)"
"x.__hex__() <==> hex(x)"
"x[y:z] <==> x[y.__index__():z.__index__()]"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__int__() <==> int(x)"
"x.__invert__() <==> ~x"
"x.__long__() <==> long(x)"
"x.__lshift__(y) <==> x<<y"
"x.__mod__(y) <==> x%y"
"x.__mul__(y) <==> x*y"
"x.__neg__() <==> -x"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"x.__nonzero__() <==> x != 0"
"x.__oct__() <==> oct(x)"
"x.__or__(y) <==> x|y"
"x.__pos__() <==> +x"
"x.__pow__(y[, z]) <==> pow(x, y[, z])"
"x.__radd__(y) <==> y+x"
"x.__rand__(y) <==> y&x"
"x.__rdiv__(y) <==> y/x"
"x.__rdivmod__(y) <==> divmod(y, x)"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__rfloordiv__(y) <==> y//x"
"x.__rlshift__(y) <==> y<<x"
"x.__rmod__(y) <==> y%x"
"x.__rmul__(y) <==> y*x"
"x.__ror__(y) <==> y|x"
"y.__rpow__(x[, z]) <==> pow(x, y[, z])"
"x.__rrshift__(y) <==> y>>x"
"x.__rshift__(y) <==> x>>y"
"x.__rsub__(y) <==> y-x"
"x.__rtruediv__(y) <==> y/x"
"x.__rxor__(y) <==> y^x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"Returns size in memory, in bytes"
"x.__str__() <==> str(x)"
"x.__sub__(y) <==> x-y"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"x.__truediv__(y) <==> x/y"
"Truncating an Integral returns itself."
"x.__xor__(y) <==> x^y"
"long.bit_length() -> int or long\n\nNumber of bits necessary to represent self in binary.\n>>> bin(37L)\n\'0b100101\'\n>>> (37L).bit_length()\n6"
"Returns self, the complex conjugate of any long."
"the denominator of a rational number in lowest terms"
"long(x[, base]) -> integer\n\nConvert a string or number to a long integer, if possible. A floating\npoint argument will be truncated towards zero (this does not include a\nstring representation of a floating point number!) When converting a\nstring, use the optional base. It is an error to supply a base when\nconverting a non-string."
"the imaginary part of a complex number"
"the numerator of a rational number in lowest terms"
"the real part of a complex number"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
"x.__delitem__(y) <==> del x[y]"
"x.__eq__(y) <==> x==y"
"default object formatter"
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
"x.__getitem__(y) <==> x[y]"
"x.__gt__(y) <==> x>y"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__le__(y) <==> x<=y"
"x.__len__() <==> len(x)"
"x.__lt__(y) <==> x<y"
"x.__ne__(y) <==> x!=y"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"x.__setitem__(i, y) <==> x[i]=y"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"memoryview(object)\n\nCreate a new memoryview object which references the given object."
""
""
""
""
""
""
""
""
""
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
"default object formatter"
"x.__getattribute__(\'name\') <==> x.name"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"The most base type"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
"descr.__delete__(obj)"
"default object formatter"
"descr.__get__(obj[, type]) -> value"
"x.__getattribute__(\'name\') <==> x.name"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"descr.__set__(obj, value)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"Descriptor to change the deleter on a property."
"property(fget=None, fset=None, fdel=None, doc=None) -> property attribute\n\nfget is a function to be used for getting an attribute value, and likewise\nfset is a function for setting, and fdel a function for del\'ing, an\nattribute. Typical use is to define a managed attribute x:\nclass C(object):\n def getx(self): return self._x\n def setx(self, value): self._x = value\n def delx(self): del self._x\n x = property(getx, setx, delx, \"I\'m the \'x\' property.\")\n\nDecorators make defining new properties or modifying existing ones easy:\nclass C(object):\n @property\n def x(self): return self._x\n @x.setter\n def x(self, value): self._x = value\n @x.deleter\n def x(self): del self._x\n"
""
""
""
"Descriptor to change the getter on a property."
"Descriptor to change the setter on a property."
"x.__and__(y) <==> x&y"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__cmp__(y) <==> cmp(x,y)"
"x.__contains__(y) <==> y in x."
"x.__delattr__(\'name\') <==> del x.name"
"x.__eq__(y) <==> x==y"
"default object formatter"
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
"x.__gt__(y) <==> x>y"
""
"x.__iand__(y) <==> x&y"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__ior__(y) <==> x|y"
"x.__isub__(y) <==> x-y"
"x.__iter__() <==> iter(x)"
"x.__ixor__(y) <==> x^y"
"x.__le__(y) <==> x<=y"
"x.__len__() <==> len(x)"
"x.__lt__(y) <==> x<y"
"x.__ne__(y) <==> x!=y"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"x.__or__(y) <==> x|y"
"x.__rand__(y) <==> y&x"
"Return state information for pickling."
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__ror__(y) <==> y|x"
"x.__rsub__(y) <==> y-x"
"x.__rxor__(y) <==> y^x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"S.__sizeof__() -> size of S in memory, in bytes"
"x.__str__() <==> str(x)"
"x.__sub__(y) <==> x-y"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"x.__xor__(y) <==> x^y"
"Add an element to a set.\n\nThis has no effect if the element is already present."
"Remove all elements from this set."
"Return a shallow copy of a set."
"Return the difference of two or more sets as a new set.\n\n(i.e. all elements that are in this set but not the others.)"
"Remove all elements of another set from this set."
"Remove an element from a set if it is a member.\n\nIf the element is not a member, do nothing."
"set() -> new empty set object\nset(iterable) -> new set object\n\nBuild an unordered collection of unique elements."
"Return the intersection of two or more sets as a new set.\n\n(i.e. elements that are common to all of the sets.)"
"Update a set with the intersection of itself and another."
"Return True if two sets have a null intersection."
"Report whether another set contains this set."
"Report whether this set contains another set."
"Remove and return an arbitrary set element.\nRaises KeyError if the set is empty."
"Remove an element from a set; it must be a member.\n\nIf the element is not a member, raise a KeyError."
"Return the symmetric difference of two sets as a new set.\n\n(i.e. all elements that are in exactly one of the sets.)"
"Update a set with the symmetric difference of itself and another."
"Return the union of sets as a new set.\n\n(i.e. all elements that are in either set.)"
"Update a set with the union of itself and others."
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__cmp__(y) <==> cmp(x,y)"
"x.__delattr__(\'name\') <==> del x.name"
"default object formatter"
"x.__getattribute__(\'name\') <==> x.name"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"Return state information for pickling."
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"slice([start,] stop[, step])\n\nCreate a slice object. This is used for extended slicing (e.g. a[0:10:2])."
"S.indices(len) -> (start, stop, stride)\n\nAssuming a sequence of length len, calculate the start and stop\nindices, and the stride length of the extended slice described by\nS. Out of bounds indices are clipped in a manner consistent with the\nhandling of normal slices."
""
""
""
"Compiled regular expression objects"
"findall(string[, pos[, endpos]]) --> list.\n Return a list of all non-overlapping matches of pattern in string."
"finditer(string[, pos[, endpos]]) --> iterator.\n Return an iterator over all non-overlapping matches for the \n RE pattern in string. For each match, the iterator returns a\n match object."
"match(string[, pos[, endpos]]) --> match object or None.\n Matches zero or more characters at the beginning of the string"
"search(string[, pos[, endpos]]) --> match object or None.\n Scan through string looking for a match, and return a corresponding\n match object instance. Return None if no position in the string matches."
"split(string[, maxsplit = 0]) --> list.\n Split string by the occurrences of pattern."
"sub(repl, string[, count = 0]) --> newstring\n Return the string obtained by replacing the leftmost non-overlapping\n occurrences of pattern in string by the replacement repl."
"subn(repl, string[, count = 0]) --> (newstring, number of subs)\n Return the tuple (new_string, number_of_subs_made) found by replacing\n the leftmost non-overlapping occurrences of pattern with the\n replacement repl."
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
"default object formatter"
""
"descr.__get__(obj[, type]) -> value"
"x.__getattribute__(\'name\') <==> x.name"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"staticmethod(function) -> method\n\nConvert a function to be a static method.\n\nA static method does not receive an implicit first argument.\nTo declare a static method, use this idiom:\n\n class C:\n def f(arg1, arg2, ...): ...\n f = staticmethod(f)\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()). The instance is ignored except for its class.\n\nStatic methods in Python are similar to those found in Java or C++.\nFor a more advanced concept, see the classmethod builtin."
"x.__add__(y) <==> x+y"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__contains__(y) <==> y in x"
"x.__delattr__(\'name\') <==> del x.name"
"x.__eq__(y) <==> x==y"
"S.__format__(format_spec) -> string\n\nReturn a formatted version of S as described by format_spec."
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
"x.__getitem__(y) <==> x[y]"
""
"x.__getslice__(i, j) <==> x[i:j]\n \n Use of negative indices is not supported."
"x.__gt__(y) <==> x>y"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__le__(y) <==> x<=y"
"x.__len__() <==> len(x)"
"x.__lt__(y) <==> x<y"
"x.__mod__(y) <==> x%y"
"x.__mul__(n) <==> x*n"
"x.__ne__(y) <==> x!=y"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__rmod__(y) <==> y%x"
"x.__rmul__(n) <==> n*x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"S.__sizeof__() -> size of S in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
""
""
"S.capitalize() -> string\n\nReturn a copy of the string S with only its first character\ncapitalized."
"S.center(width[, fillchar]) -> string\n\nReturn S centered in a string of length width. Padding is\ndone using the specified fill character (default is a space)"
"S.count(sub[, start[, end]]) -> int\n\nReturn the number of non-overlapping occurrences of substring sub in\nstring S[start:end]. Optional arguments start and end are interpreted\nas in slice notation."
"S.decode([encoding[,errors]]) -> object\n\nDecodes S using the codec registered for encoding. encoding defaults\nto the default encoding. errors may be given to set a different error\nhandling scheme. Default is \'strict\' meaning that encoding errors raise\na UnicodeDecodeError. Other possible values are \'ignore\' and \'replace\'\nas well as any other name registered with codecs.register_error that is\nable to handle UnicodeDecodeErrors."
"str(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object."
"S.encode([encoding[,errors]]) -> object\n\nEncodes S using the codec registered for encoding. encoding defaults\nto the default encoding. errors may be given to set a different error\nhandling scheme. Default is \'strict\' meaning that encoding errors raise\na UnicodeEncodeError. Other possible values are \'ignore\', \'replace\' and\n\'xmlcharrefreplace\' as well as any other name registered with\ncodecs.register_error that is able to handle UnicodeEncodeErrors."
"S.endswith(suffix[, start[, end]]) -> bool\n\nReturn True if S ends with the specified suffix, False otherwise.\nWith optional start, test S beginning at that position.\nWith optional end, stop comparing S at that position.\nsuffix can also be a tuple of strings to try."
"S.expandtabs([tabsize]) -> string\n\nReturn a copy of S where all tab characters are expanded using spaces.\nIf tabsize is not given, a tab size of 8 characters is assumed."
"S.find(sub [,start [,end]]) -> int\n\nReturn the lowest index in S where substring sub is found,\nsuch that sub is contained within s[start:end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure."
"S.format(*args, **kwargs) -> string\n\nReturn a formatted version of S, using substitutions from args and kwargs.\nThe substitutions are identified by braces (\'{\' and \'}\')."
"S.index(sub [,start [,end]]) -> int\n\nLike S.find() but raise ValueError when the substring is not found."
"S.isalnum() -> bool\n\nReturn True if all characters in S are alphanumeric\nand there is at least one character in S, False otherwise."
"S.isalpha() -> bool\n\nReturn True if all characters in S are alphabetic\nand there is at least one character in S, False otherwise."
"S.isdigit() -> bool\n\nReturn True if all characters in S are digits\nand there is at least one character in S, False otherwise."
"S.islower() -> bool\n\nReturn True if all cased characters in S are lowercase and there is\nat least one cased character in S, False otherwise."
"S.isspace() -> bool\n\nReturn True if all characters in S are whitespace\nand there is at least one character in S, False otherwise."
"S.istitle() -> bool\n\nReturn True if S is a titlecased string and there is at least one\ncharacter in S, i.e. uppercase characters may only follow uncased\ncharacters and lowercase characters only cased ones. Return False\notherwise."
"S.isupper() -> bool\n\nReturn True if all cased characters in S are uppercase and there is\nat least one cased character in S, False otherwise."
"S.join(iterable) -> string\n\nReturn a string which is the concatenation of the strings in the\niterable. The separator between elements is S."
"S.ljust(width[, fillchar]) -> string\n\nReturn S left-justified in a string of length width. Padding is\ndone using the specified fill character (default is a space)."
"S.lower() -> string\n\nReturn a copy of the string S converted to lowercase."
"S.lstrip([chars]) -> string or unicode\n\nReturn a copy of the string S with leading whitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is unicode, S will be converted to unicode before stripping"
"S.partition(sep) -> (head, sep, tail)\n\nSearch for the separator sep in S, and return the part before it,\nthe separator itself, and the part after it. If the separator is not\nfound, return S and two empty strings."
"S.replace(old, new[, count]) -> string\n\nReturn a copy of string S with all occurrences of substring\nold replaced by new. If the optional argument count is\ngiven, only the first count occurrences are replaced."
"S.rfind(sub [,start [,end]]) -> int\n\nReturn the highest index in S where substring sub is found,\nsuch that sub is contained within s[start:end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure."
"S.rindex(sub [,start [,end]]) -> int\n\nLike S.rfind() but raise ValueError when the substring is not found."
"S.rjust(width[, fillchar]) -> string\n\nReturn S right-justified in a string of length width. Padding is\ndone using the specified fill character (default is a space)"
"S.rpartition(sep) -> (head, sep, tail)\n\nSearch for the separator sep in S, starting at the end of S, and return\nthe part before it, the separator itself, and the part after it. If the\nseparator is not found, return two empty strings and S."
"S.rsplit([sep [,maxsplit]]) -> list of strings\n\nReturn a list of the words in the string S, using sep as the\ndelimiter string, starting at the end of the string and working\nto the front. If maxsplit is given, at most maxsplit splits are\ndone. If sep is not specified or is None, any whitespace string\nis a separator."
"S.rstrip([chars]) -> string or unicode\n\nReturn a copy of the string S with trailing whitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is unicode, S will be converted to unicode before stripping"
"S.split([sep [,maxsplit]]) -> list of strings\n\nReturn a list of the words in the string S, using sep as the\ndelimiter string. If maxsplit is given, at most maxsplit\nsplits are done. If sep is not specified or is None, any\nwhitespace string is a separator and empty strings are removed\nfrom the result."
"S.splitlines([keepends]) -> list of strings\n\nReturn a list of the lines in S, breaking at line boundaries.\nLine breaks are not included in the resulting list unless keepends\nis given and true."
"S.startswith(prefix[, start[, end]]) -> bool\n\nReturn True if S starts with the specified prefix, False otherwise.\nWith optional start, test S beginning at that position.\nWith optional end, stop comparing S at that position.\nprefix can also be a tuple of strings to try."
"S.strip([chars]) -> string or unicode\n\nReturn a copy of the string S with leading and trailing\nwhitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is unicode, S will be converted to unicode before stripping"
"S.swapcase() -> string\n\nReturn a copy of the string S with uppercase characters\nconverted to lowercase and vice versa."
"S.title() -> string\n\nReturn a titlecased version of S, i.e. words start with uppercase\ncharacters, all remaining cased characters have lowercase."
"S.translate(table [,deletechars]) -> string\n\nReturn a copy of the string S, where all characters occurring\nin the optional argument deletechars are removed, and the\nremaining characters have been mapped through the given\ntranslation table, which must be a string of length 256."
"S.upper() -> string\n\nReturn a copy of the string S converted to uppercase."
"S.zfill(width) -> string\n\nPad a numeric string S with zeros on the left, to fill a field\nof the specified width. The string S is never truncated."
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
"default object formatter"
"descr.__get__(obj[, type]) -> value"
"x.__getattribute__(\'name\') <==> x.name"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"the instance invoking super(); may be None"
"the type of the instance invoking super(); may be None"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"the class invoking super()"
"super(type) -> unbound super object\nsuper(type, obj) -> bound super object; requires isinstance(obj, type)\nsuper(type, type2) -> bound super object; requires issubclass(type2, type)\nTypical use to call a cooperative superclass method:\nclass C(B):\n def meth(self, arg):\n super(C, self).meth(arg)"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
"default object formatter"
"x.__getattribute__(\'name\') <==> x.name"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
""
""
""
""
""
"x.__add__(y) <==> x+y"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__contains__(y) <==> y in x"
"x.__delattr__(\'name\') <==> del x.name"
"x.__eq__(y) <==> x==y"
"default object formatter"
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
"x.__getitem__(y) <==> x[y]"
""
"x.__getslice__(i, j) <==> x[i:j]\n \n Use of negative indices is not supported."
"x.__gt__(y) <==> x>y"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__iter__() <==> iter(x)"
"x.__le__(y) <==> x<=y"
"x.__len__() <==> len(x)"
"x.__lt__(y) <==> x<y"
"x.__mul__(n) <==> x*n"
"x.__ne__(y) <==> x!=y"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__rmul__(n) <==> n*x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"T.__sizeof__() -- size of T in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"T.count(value) -> integer -- return number of occurrences of value"
"tuple() -> empty tuple\ntuple(iterable) -> tuple initialized from iterable\'s items\n\nIf the argument is a tuple, the return value is the same object."
"T.index(value, [start, [stop]]) -> integer -- return first index of value.\nRaises ValueError if the value is not present."
""
"The most base type"
"tuple() -> empty tuple\ntuple(iterable) -> tuple initialized from iterable\'s items\n\nIf the argument is a tuple, the return value is the same object."
"int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible. A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!) When converting a string, use\nthe optional base. It is an error to supply a base when converting a\nnon-string. If base is zero, the proper base is guessed based on the\nstring content. If the argument is outside the integer range a\nlong object will be returned instead."
"x.__call__(...) <==> x(...)"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
""
"int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible. A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!) When converting a string, use\nthe optional base. It is an error to supply a base when converting a\nnon-string. If base is zero, the proper base is guessed based on the\nstring content. If the argument is outside the integer range a\nlong object will be returned instead."
"x.__eq__(y) <==> x==y"
"int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible. A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!) When converting a string, use\nthe optional base. It is an error to supply a base when converting a\nnon-string. If base is zero, the proper base is guessed based on the\nstring content. If the argument is outside the integer range a\nlong object will be returned instead."
"default object formatter"
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
"x.__gt__(y) <==> x>y"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"__instancecheck__() -> bool\ncheck if an object is an instance"
"int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible. A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!) When converting a string, use\nthe optional base. It is an error to supply a base when converting a\nnon-string. If base is zero, the proper base is guessed based on the\nstring content. If the argument is outside the integer range a\nlong object will be returned instead."
"x.__le__(y) <==> x<=y"
"x.__lt__(y) <==> x<y"
"str(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object."
"tuple() -> empty tuple\ntuple(iterable) -> tuple initialized from iterable\'s items\n\nIf the argument is a tuple, the return value is the same object."
"str(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object."
"x.__ne__(y) <==> x!=y"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"__subclasscheck__() -> bool\ncheck if a class is a subclass"
"__subclasses__() -> list of immediate subclasses"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible. A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!) When converting a string, use\nthe optional base. It is an error to supply a base when converting a\nnon-string. If base is zero, the proper base is guessed based on the\nstring content. If the argument is outside the integer range a\nlong object will be returned instead."
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"mro() -> list\nreturn a type\'s method resolution order"
"x.__add__(y) <==> x+y"
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__contains__(y) <==> y in x"
"x.__delattr__(\'name\') <==> del x.name"
"x.__eq__(y) <==> x==y"
"S.__format__(format_spec) -> unicode\n\nReturn a formatted version of S as described by format_spec."
"x.__ge__(y) <==> x>=y"
"x.__getattribute__(\'name\') <==> x.name"
"x.__getitem__(y) <==> x[y]"
""
"x.__getslice__(i, j) <==> x[i:j]\n \n Use of negative indices is not supported."
"x.__gt__(y) <==> x>y"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__le__(y) <==> x<=y"
"x.__len__() <==> len(x)"
"x.__lt__(y) <==> x<y"
"x.__mod__(y) <==> x%y"
"x.__mul__(n) <==> x*n"
"x.__ne__(y) <==> x!=y"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
"helper for pickle"
"helper for pickle"
"x.__repr__() <==> repr(x)"
"x.__rmod__(y) <==> y%x"
"x.__rmul__(n) <==> n*x"
"x.__setattr__(\'name\', value) <==> x.name = value"
"S.__sizeof__() -> size of S in memory, in bytes\n\n"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
""
""
"S.capitalize() -> unicode\n\nReturn a capitalized version of S, i.e. make the first character\nhave upper case and the rest lower case."
"S.center(width[, fillchar]) -> unicode\n\nReturn S centered in a Unicode string of length width. Padding is\ndone using the specified fill character (default is a space)"
"S.count(sub[, start[, end]]) -> int\n\nReturn the number of non-overlapping occurrences of substring sub in\nUnicode string S[start:end]. Optional arguments start and end are\ninterpreted as in slice notation."
"S.decode([encoding[,errors]]) -> string or unicode\n\nDecodes S using the codec registered for encoding. encoding defaults\nto the default encoding. errors may be given to set a different error\nhandling scheme. Default is \'strict\' meaning that encoding errors raise\na UnicodeDecodeError. Other possible values are \'ignore\' and \'replace\'\nas well as any other name registerd with codecs.register_error that is\nable to handle UnicodeDecodeErrors."
"unicode(object=\'\') -> unicode object\nunicode(string[, encoding[, errors]]) -> unicode object\n\nCreate a new Unicode object from the given encoded string.\nencoding defaults to the current default string encoding.\nerrors can be \'strict\', \'replace\' or \'ignore\' and defaults to \'strict\'."
"S.encode([encoding[,errors]]) -> string or unicode\n\nEncodes S using the codec registered for encoding. encoding defaults\nto the default encoding. errors may be given to set a different error\nhandling scheme. Default is \'strict\' meaning that encoding errors raise\na UnicodeEncodeError. Other possible values are \'ignore\', \'replace\' and\n\'xmlcharrefreplace\' as well as any other name registered with\ncodecs.register_error that can handle UnicodeEncodeErrors."
"S.endswith(suffix[, start[, end]]) -> bool\n\nReturn True if S ends with the specified suffix, False otherwise.\nWith optional start, test S beginning at that position.\nWith optional end, stop comparing S at that position.\nsuffix can also be a tuple of strings to try."
"S.expandtabs([tabsize]) -> unicode\n\nReturn a copy of S where all tab characters are expanded using spaces.\nIf tabsize is not given, a tab size of 8 characters is assumed."
"S.find(sub [,start [,end]]) -> int\n\nReturn the lowest index in S where substring sub is found,\nsuch that sub is contained within s[start:end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure."
"S.format(*args, **kwargs) -> unicode\n\nReturn a formatted version of S, using substitutions from args and kwargs.\nThe substitutions are identified by braces (\'{\' and \'}\')."
"S.index(sub [,start [,end]]) -> int\n\nLike S.find() but raise ValueError when the substring is not found."
"S.isalnum() -> bool\n\nReturn True if all characters in S are alphanumeric\nand there is at least one character in S, False otherwise."
"S.isalpha() -> bool\n\nReturn True if all characters in S are alphabetic\nand there is at least one character in S, False otherwise."
"S.isdecimal() -> bool\n\nReturn True if there are only decimal characters in S,\nFalse otherwise."
"S.isdigit() -> bool\n\nReturn True if all characters in S are digits\nand there is at least one character in S, False otherwise."
"S.islower() -> bool\n\nReturn True if all cased characters in S are lowercase and there is\nat least one cased character in S, False otherwise."
"S.isnumeric() -> bool\n\nReturn True if there are only numeric characters in S,\nFalse otherwise."
"S.isspace() -> bool\n\nReturn True if all characters in S are whitespace\nand there is at least one character in S, False otherwise."
"S.istitle() -> bool\n\nReturn True if S is a titlecased string and there is at least one\ncharacter in S, i.e. upper- and titlecase characters may only\nfollow uncased characters and lowercase characters only cased ones.\nReturn False otherwise."
"S.isupper() -> bool\n\nReturn True if all cased characters in S are uppercase and there is\nat least one cased character in S, False otherwise."
"S.join(iterable) -> unicode\n\nReturn a string which is the concatenation of the strings in the\niterable. The separator between elements is S."
"S.ljust(width[, fillchar]) -> int\n\nReturn S left-justified in a Unicode string of length width. Padding is\ndone using the specified fill character (default is a space)."
"S.lower() -> unicode\n\nReturn a copy of the string S converted to lowercase."
"S.lstrip([chars]) -> unicode\n\nReturn a copy of the string S with leading whitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is a str, it will be converted to unicode before stripping"
"S.partition(sep) -> (head, sep, tail)\n\nSearch for the separator sep in S, and return the part before it,\nthe separator itself, and the part after it. If the separator is not\nfound, return S and two empty strings."
"S.replace(old, new[, count]) -> unicode\n\nReturn a copy of S with all occurrences of substring\nold replaced by new. If the optional argument count is\ngiven, only the first count occurrences are replaced."
"S.rfind(sub [,start [,end]]) -> int\n\nReturn the highest index in S where substring sub is found,\nsuch that sub is contained within s[start:end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure."
"S.rindex(sub [,start [,end]]) -> int\n\nLike S.rfind() but raise ValueError when the substring is not found."
"S.rjust(width[, fillchar]) -> unicode\n\nReturn S right-justified in a Unicode string of length width. Padding is\ndone using the specified fill character (default is a space)."
"S.rpartition(sep) -> (head, sep, tail)\n\nSearch for the separator sep in S, starting at the end of S, and return\nthe part before it, the separator itself, and the part after it. If the\nseparator is not found, return two empty strings and S."
"S.rsplit([sep [,maxsplit]]) -> list of strings\n\nReturn a list of the words in S, using sep as the\ndelimiter string, starting at the end of the string and\nworking to the front. If maxsplit is given, at most maxsplit\nsplits are done. If sep is not specified, any whitespace string\nis a separator."
"S.rstrip([chars]) -> unicode\n\nReturn a copy of the string S with trailing whitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is a str, it will be converted to unicode before stripping"
"S.split([sep [,maxsplit]]) -> list of strings\n\nReturn a list of the words in S, using sep as the\ndelimiter string. If maxsplit is given, at most maxsplit\nsplits are done. If sep is not specified or is None, any\nwhitespace string is a separator and empty strings are\nremoved from the result."
"S.splitlines([keepends]) -> list of strings\n\nReturn a list of the lines in S, breaking at line boundaries.\nLine breaks are not included in the resulting list unless keepends\nis given and true."
"S.startswith(prefix[, start[, end]]) -> bool\n\nReturn True if S starts with the specified prefix, False otherwise.\nWith optional start, test S beginning at that position.\nWith optional end, stop comparing S at that position.\nprefix can also be a tuple of strings to try."
"S.strip([chars]) -> unicode\n\nReturn a copy of the string S with leading and trailing\nwhitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is a str, it will be converted to unicode before stripping"
"S.swapcase() -> unicode\n\nReturn a copy of S with uppercase characters converted to lowercase\nand vice versa."
"S.title() -> unicode\n\nReturn a titlecased version of S, i.e. words start with title case\ncharacters, all remaining cased characters have lower case."
"S.translate(table) -> unicode\n\nReturn a copy of the string S, where all characters have been mapped\nthrough the given translation table, which must be a mapping of\nUnicode ordinals to Unicode ordinals, Unicode strings or None.\nUnmapped characters are left untouched. Characters mapped to None\nare deleted."
"S.upper() -> unicode\n\nReturn a copy of S converted to uppercase."
"S.zfill(width) -> unicode\n\nPad a numeric string S with zeros on the left, to fill a field\nof the specified width. The string S is never truncated."
"type(object) -> the object\'s type\ntype(name, bases, dict) -> a new type"
"x.__delattr__(\'name\') <==> del x.name"
"default object formatter"
"x.__getattribute__(\'name\') <==> x.name"
"x.__getitem__(y) <==> x[y]"
"x.__hash__() <==> hash(x)"
"x.__init__(...) initializes x; see help(type(x)) for signature"
"x.__iter__() <==> iter(x)"
"x.__len__() <==> len(x)"
"T.__new__(S, ...) -> a new object with type S, a subtype of T"
""
"helper for pickle"
"x.__repr__() <==> repr(x)"
"Returns a reverse iterator."
"x.__setattr__(\'name\', value) <==> x.name = value"
"__sizeof__() -> int\nsize of object in memory, in bytes"
"x.__str__() <==> str(x)"
"Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n"
"xrange([start,] stop[, step]) -> xrange object\n\nLike range(), but instead of returning a list, returns an object that\ngenerates the numbers in the range on demand. For looping, this is \nslightly faster than range() and more memory efficient."