Python 集合set()添加删除交集并集集合操作详解

Posted 2020-09-30

Python 集合set()添加删除、交集、并集、集合操作详解

在Python set是基本数据类型的一种集合类型，它有可变集合(set())和不可变集合(frozenset)两种。创建集合set、集合set添加、集合删除、交集、并集、差集的操作都是非常实用的方法。
python之家提示: 推荐在Linux系统下编写python程序，会养成一个非常好的编码习惯。

创建集合set

   1 # encoding: utf-8
   2 # module builtins
   3 # from (built-in)
   4 # by generator 1.145
   5 """
   6 Built-in functions, exceptions, and other objects.
   7 
   8 Noteworthy: None is the `nil‘ object; Ellipsis represents `...‘ in slices.
   9 """
  10 # no imports
  11 
  12 # Variables with simple values
  13 # definition of False omitted
  14 # definition of None omitted
  15 # definition of True omitted
  16 # definition of __debug__ omitted
  17 
  18 # functions
  19 
  20 def abs(*args, **kwargs): # real signature unknown
  21     """ Return the absolute value of the argument. """
  22     pass
  23 
  24 def all(*args, **kwargs): # real signature unknown
  25     """
  26     Return True if bool(x) is True for all values x in the iterable.
  27     
  28     If the iterable is empty, return True.
  29     """
  30     pass
  31 
  32 def any(*args, **kwargs): # real signature unknown
  33     """
  34     Return True if bool(x) is True for any x in the iterable.
  35     
  36     If the iterable is empty, return False.
  37     """
  38     pass
  39 
  40 def ascii(*args, **kwargs): # real signature unknown
  41     """
  42     Return an ASCII-only representation of an object.
  43     
  44     As repr(), return a string containing a printable representation of an
  45     object, but escape the non-ASCII characters in the string returned by
  46     repr() using \\\\x, \\\\u or \\\\U escapes. This generates a string similar
  47     to that returned by repr() in Python 2.
  48     """
  49     pass
  50 
  51 def bin(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
  52     """
  53     Return the binary representation of an integer.
  54     
  55        >>> bin(2796202)
  56        ‘0b1010101010101010101010‘
  57     """
  58     pass
  59 
  60 def callable(i_e_, some_kind_of_function): # real signature unknown; restored from __doc__
  61     """
  62     Return whether the object is callable (i.e., some kind of function).
  63     
  64     Note that classes are callable, as are instances of classes with a
  65     __call__() method.
  66     """
  67     pass
  68 
  69 def chr(*args, **kwargs): # real signature unknown
  70     """ Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff. """
  71     pass
  72 
  73 def compile(*args, **kwargs): # real signature unknown
  74     """
  75     Compile source into a code object that can be executed by exec() or eval().
  76     
  77     The source code may represent a Python module, statement or expression.
  78     The filename will be used for run-time error messages.
  79     The mode must be ‘exec‘ to compile a module, ‘single‘ to compile a
  80     single (interactive) statement, or ‘eval‘ to compile an expression.
  81     The flags argument, if present, controls which future statements influence
  82     the compilation of the code.
  83     The dont_inherit argument, if true, stops the compilation inheriting
  84     the effects of any future statements in effect in the code calling
  85     compile; if absent or false these statements do influence the compilation,
  86     in addition to any features explicitly specified.
  87     """
  88     pass
  89 
  90 def copyright(*args, **kwargs): # real signature unknown
  91     """
  92     interactive prompt objects for printing the license text, a list of
  93         contributors and the copyright notice.
  94     """
  95     pass
  96 
  97 def credits(*args, **kwargs): # real signature unknown
  98     """
  99     interactive prompt objects for printing the license text, a list of
 100         contributors and the copyright notice.
 101     """
 102     pass
 103 
 104 def delattr(x, y): # real signature unknown; restored from __doc__
 105     """
 106     Deletes the named attribute from the given object.
 107     
 108     delattr(x, ‘y‘) is equivalent to ``del x.y‘‘
 109     """
 110     pass
 111 
 112 def dir(p_object=None): # real signature unknown; restored from __doc__
 113     """
 114     dir([object]) -> list of strings
 115     
 116     If called without an argument, return the names in the current scope.
 117     Else, return an alphabetized list of names comprising (some of) the attributes
 118     of the given object, and of attributes reachable from it.
 119     If the object supplies a method named __dir__, it will be used; otherwise
 120     the default dir() logic is used and returns:
 121       for a module object: the module‘s attributes.
 122       for a class object:  its attributes, and recursively the attributes
 123         of its bases.
 124       for any other object: its attributes, its class‘s attributes, and
 125         recursively the attributes of its class‘s base classes.
 126     """
 127     return []
 128 
 129 def divmod(x, y): # known case of builtins.divmod
 130     """ Return the tuple (x//y, x%y).  Invariant: div*y + mod == x. """
 131     return (0, 0)
 132 
 133 def eval(*args, **kwargs): # real signature unknown
 134     """
 135     Evaluate the given source in the context of globals and locals.
 136     
 137     The source may be a string representing a Python expression
 138     or a code object as returned by compile().
 139     The globals must be a dictionary and locals can be any mapping,
 140     defaulting to the current globals and locals.
 141     If only globals is given, locals defaults to it.
 142     """
 143     pass
 144 
 145 def exec(*args, **kwargs): # real signature unknown
 146     """
 147     Execute the given source in the context of globals and locals.
 148     
 149     The source may be a string representing one or more Python statements
 150     or a code object as returned by compile().
 151     The globals must be a dictionary and locals can be any mapping,
 152     defaulting to the current globals and locals.
 153     If only globals is given, locals defaults to it.
 154     """
 155     pass
 156 
 157 def exit(*args, **kwargs): # real signature unknown
 158     pass
 159 
 160 def format(*args, **kwargs): # real signature unknown
 161     """
 162     Return value.__format__(format_spec)
 163     
 164     format_spec defaults to the empty string
 165     """
 166     pass
 167 
 168 def getattr(object, name, default=None): # known special case of getattr
 169     """
 170     getattr(object, name[, default]) -> value
 171     
 172     Get a named attribute from an object; getattr(x, ‘y‘) is equivalent to x.y.
 173     When a default argument is given, it is returned when the attribute doesn‘t
 174     exist; without it, an exception is raised in that case.
 175     """
 176     pass
 177 
 178 def globals(*args, **kwargs): # real signature unknown
 179     """
 180     Return the dictionary containing the current scope‘s global variables.
 181     
 182     NOTE: Updates to this dictionary *will* affect name lookups in the current
 183     global scope and vice-versa.
 184     """
 185     pass
 186 
 187 def hasattr(*args, **kwargs): # real signature unknown
 188     """
 189     Return whether the object has an attribute with the given name.
 190     
 191     This is done by calling getattr(obj, name) and catching AttributeError.
 192     """
 193     pass
 194 
 195 def hash(*args, **kwargs): # real signature unknown
 196     """
 197     Return the hash value for the given object.
 198     
 199     Two objects that compare equal must also have the same hash value, but the
 200     reverse is not necessarily true.
 201     """
 202     pass
 203 
 204 def help(): # real signature unknown; restored from __doc__
 205     """
 206     Define the builtin ‘help‘.
 207     
 208         This is a wrapper around pydoc.help that provides a helpful message
 209         when ‘help‘ is typed at the Python interactive prompt.
 210     
 211         Calling help() at the Python prompt starts an interactive help session.
 212         Calling help(thing) prints help for the python object ‘thing‘.
 213     """
 214     pass
 215 
 216 def hex(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
 217     """
 218     Return the hexadecimal representation of an integer.
 219     
 220        >>> hex(12648430)
 221        ‘0xc0ffee‘
 222     """
 223     pass
 224 
 225 def id(*args, **kwargs): # real signature unknown
 226     """
 227     Return the identity of an object.
 228     
 229     This is guaranteed to be unique among simultaneously existing objects.
 230     (CPython uses the object‘s memory address.)
 231     """
 232     pass
 233 
 234 def input(*args, **kwargs): # real signature unknown
 235     """
 236     Read a string from standard input.  The trailing newline is stripped.
 237     
 238     The prompt string, if given, is printed to standard output without a
 239     trailing newline before reading input.
 240     
 241     If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
 242     On *nix systems, readline is used if available.
 243     """
 244     pass
 245 
 246 def isinstance(x, A_tuple): # real signature unknown; restored from __doc__
 247     """
 248     Return whether an object is an instance of a class or of a subclass thereof.
 249     
 250     A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
 251     check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
 252     or ...`` etc.
 253     """
 254     pass
 255 
 256 def issubclass(x, A_tuple): # real signature unknown; restored from __doc__
 257     """
 258     Return whether ‘cls‘ is a derived from another class or is the same class.
 259     
 260     A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to
 261     check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)
 262     or ...`` etc.
 263     """
 264     pass
 265 
 266 def iter(source, sentinel=None): # known special case of iter
 267     """
 268     iter(iterable) -> iterator
 269     iter(callable, sentinel) -> iterator
 270     
 271     Get an iterator from an object.  In the first form, the argument must
 272     supply its own iterator, or be a sequence.
 273     In the second form, the callable is called until it returns the sentinel.
 274     """
 275     pass
 276 
 277 def len(*args, **kwargs): # real signature unknown
 278     """ Return the number of items in a container. """
 279     pass
 280 
 281 def license(*args, **kwargs): # real signature unknown
 282     """
 283     interactive prompt objects for printing the license text, a list of
 284         contributors and the copyright notice.
 285     """
 286     pass
 287 
 288 def locals(*args, **kwargs): # real signature unknown
 289     """
 290     Return a dictionary containing the current scope‘s local variables.
 291     
 292     NOTE: Whether or not updates to this dictionary will affect name lookups in
 293     the local scope and vice-versa is *implementation dependent* and not
 294     covered by any backwards compatibility guarantees.
 295     """
 296     pass
 297 
 298 def max(*args, key=None): # known special case of max
 299     """
 300     max(iterable, *[, default=obj, key=func]) -> value
 301     max(arg1, arg2, *args, *[, key=func]) -> value
 302     
 303     With a single iterable argument, return its biggest item. The
 304     default keyword-only argument specifies an object to return if
 305     the provided iterable is empty.
 306     With two or more arguments, return the largest argument.
 307     """
 308     pass
 309 
 310 def min(*args, key=None): # known special case of min
 311     """
 312     min(iterable, *[, default=obj, key=func]) -> value
 313     min(arg1, arg2, *args, *[, key=func]) -> value
 314     
 315     With a single iterable argument, return its smallest item. The
 316     default keyword-only argument specifies an object to return if
 317     the provided iterable is empty.
 318     With two or more arguments, return the smallest argument.
 319     """
 320     pass
 321 
 322 def next(iterator, default=None): # real signature unknown; restored from __doc__
 323     """
 324     next(iterator[, default])
 325     
 326     Return the next item from the iterator. If default is given and the iterator
 327     is exhausted, it is returned instead of raising StopIteration.
 328     """
 329     pass
 330 
 331 def oct(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
 332     """
 333     Return the octal representation of an integer.
 334     
 335        >>> oct(342391)
 336        ‘0o1234567‘
 337     """
 338     pass
 339 
 340 def open(file, mode=‘r‘, buffering=None, encoding=None, errors=None, newline=None, closefd=True): # known special case of open
 341     """
 342     Open file and return a stream.  Raise IOError upon failure.
 343     
 344     file is either a text or byte string giving the name (and the path
 345     if the file isn‘t in the current working directory) of the file to
 346     be opened or an integer file descriptor of the file to be
 347     wrapped. (If a file descriptor is given, it is closed when the
 348     returned I/O object is closed, unless closefd is set to False.)
 349     
 350     mode is an optional string that specifies the mode in which the file
 351     is opened. It defaults to ‘r‘ which means open for reading in text
 352     mode.  Other common values are ‘w‘ for writing (truncating the file if
 353     it already exists), ‘x‘ for creating and writing to a new file, and
 354     ‘a‘ for appending (which on some Unix systems, means that all writes
 355     append to the end of the file regardless of the current seek position).
 356     In text mode, if encoding is not specified the encoding used is platform
 357     dependent: locale.getpreferredencoding(False) is called to get the
 358     current locale encoding. (For reading and writing raw bytes use binary
 359     mode and leave encoding unspecified.) The available modes are:
 360     
 361     ========= ===============================================================
 362     Character Meaning
 363     --------- ---------------------------------------------------------------
 364     ‘r‘       open for reading (default)
 365     ‘w‘       open for writing, truncating the file first
 366     ‘x‘       create a new file and open it for writing
 367     ‘a‘       open for writing, appending to the end of the file if it exists
 368     ‘b‘       binary mode
 369     ‘t‘       text mode (default)
 370     ‘+‘       open a disk file for updating (reading and writing)
 371     ‘U‘       universal newline mode (deprecated)
 372     ========= ===============================================================
 373     
 374     The default mode is ‘rt‘ (open for reading text). For binary random
 375     access, the mode ‘w+b‘ opens and truncates the file to 0 bytes, while
 376     ‘r+b‘ opens the file without truncation. The ‘x‘ mode implies ‘w‘ and
 377     raises an `FileExistsError` if the file already exists.
 378     
 379     Python distinguishes between files opened in binary and text modes,
 380     even when the underlying operating system doesn‘t. Files opened in
 381     binary mode (appending ‘b‘ to the mode argument) return contents as
 382     bytes objects without any decoding. In text mode (the default, or when
 383     ‘t‘ is appended to the mode argument), the contents of the file are
 384     returned as strings, the bytes having been first decoded using a
 385     platform-dependent encoding or using the specified encoding if given.
 386     
 387     ‘U‘ mode is deprecated and will raise an exception in future versions
 388     of Python.  It has no effect in Python 3.  Use newline to control
 389     universal newlines mode.
 390     
 391     buffering is an optional integer used to set the buffering policy.
 392     Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
 393     line buffering (only usable in text mode), and an integer > 1 to indicate
 394     the size of a fixed-size chunk buffer.  When no buffering argument is
 395     given, the default buffering policy works as follows:
 396     
 397     * Binary files are buffered in fixed-size chunks; the size of the buffer
 398       is chosen using a heuristic trying to determine the underlying device‘s
 399       "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
 400       On many systems, the buffer will typically be 4096 or 8192 bytes long.
 401     
 402     * "Interactive" text files (files for which isatty() returns True)
 403       use line buffering.  Other text files use the policy described above
 404       for binary files.
 405     
 406     encoding is the name of the encoding used to decode or encode the
 407     file. This should only be used in text mode. The default encoding is
 408     platform dependent, but any encoding supported by Python can be
 409     passed.  See the codecs module for the list of supported encodings.
 410     
 411     errors is an optional string that specifies how encoding errors are to
 412     be handled---this argument should not be used in binary mode. Pass
 413     ‘strict‘ to raise a ValueError exception if there is an encoding error
 414     (the default of None has the same effect), or pass ‘ignore‘ to ignore
 415     errors. (Note that ignoring encoding errors can lead to data loss.)
 416     See the documentation for codecs.register or run ‘help(codecs.Codec)‘
 417     for a list of the permitted encoding error strings.
 418     
 419     newline controls how universal newlines works (it only applies to text
 420     mode). It can be None, ‘‘, ‘\\n‘, ‘\\r‘, and ‘\\r\\n‘.  It works as
 421     follows:
 422     
 423     * On input, if newline is None, universal newlines mode is
 424       enabled. Lines in the input can end in ‘\\n‘, ‘\\r‘, or ‘\\r\\n‘, and
 425       these are translated into ‘\\n‘ before being returned to the
 426       caller. If it is ‘‘, universal newline mode is enabled, but line
 427       endings are returned to the caller untranslated. If it has any of
 428       the other legal values, input lines are only terminated by the given
 429       string, and the line ending is returned to the caller untranslated.
 430     
 431     * On output, if newline is None, any ‘\\n‘ characters written are
 432       translated to the system default line separator, os.linesep. If
 433       newline is ‘‘ or ‘\\n‘, no translation takes place. If newline is any
 434       of the other legal values, any ‘\\n‘ characters written are translated
 435       to the given string.
 436     
 437     If closefd is False, the underlying file descriptor will be kept open
 438     when the file is closed. This does not work when a file name is given
 439     and must be True in that case.
 440     
 441     A custom opener can be used by passing a callable as *opener*. The
 442     underlying file descriptor for the file object is then obtained by
 443     calling *opener* with (*file*, *flags*). *opener* must return an open
 444     file descriptor (passing os.open as *opener* results in functionality
 445     similar to passing None).
 446     
 447     open() returns a file object whose type depends on the mode, and
 448     through which the standard file operations such as reading and writing
 449     are performed. When open() is used to open a file in a text mode (‘w‘,
 450     ‘r‘, ‘wt‘, ‘rt‘, etc.), it returns a TextIOWrapper. When used to open
 451     a file in a binary mode, the returned class varies: in read binary
 452     mode, it returns a BufferedReader; in write binary and append binary
 453     modes, it returns a BufferedWriter, and in read/write mode, it returns
 454     a BufferedRandom.
 455     
 456     It is also possible to use a string or bytearray as a file for both
 457     reading and writing. For strings StringIO can be used like a file
 458     opened in a text mode, and for bytes a BytesIO can be used like a file
 459     opened in a binary mode.
 460     """
 461     pass
 462 
 463 def ord(*args, **kwargs): # real signature unknown
 464     """ Return the Unicode code point for a one-character string. """
 465     pass
 466 
 467 def pow(*args, **kwargs): # real signature unknown
 468     """
 469     Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
 470     
 471     Some types, such as ints, are able to use a more efficient algorithm when
 472     invoked using the three argument form.
 473     """
 474     pass
 475 
 476 def print(self, *args, sep=‘ ‘, end=‘\\n‘, file=None): # known special case of print
 477     """
 478     print(value, ..., sep=‘ ‘, end=‘\\n‘, file=sys.stdout, flush=False)
 479     
 480     Prints the values to a stream, or to sys.stdout by default.
 481     Optional keyword arguments:
 482     file:  a file-like object (stream); defaults to the current sys.stdout.
 483     sep:   string inserted between values, default a space.
 484     end:   string appended after the last value, default a newline.
 485     flush: whether to forcibly flush the stream.
 486     """
 487     pass
 488 
 489 def quit(*args, **kwargs): # real signature unknown
 490     pass
 491 
 492 def repr(obj): # real signature unknown; restored from __doc__
 493     """
 494     Return the canonical string representation of the object.
 495     
 496     For many object types, including most builtins, eval(repr(obj)) == obj.
 497     """
 498     pass
 499 
 500 def round(number, ndigits=None): # real signature unknown; restored from __doc__
 501     """
 502     round(number[, ndigits]) -> number
 503     
 504     Round a number to a given precision in decimal digits (default 0 digits).
 505     This returns an int when called with one argument, otherwise the
 506     same type as the number. ndigits may be negative.
 507     """
 508     return 0
 509 
 510 def setattr(x, y, v): # real signature unknown; restored from __doc__
 511     """
 512     Sets the named attribute on the given object to the specified value.
 513     
 514     setattr(x, ‘y‘, v) is equivalent to ``x.y = v‘‘
 515     """
 516     pass
 517 
 518 def sorted(*args, **kwargs): # real signature unknown
 519     """
 520     Return a new list containing all items from the iterable in ascending order.
 521     
 522     A custom key function can be supplied to customize the sort order, and the
 523     reverse flag can be set to request the result in descending order.
 524     """
 525     pass
 526 
 527 def sum(*args, **kwargs): # real signature unknown
 528     """
 529     Return the sum of a ‘start‘ value (default: 0) plus an iterable of numbers
 530     
 531     When the iterable is empty, return the start value.
 532     This function is intended specifically for use with numeric values and may
 533     reject non-numeric types.
 534     """
 535     pass
 536 
 537 def vars(p_object=None): # real signature unknown; restored from __doc__
 538     """
 539     vars([object]) -> dictionary
 540     
 541     Without arguments, equivalent to locals().
 542     With an argument, equivalent to object.__dict__.
 543     """
 544     return {}
 545 
 546 def __build_class__(func, name, *bases, metaclass=None, **kwds): # real signature unknown; restored from __doc__
 547     """
 548     __build_class__(func, name, *bases, metaclass=None, **kwds) -> class
 549     
 550     Internal helper function used by the class statement.
 551     """
 552     pass
 553 
 554 def __import__(name, globals=None, locals=None, fromlist=(), level=0): # real signature unknown; restored from __doc__
 555     """
 556     __import__(name, globals=None, locals=None, fromlist=(), level=0) -> module
 557     
 558     Import a module. Because this function is meant for use by the Python
 559     interpreter and not for general use it is better to use
 560     importlib.import_module() to programmatically import a module.
 561     
 562     The globals argument is only used to determine the context;
 563     they are not modified.  The locals argument is unused.  The fromlist
 564     should be a list of names to emulate ``from name import ...‘‘, or an
 565     empty list to emulate ``import name‘‘.
 566     When importing a module from a package, note that __import__(‘A.B‘, ...)
 567     returns package A when fromlist is empty, but its submodule B when
 568     fromlist is not empty.  Level is used to determine whether to perform 
 569     absolute or relative imports. 0 is absolute while a positive number
 570     is the number of parent directories to search relative to the current module.
 571     """
 572     pass
 573 
 574 # classes
 575 
 576 
 577 class __generator(object):
 578     ‘‘‘A mock class representing the generator function type.‘‘‘
 579     def __init__(self):
 580         self.gi_code = None
 581         self.gi_frame = None
 582         self.gi_running = 0
 583 
 584     def __iter__(self):
 585         ‘‘‘Defined to support iteration over container.‘‘‘
 586         pass
 587 
 588     def __next__(self):
 589         ‘‘‘Return the next item from the container.‘‘‘
 590         pass
 591 
 592     def close(self):
 593         ‘‘‘Raises new GeneratorExit exception inside the generator to terminate the iteration.‘‘‘
 594         pass
 595 
 596     def send(self, value):
 597         ‘‘‘Resumes the generator and "sends" a value that becomes the result of the current yield-expression.‘‘‘
 598         pass
 599 
 600     def throw(self, type, value=None, traceback=None):
 601         ‘‘‘Used to raise an exception inside the generator.‘‘‘
 602         pass
 603 
 604 
 605 class __asyncgenerator(object):
 606     ‘‘‘A mock class representing the async generator function type.‘‘‘
 607     def __init__(self):
 608         ‘‘‘Create an async generator object.‘‘‘
 609         self.__name__ = ‘‘
 610         self.__qualname__ = ‘‘
 611         self.ag_await = None
 612         self.ag_frame = None
 613         self.ag_running = False
 614         self.ag_code = None
 615 
 616     def __aiter__(self):
 617         ‘‘‘Defined to support iteration over container.‘‘‘
 618         pass
 619 
 620     def __anext__(self):
 621         ‘‘‘Returns an awaitable, that performs one asynchronous generator iteration when awaited.‘‘‘
 622         pass
 623 
 624     def aclose(self):
 625         ‘‘‘Returns an awaitable, that throws a GeneratorExit exception into generator.‘‘‘
 626         pass
 627 
 628     def asend(self, value):
 629         ‘‘‘Returns an awaitable, that pushes the value object in generator.‘‘‘
 630         pass
 631 
 632     def athrow(self, type, value=None, traceback=None):
 633         ‘‘‘Returns an awaitable, that throws an exception into generator.‘‘‘
 634         pass
 635 
 636 
 637 class __function(object):
 638     ‘‘‘A mock class representing function type.‘‘‘
 639 
 640     def __init__(self):
 641         self.__name__ = ‘‘
 642         self.__doc__ = ‘‘
 643         self.__dict__ = ‘‘
 644         self.__module__ = ‘‘
 645 
 646         self.__defaults__ = {}
 647         self.__globals__ = {}
 648         self.__closure__ = None
 649         self.__code__ = None
 650         self.__name__ = ‘‘
 651 
 652         self.__annotations__ = {}
 653         self.__kwdefaults__ = {}
 654 
 655         self.__qualname__ = ‘‘
 656 
 657 
 658 class __method(object):
 659     ‘‘‘A mock class representing method type.‘‘‘
 660 
 661     def __init__(self):
 662 
 663         self.__func__ = None
 664         self.__self__ = None
 665 
 666 
 667 class __coroutine(object):
 668     ‘‘‘A mock class representing coroutine type.‘‘‘
 669 
 670     def __init__(self):
 671         self.__name__ = ‘‘
 672         self.__qualname__ = ‘‘
 673         self.cr_await = None
 674         self.cr_frame = None
 675         self.cr_running = False
 676         self.cr_code = None
 677 
 678     def __await__(self):
 679         return []
 680 
 681     def close(self):
 682         pass
 683 
 684     def send(self, value):
 685         pass
 686 
 687     def throw(self, type, value=None, traceback=None):
 688         pass
 689 
 690 
 691 class __namedtuple(tuple):
 692     ‘‘‘A mock base class for named tuples.‘‘‘
 693 
 694     __slots__ = ()
 695     _fields = ()
 696 
 697     def __new__(cls, *args, **kwargs):
 698         ‘Create a new instance of the named tuple.‘
 699         return tuple.__new__(cls, *args)
 700 
 701     @classmethod
 702     def _make(cls, iterable, new=tuple.__new__, len=len):
 703         ‘Make a new named tuple object from a sequence or iterable.‘
 704         return new(cls, iterable)
 705 
 706     def __repr__(self):
 707         return ‘‘
 708 
 709     def _asdict(self):
 710         ‘Return a new dict which maps field types to their values.‘
 711         return {}
 712 
 713     def _replace(self, **kwargs):
 714         ‘Return a new named tuple object replacing specified fields with new values.‘
 715         return self
 716 
 717     def __getnewargs__(self):
 718         return tuple(self)
 719 
 720 class object:
 721     """ The most base type """
 722     def __delattr__(self, *args, **kwargs): # real signature unknown
 723         """ Implement delattr(self, name). """
 724         pass
 725 
 726     def __dir__(self): # real signature unknown; restored from __doc__
 727         """
 728         __dir__() -> list
 729         default dir() implementation
 730         """
 731         return []
 732 
 733     def __eq__(self, *args, **kwargs): # real signature unknown
 734         """ Return self==value. """
 735         pass
 736 
 737     def __format__(self, *args, **kwargs): # real signature unknown
 738         """ default object formatter """
 739         pass
 740 
 741     def __getattribute__(self, *args, **kwargs): # real signature unknown
 742         """ Return getattr(self, name). """
 743         pass
 744 
 745     def __ge__(self, *args, **kwargs): # real signature unknown
 746         """ Return self>=value. """
 747         pass
 748 
 749     def __gt__(self, *args, **kwargs): # real signature unknown
 750         """ Return self>value. """
 751         pass
 752 
 753     def __hash__(self, *args, **kwargs): # real signature unknown
 754         """ Return hash(self). """
 755         pass
 756 
 757     def __init_subclass__(self, *args, **kwargs): # real signature unknown
 758         """
 759         This method is called when a class is subclassed.
 760         
 761         The default implementation does nothing. It may be
 762         overridden to extend subclasses.
 763         """
 764         pass
 765 
 766     def __init__(self): # known special case of object.__init__
 767         """ Initialize self.  See help(type(self)) for accurate signature. """
 768         pass
 769 
 770     def __le__(self, *args, **kwargs): # real signature unknown
 771         """ Return self<=value. """
 772         pass
 773 
 774     def __lt__(self, *args, **kwargs): # real signature unknown
 775         """ Return self<value. """
 776         pass
 777 
 778     @staticmethod # known case of __new__
 779     def __new__(cls, *more): # known special case of object.__new__
 780         """ Create and return a new object.  See help(type) for accurate signature. """
 781         pass
 782 
 783     def __ne__(self, *args, **kwargs): # real signature unknown
 784         """ Return self!=value. """
 785         pass
 786 
 787     def __reduce_ex__(self, *args, **kwargs): # real signature unknown
 788         """ helper for pickle """
 789         pass
 790 
 791     def __reduce__(self, *args, **kwargs): # real signature unknown
 792         """ helper for pickle """
 793         pass
 794 
 795     def __repr__(self, *args, **kwargs): # real signature unknown
 796         """ Return repr(self). """
 797         pass
 798 
 799     def __setattr__(self, *args, **kwargs): # real signature unknown
 800         """ Implement setattr(self, name, value). """
 801         pass
 802 
 803     def __sizeof__(self): # real signature unknown; restored from __doc__
 804         """
 805         __sizeof__() -> int
 806         size of object in memory, in bytes
 807         """
 808         return 0
 809 
 810     def __str__(self, *args, **kwargs): # real signature unknown
 811         """ Return str(self). """
 812         pass
 813 
 814     @classmethod # known case
 815     def __subclasshook__(cls, subclass): # known special case of object.__subclasshook__
 816         """
 817         Abstract classes can override this to customize issubclass().
 818         
 819         This is invoked early on by abc.ABCMeta.__subclasscheck__().
 820         It should return True, False or NotImplemented.  If it returns
 821         NotImplemented, the normal algorithm is used.  Otherwise, it
 822         overrides the normal algorithm (and the outcome is cached).
 823         """
 824         pass
 825 
 826     __class__ = None # (!) forward: type, real value is ‘‘
 827     __dict__ = {}
 828     __doc__ = ‘‘
 829     __module__ = ‘‘
 830 
 831 
 832 class BaseException(object):
 833     """ Common base class for all exceptions """
 834     def with_traceback(self, tb): # real signature unknown; restored from __doc__
 835         """
 836         Exception.with_traceback(tb) --
 837             set self.__traceback__ to tb and return self.
 838         """
 839         pass
 840 
 841     def __delattr__(self, *args, **kwargs): # real signature unknown
 842         """ Implement delattr(self, name). """
 843         pass
 844 
 845     def __getattribute__(self, *args, **kwargs): # real signature unknown
 846         """ Return getattr(self, name). """
 847         pass
 848 
 849     def __init__(self, *args, **kwargs): # real signature unknown
 850         pass
 851 
 852     @staticmethod # known case of __new__
 853     def __new__(*args, **kwargs): # real signature unknown
 854         """ Create and return a new object.  See help(type) for accurate signature. """
 855         pass
 856 
 857     def __reduce__(self, *args, **kwargs): # real signature unknown
 858         pass
 859 
 860     def __repr__(self, *args, **kwargs): # real signature unknown
 861         """ Return repr(self). """
 862         pass
 863 
 864     def __setattr__(self, *args, **kwargs): # real signature unknown
 865         """ Implement setattr(self, name, value). """
 866         pass
 867 
 868     def __setstate__(self, *args, **kwargs): # real signature unknown
 869         pass
 870 
 871     def __str__(self, *args, **kwargs): # real signature unknown
 872         """ Return str(self). """
 873         pass
 874 
 875     args = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 876 
 877     __cause__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 878     """exception cause"""
 879 
 880     __context__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 881     """exception context"""
 882 
 883     __suppress_context__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 884 
 885     __traceback__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 886 
 887 
 888     __dict__ = None # (!) real value is ‘‘
 889 
 890 
 891 class Exception(BaseException):
 892     """ Common base class for all non-exit exceptions. """
 893     def __init__(self, *args, **kwargs): # real signature unknown
 894         pass
 895 
 896     @staticmethod # known case of __new__
 897     def __new__(*args, **kwargs): # real signature unknown
 898         """ Create and return a new object.  See help(type) for accurate signature. """
 899         pass
 900 
 901 
 902 class ArithmeticError(Exception):
 903     """ Base class for arithmetic errors. """
 904     def __init__(self, *args, **kwargs): # real signature unknown
 905         pass
 906 
 907     @staticmethod # known case of __new__
 908     def __new__(*args, **kwargs): # real signature unknown
 909         """ Create and return a new object.  See help(type) for accurate signature. """
 910         pass
 911 
 912 
 913 class AssertionError(Exception):
 914     """ Assertion failed. """
 915     def __init__(self, *args, **kwargs): # real signature unknown
 916         pass
 917 
 918     @staticmethod # known case of __new__
 919     def __new__(*args, **kwargs): # real signature unknown
 920         """ Create and return a new object.  See help(type) for accurate signature. """
 921         pass
 922 
 923 
 924 class AttributeError(Exception):
 925     """ Attribute not found. """
 926     def __init__(self, *args, **kwargs): # real signature unknown
 927         pass
 928 
 929     @staticmethod # known case of __new__
 930     def __new__(*args, **kwargs): # real signature unknown
 931         """ Create and return a new object.  See help(type) for accurate signature. """
 932         pass
 933 
 934 
 935 class WindowsError(Exception):
 936     """ Base class for I/O related errors. """
 937     def __init__(self, *args, **kwargs): # real signature unknown
 938         pass
 939 
 940     @staticmethod # known case of __new__
 941     def __new__(*args, **kwargs): # real signature unknown
 942         """ Create and return a new object.  See help(type) for accurate signature. """
 943         pass
 944 
 945     def __reduce__(self, *args, **kwargs): # real signature unknown
 946         pass
 947 
 948     def __str__(self, *args, **kwargs): # real signature unknown
 949         """ Return str(self). """
 950         pass
 951 
 952     characters_written = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 953 
 954     errno = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 955     """POSIX exception code"""
 956 
 957     filename = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 958     """exception filename"""
 959 
 960     filename2 = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 961     """second exception filename"""
 962 
 963     strerror = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 964     """exception strerror"""
 965 
 966     winerror = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
 967     """Win32 exception code"""
 968 
 969 
 970 
 971 OSError = WindowsError
 972 
 973 
 974 IOError = WindowsError
 975 
 976 
 977 EnvironmentError = WindowsError
 978 
 979 
 980 class BlockingIOError(OSError):
 981     """ I/O operation would block. """
 982     def __init__(self, *args, **kwargs): # real signature unknown
 983         pass
 984 
 985 
 986 class int(object):
 987     """
 988     int(x=0) -> integer
 989     int(x, base=10) -> integer
 990     
 991     Convert a number or string to an integer, or return 0 if no arguments
 992     are given.  If x is a number, return x.__int__().  For floating point
 993     numbers, this truncates towards zero.
 994     
 995     If x is not a number or if base is given, then x must be a string,
 996     bytes, or bytearray instance representing an integer literal in the
 997     given base.  The literal can be preceded by ‘+‘ or ‘-‘ and be surrounded
 998     by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 999     Base 0 means to interpret the base from the string as an integer literal.
1000     >>> int(‘0b100‘, base=0)
1001     4
1002     """
1003     def bit_length(self): # real signature unknown; restored from __doc__
1004         """
1005         int.bit_length() -> int
1006         
1007         Number of bits necessary to represent self in binary.
1008         >>> bin(37)
1009         ‘0b100101‘
1010         >>> (37).bit_length()
1011         6
1012         """
1013         return 0
1014 
1015     def conjugate(self, *args, **kwargs): # real signature unknown
1016         """ Returns self, the complex conjugate of any int. """
1017         pass
1018 
1019     @classmethod # known case
1020     def from_bytes(cls, bytes, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
1021         """
1022         int.from_bytes(bytes, byteorder, *, signed=False) -> int
1023         
1024         Return the integer represented by the given array of bytes.
1025         
1026         The bytes argument must be a bytes-like object (e.g. bytes or bytearray).
1027         
1028         The byteorder argument determines the byte order used to represent the
1029         integer.  If byteorder is ‘big‘, the most significant byte is at the
1030         beginning of the byte array.  If byteorder is ‘little‘, the most
1031         significant byte is at the end of the byte array.  To request the native
1032         byte order of the host system, use `sys.byteorder‘ as the byte order value.
1033         
1034         The signed keyword-only argument indicates whether two‘s complement is
1035         used to represent the integer.
1036         """
1037         pass
1038 
1039     def to_bytes(self, length, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
1040         """
1041         int.to_bytes(length, byteorder, *, signed=False) -> bytes
1042         
1043         Return an array of bytes representing an integer.
1044         
1045         The integer is represented using length bytes.  An OverflowError is
1046         raised if the integer is not representable with the given number of
1047         bytes.
1048         
1049         The byteorder argument determines the byte order used to represent the
1050         integer.  If byteorder is ‘big‘, the most significant byte is at the
1051         beginning of the byte array.  If byteorder is ‘little‘, the most
1052         significant byte is at the end of the byte array.  To request the native
1053         byte order of the host system, use `sys.byteorder‘ as the byte order value.
1054         
1055         The signed keyword-only argument determines whether two‘s complement is
1056         used to represent the integer.  If signed is False and a negative integer
1057         is given, an OverflowError is raised.
1058         """
1059         pass
1060 
1061     def __abs__(self, *args, **kwargs): # real signature unknown
1062         """ abs(self) """
1063         pass
1064 
1065     def __add__(self, *args, **kwargs): # real signature unknown
1066         """ Return self+value. """
1067         pass
1068 
1069     def __and__(self, *args, **kwargs): # real signature unknown
1070         """ Return self&value. """
1071         pass
1072 
1073     def __bool__(self, *args, **kwargs): # real signature unknown
1074         """ self != 0 """
1075         pass
1076 
1077     def __ceil__(self, *args, **kwargs): # real signature unknown
1078         """ Ceiling of an Integral returns itself. """
1079         pass
1080 
1081     def __divmod__(self, *args, **kwargs): # real signature unknown
1082         """ Return divmod(self, value). """
1083         pass
1084 
1085     def __eq__(self, *args, **kwargs): # real signature unknown
1086         """ Return self==value. """
1087         pass
1088 
1089     def __float__(self, *args, **kwargs): # real signature unknown
1090         """ float(self) """
1091         pass
1092 
1093     def __floordiv__(self, *args, **kwargs): # real signature unknown
1094         """ Return self//value. """
1095         pass
1096 
1097     def __floor__(self, *args, **kwargs): # real signature unknown
1098         """ Flooring an Integral returns itself. """
1099         pass
1100 
1101     def __format__(self, *args, **kwargs): # real signature unknown
1102         pass
1103 
1104     def __getattribute__(self, *args, **kwargs): # real signature unknown
1105         """ Return getattr(self, name). """
1106         pass
1107 
1108     def __getnewargs__(self, *args, **kwargs): # real signature unknown
1109         pass
1110 
1111     def __ge__(self, *args, **kwargs): # real signature unknown
1112         """ Return self>=value. """
1113         pass
1114 
1115     def __gt__(self, *args, **kwargs): # real signature unknown
1116         """ Return self>value. """
1117         pass
1118 
1119     def __hash__(self, *args, **kwargs): # real signature unknown
1120         """ Return hash(self). """
1121         pass
1122 
1123     def __index__(self, *args, **kwargs): # real signature unknown
1124         """ Return self converted to an integer, if self is suitable for use as an index into a list. """
1125         pass
1126 
1127     def __init__(self, x, base=10): # known special case of int.__init__
1128         """
1129         int(x=0) -> integer
1130         int(x, base=10) -> integer
1131         
1132         Convert a number or string to an integer, or return 0 if no arguments
1133         are given.  If x is a number, return x.__int__().  For floating point
1134         numbers, this truncates towards zero.
1135         
1136         If x is not a number or if base is given, then x must be a string,
1137         bytes, or bytearray instance representing an integer literal in the
1138         given base.  The literal can be preceded by ‘+‘ or ‘-‘ and be surrounded
1139         by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
1140         Base 0 means to interpret the base from the string as an integer literal.
1141         >>> int(‘0b100‘, base=0)
1142         4
1143         # (copied from class doc)
1144         """
1145         pass
1146 
1147     def __int__(self, *args, **kwargs): # real signature unknown
1148         """ int(self) """
1149         pass
1150 
1151     def __invert__(self, *args, **kwargs): # real signature unknown
1152         """ ~self """
1153         pass
1154 
1155     def __le__(self, *args, **kwargs): # real signature unknown
1156         """ Return self<=value. """
1157         pass
1158 
1159     def __lshift__(self, *args, **kwargs): # real signature unknown
1160         """ Return self<<value. """
1161         pass
1162 
1163     def __lt__(self, *args, **kwargs): # real signature unknown
1164         """ Return self<value. """
1165         pass
1166 
1167     def __mod__(self, *args, **kwargs): # real signature unknown
1168         """ Return self%value. """
1169         pass
1170 
1171     def __mul__(self, *args, **kwargs): # real signature unknown
1172         """ Return self*value. """
1173         pass
1174 
1175     def __neg__(self, *args, **kwargs): # real signature unknown
1176         """ -self """
1177         pass
1178 
1179     @staticmethod # known case of __new__
1180     def __new__(*args, **kwargs): # real signature unknown
1181         """ Create and return a new object.  See help(type) for accurate signature. """
1182         pass
1183 
1184     def __ne__(self, *args, **kwargs): # real signature unknown
1185         """ Return self!=value. """
1186         pass
1187 
1188     def __or__(self, *args, **kwargs): # real signature unknown
1189         """ Return self|value. """
1190         pass
1191 
1192     def __pos__(self, *args, **kwargs): # real signature unknown
1193         """ +self """
1194         pass
1195 
1196     def __pow__(self, *args, **kwargs): # real signature unknown
1197         """ Return pow(self, value, mod). """
1198         pass
1199 
1200     def __radd__(self, *args, **kwargs): # real signature unknown
1201         """ Return value+self. """
1202         pass
1203 
1204     def __rand__(self, *args, **kwargs): # real signature unknown
1205         """ Return value&self. """
1206         pass
1207 
1208     def __rdivmod__(self, *args, **kwargs): # real signature unknown
1209         """ Return divmod(value, self). """
1210         pass
1211 
1212     def __repr__(self, *args, **kwargs): # real signature unknown
1213         """ Return repr(self). """
1214         pass
1215 
1216     def __rfloordiv__(self, *args, **kwargs): # real signature unknown
1217         """ Return value//self. """
1218         pass
1219 
1220     def __rlshift__(self, *args, **kwargs): # real signature unknown
1221         """ Return value<<self. """
1222         pass
1223 
1224     def __rmod__(self, *args, **kwargs): # real signature unknown
1225         """ Return value%self. """
1226         pass
1227 
1228     def __rmul__(self, *args, **kwargs): # real signature unknown
1229         """ Return value*self. """
1230         pass
1231 
1232     def __ror__(self, *args, **kwargs): # real signature unknown
1233         """ Return value|self. """
1234         pass
1235 
1236     def __round__(self, *args, **kwargs): # real signature unknown
1237         """
1238         Rounding an Integral returns itself.
1239         Rounding with an ndigits argument also returns an integer.
1240         """
1241         pass
1242 
1243     def __rpow__(self, *args, **kwargs): # real signature unknown
1244         """ Return pow(value, self, mod). """
1245         pass
1246 
1247     def __rrshift__(self, *args, **kwargs): # real signature unknown
1248         """ Return value>>self. """
1249         pass
1250 
1251     def __rshift__(self, *args, **kwargs): # real signature unknown
1252         """ Return self>>value. """
1253         pass
1254 
1255     def __rsub__(self, *args, **kwargs): # real signature unknown
1256         """ Return value-self. """
1257         pass
1258 
1259     def __rtruediv__(self, *args, **kwargs): # real signature unknown
1260         """ Return value/self. """
1261         pass
1262 
1263     def __rxor__(self, *args, **kwargs): # real signature unknown
1264         """ Return value^self. """
1265         pass
1266 
1267     def __sizeof__(self, *args, **kwargs): # real signature unknown
1268         """ Returns size in memory, in bytes """
1269         pass
1270 
1271     def __str__(self, *args, **kwargs): # real signature unknown
1272         """ Return str(self). """
1273         pass
1274 
1275     def __sub__(self, *args, **kwargs): # real signature unknown
1276         """ Return self-value. """
1277         pass
1278 
1279     def __truediv__(self, *args, **kwargs): # real signature unknown
1280         """ Return self/value. """
1281         pass
1282 
1283     def __trunc__(self, *args, **kwargs): # real signature unknown
1284         """ Truncating an Integral returns itself. """
1285         pass
1286 
1287     def __xor__(self, *args, **kwargs): # real signature unknown
1288         """ Return self^value. """
1289         pass
1290 
1291     denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1292     """the denominator of a rational number in lowest terms"""
1293 
1294     imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1295     """the imaginary part of a complex number"""
1296 
1297     numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1298     """the numerator of a rational number in lowest terms"""
1299 
1300     real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1301     """the real part of a complex number"""
1302 
1303 
1304 
1305 class bool(int):
1306     """
1307     bool(x) -> bool
1308     
1309     Returns True when the argument x is true, False otherwise.
1310     The builtins True and False are the only two instances of the class bool.
1311     The class bool is a subclass of the class int, and cannot be subclassed.
1312     """
1313     def __and__(self, *args, **kwargs): # real signature unknown
1314         """ Return self&value. """
1315         pass
1316 
1317     def __init__(self, x): # real signature unknown; restored from __doc__
1318         pass
1319 
1320     @staticmethod # known case of __new__
1321     def __new__(*args, **kwargs): # real signature unknown
1322         """ Create and return a new object.  See help(type) for accurate signature. """
1323         pass
1324 
1325     def __or__(self, *args, **kwargs): # real signature unknown
1326         """ Return self|value. """
1327         pass
1328 
1329     def __rand__(self, *args, **kwargs): # real signature unknown
1330         """ Return value&self. """
1331         pass
1332 
1333     def __repr__(self, *args, **kwargs): # real signature unknown
1334         """ Return repr(self). """
1335         pass
1336 
1337     def __ror__(self, *args, **kwargs): # real signature unknown
1338         """ Return value|self. """
1339         pass
1340 
1341     def __rxor__(self, *args, **kwargs): # real signature unknown
1342         """ Return value^self. """
1343         pass
1344 
1345     def __str__(self, *args, **kwargs): # real signature unknown
1346         """ Return str(self). """
1347         pass
1348 
1349     def __xor__(self, *args, **kwargs): # real signature unknown
1350         """ Return self^value. """
1351         pass
1352 
1353 
1354 class ConnectionError(OSError):
1355     """ Connection error. """
1356     def __init__(self, *args, **kwargs): # real signature unknown
1357         pass
1358 
1359 
1360 class BrokenPipeError(ConnectionError):
1361     """ Broken pipe. """
1362     def __init__(self, *args, **kwargs): # real signature unknown
1363         pass
1364 
1365 
1366 class BufferError(Exception):
1367     """ Buffer error. """
1368     def __init__(self, *args, **kwargs): # real signature unknown
1369         pass
1370 
1371     @staticmethod # known case of __new__
1372     def __new__(*args, **kwargs): # real signature unknown
1373         """ Create and return a new object.  See help(type) for accurate signature. """
1374         pass
1375 
1376 
1377 class bytearray(object):
1378     """
1379     bytearray(iterable_of_ints) -> bytearray
1380     bytearray(string, encoding[, errors]) -> bytearray
1381     bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
1382     bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
1383     bytearray() -> empty bytes array
1384     
1385     Construct a mutable bytearray object from:
1386       - an iterable yielding integers in range(256)
1387       - a text string encoded using the specified encoding
1388       - a bytes or a buffer object
1389       - any object implementing the buffer API.
1390       - an integer
1391     """
1392     def append(self, *args, **kwargs): # real signature unknown
1393         """
1394         Append a single item to the end of the bytearray.
1395         
1396           item
1397             The item to be appended.
1398         """
1399         pass
1400 
1401     def capitalize(self): # real signature unknown; restored from __doc__
1402         """
1403         B.capitalize() -> copy of B
1404         
1405         Return a copy of B with only its first character capitalized (ASCII)
1406         and the rest lower-cased.
1407         """
1408         pass
1409 
1410     def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
1411         """
1412         B.center(width[, fillchar]) -> copy of B
1413         
1414         Return B centered in a string of length width.  Padding is
1415         done using the specified fill character (default is a space).
1416         """
1417         pass
1418 
1419     def clear(self, *args, **kwargs): # real signature unknown
1420         """ Remove all items from the bytearray. """
1421         pass
1422 
1423     def copy(self, *args, **kwargs): # real signature unknown
1424         """ Return a copy of B. """
1425         pass
1426 
1427     def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
1428         """
1429         B.count(sub[, start[, end]]) -> int
1430         
1431         Return the number of non-overlapping occurrences of subsection sub in
1432         bytes B[start:end].  Optional arguments start and end are interpreted
1433         as in slice notation.
1434         """
1435         return 0
1436 
1437     def decode(self, *args, **kwargs): # real signature unknown
1438         """
1439         Decode the bytearray using the codec registered for encoding.
1440         
1441           encoding
1442             The encoding with which to decode the bytearray.
1443           errors
1444             The error handling scheme to use for the handling of decoding errors.
1445             The default is ‘strict‘ meaning that decoding errors raise a
1446             UnicodeDecodeError. Other possible values are ‘ignore‘ and ‘replace‘
1447             as well as any other name registered with codecs.register_error that
1448             can handle UnicodeDecodeErrors.
1449         """
1450         pass
1451 
1452     def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
1453         """
1454         B.endswith(suffix[, start[, end]]) -> bool
1455         
1456         Return True if B ends with the specified suffix, False otherwise.
1457         With optional start, test B beginning at that position.
1458         With optional end, stop comparing B at that position.
1459         suffix can also be a tuple of bytes to try.
1460         """
1461         return False
1462 
1463     def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
1464         """
1465         B.expandtabs(tabsize=8) -> copy of B
1466         
1467         Return a copy of B where all tab characters are expanded using spaces.
1468         If tabsize is not given, a tab size of 8 characters is assumed.
1469         """
1470         pass
1471 
1472     def extend(self, *args, **kwargs): # real signature unknown
1473         """
1474         Append all the items from the iterator or sequence to the end of the bytearray.
1475         
1476           iterable_of_ints
1477             The iterable of items to append.
1478         """
1479         pass
1480 
1481     def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
1482         """
1483         B.find(sub[, start[, end]]) -> int
1484         
1485         Return the lowest index in B where subsection sub is found,
1486         such that sub is contained within B[start,end].  Optional
1487         arguments start and end are interpreted as in slice notation.
1488         
1489         Return -1 on failure.
1490         """
1491         return 0
1492 
1493     @classmethod # known case
1494     def fromhex(cls, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
1495         """
1496         Create a bytearray object from a string of hexadecimal numbers.
1497         
1498         Spaces between two numbers are accepted.
1499         Example: bytearray.fromhex(‘B9 01EF‘) -> bytearray(b‘\\\\xb9\\\\x01\\\\xef‘)
1500         """
1501         pass
1502 
1503     def hex(self): # real signature unknown; restored from __doc__
1504         """
1505         B.hex() -> string
1506         
1507         Create a string of hexadecimal numbers from a bytearray object.
1508         Example: bytearray([0xb9, 0x01, 0xef]).hex() -> ‘b901ef‘.
1509         """
1510         return ""
1511 
1512     def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
1513         """
1514         B.index(sub[, start[, end]]) -> int
1515         
1516         Like B.find() but raise ValueError when the subsection is not found.
1517         """
1518         return 0
1519 
1520     def insert(self, *args, **kwargs): # real signature unknown
1521         """
1522         Insert a single item into the bytearray before the given index.
1523         
1524           index
1525             The index where the value is to be inserted.
1526           item
1527             The item to be inserted.
1528         """
1529         pass
1530 
1531     def isalnum(self): # real signature unknown; restored from __doc__
1532         """
1533         B.isalnum() -> bool
1534         
1535         Return True if all characters in B are alphanumeric
1536         and there is at least one character in B, False otherwise.
1537         """
1538         return False
1539 
1540     def isalpha(self): # real signature unknown; restored from __doc__
1541         """
1542         B.isalpha() -> bool
1543         
1544         Return True if all characters in B are alphabetic
1545         and there is at least one character in B, False otherwise.
1546         """
1547         return False
1548 
1549     def isdigit(self): # real signature unknown; restored from __doc__
1550         """
1551         B.isdigit() -> bool
1552         
1553         Return True if all characters in B are digits
1554         and there is at least one character in B, False otherwise.
1555         """
1556         return False
1557 
1558     def islower(self): # real signature unknown; restored from __doc__
1559         """
1560         B.islower() -> bool
1561         
1562         Return True if all cased characters in B are lowercase and there is
1563         at least one cased character in B, False otherwise.
1564         """
1565         return False
1566 
1567     def isspace(self): # real signature unknown; restored from __doc__
1568         """
1569         B.isspace() -> bool
1570         
1571         Return True if all characters in B are whitespace
1572         and there is at least one character in B, False otherwise.
1573         """
1574         return False
1575 
1576     def istitle(self): # real signature unknown; restored from __doc__
1577         """
1578         B.istitle() -> bool
1579         
1580         Return True if B is a titlecased string and there is at least one
1581         character in B, i.e. uppercase characters may only follow uncased
1582         characters and lowercase characters only cased ones. Return False
1583         otherwise.
1584         """
1585         return False
1586 
1587     def isupper(self): # real signature unknown; restored from __doc__
1588         """
1589         B.isupper() -> bool
1590         
1591         Return True if all cased characters in B are uppercase and there is
1592         at least one cased character in B, False otherwise.
1593         """
1594         return False
1595 
1596     def join(self, *args, **kwargs): # real signature unknown
1597         """
1598         Concatenate any number of bytes/bytearray objects.
1599         
1600         The bytearray whose method is called is inserted in between each pair.
1601         
1602         The result is returned as a new bytearray object.
1603         """
1604         pass
1605 
1606     def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
1607         """
1608         B.ljust(width[, fillchar]) -> copy of B
1609         
1610         Return B left justified in a string of length width. Padding is
1611         done using the specified fill character (default is a space).
1612         """
1613         pass
1614 
1615     def lower(self): # real signature unknown; restored from __doc__
1616         """
1617         B.lower() -> copy of B
1618         
1619         Return a copy of B with all ASCII characters converted to lowercase.
1620         """
1621         pass
1622 
1623     def lstrip(self, *args, **kwargs): # real signature unknown
1624         """
1625         Strip leading bytes contained in the argument.
1626         
1627         If the argument is omitted or None, strip leading ASCII whitespace.
1628         """
1629         pass
1630 
1631     @staticmethod # known case
1632     def maketrans(*args, **kwargs): # real signature unknown
1633         """
1634         Return a translation table useable for the bytes or bytearray translate method.
1635         
1636         The returned table will be one where each byte in frm is mapped to the byte at
1637         the same position in to.
1638         
1639         The bytes objects frm and to must be of the same length.
1640         """
1641         pass
1642 
1643     def partition(self, *args, **kwargs): # real signature unknown
1644         """
1645         Partition the bytearray into three parts using the given separator.
1646         
1647         This will search for the separator sep in the bytearray. If the separator is
1648         found, returns a 3-tuple containing the part before the separator, the
1649         separator itself, and the part after it.
1650         
1651         If the separator is not found, returns a 3-tuple containing the original
1652         bytearray object and two empty bytearray objects.
1653         """
1654         pass
1655 
1656     def pop(self, *args, **kwargs): # real signature unknown
1657         """
1658         Remove and return a single item from B.
1659         
1660           index
1661             The index from where to remove the item.
1662             -1 (the default value) means remove the last item.
1663         
1664         If no index argument is given, will pop the last item.
1665         """
1666         pass
1667 
1668     def remove(self, *args, **kwargs): # real signature unknown
1669         """
1670         Remove the first occurrence of a value in the bytearray.
1671         
1672           value
1673             The value to remove.
1674         """
1675         pass
1676 
1677     def replace(self, *args, **kwargs): # real signature unknown
1678         """
1679         Return a copy with all occurrences of substring old replaced by new.
1680         
1681           count
1682             Maximum number of occurrences to replace.
1683             -1 (the default value) means replace all occurrences.
1684         
1685         If the optional argument count is given, only the first count occurrences are
1686         replaced.
1687         """
1688         pass
1689 
1690     def reverse(self, *args, **kwargs): # real signature unknown
1691         """ Reverse the order of the values in B in place. """
1692         pass
1693 
1694     def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
1695         """
1696         B.rfind(sub[, start[, end]]) -> int
1697         
1698         Return the highest index in B where subsection sub is found,
1699         such that sub is contained within B[start,end].  Optional
1700         arguments start and end are interpreted as in slice notation.
1701         
1702         Return -1 on failure.
1703         """
1704         return 0
1705 
1706     def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
1707         """
1708         B.rindex(sub[, start[, end]]) -> int
1709         
1710         Like B.rfind() but raise ValueError when the subsection is not found.
1711         """
1712         return 0
1713 
1714     def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
1715         """
1716         B.rjust(width[, fillchar]) -> copy of B
1717         
1718         Return B right justified in a string of length width. Padding is
1719         done using the specified fill character (default is a space)
1720         """
1721         pass
1722 
1723     def rpartition(self, *args, **kwargs): # real signature unknown
1724         """
1725         Partition the bytes into three parts using the given separator.
1726         
1727         This will search for the separator sep in the bytearray, starting and the end.
1728         If the separator is found, returns a 3-tuple containing the part before the
1729         separator, the separator itself, and the part after it.
1730         
1731         If the separator is not found, returns a 3-tuple containing two empty bytearray
1732         objects and the original bytearray object.
1733         """
1734         pass
1735 
1736     def rsplit(self, *args, **kwargs): # real signature unknown
1737         """
1738         Return a list of the sections in the bytearray, using sep as the delimiter.
1739         
1740           sep
1741             The delimiter according which to split the bytearray.
1742             None (the default value) means split on ASCII whitespace characters
1743             (space, tab, return, newline, formfeed, vertical tab).
1744           maxsplit
1745             Maximum number of splits to do.
1746             -1 (the default value) means no limit.
1747         
1748         Splitting is done starting at the end of the bytearray and working to the front.
1749         """
1750         pass
1751 
1752     def rstrip(self, *args, **kwargs): # real signature unknown
1753         """
1754         Strip trailing bytes contained in the argument.
1755         
1756         If the argument is omitted or None, strip trailing ASCII whitespace.
1757         """
1758         pass
1759 
1760     def split(self, *args, **kwargs): # real signature unknown
1761         """
1762         Return a list of the sections in the bytearray, using sep as the delimiter.
1763         
1764           sep
1765             The delimiter according which to split the bytearray.
1766             None (the default value) means split on ASCII whitespace characters
1767             (space, tab, return, newline, formfeed, vertical tab).
1768           maxsplit
1769             Maximum number of splits to do.
1770             -1 (the default value) means no limit.
1771         """
1772         pass
1773 
1774     def splitlines(self, *args, **kwargs): # real signature unknown
1775         """
1776         Return a list of the lines in the bytearray, breaking at line boundaries.
1777         
1778         Line breaks are not included in the resulting list unless keepends is given and
1779         true.
1780         """
1781         pass
1782 
1783     def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
1784         """
1785         B.startswith(prefix[, start[, end]]) -> bool
1786         
1787         Return True if B starts with the specified prefix, False otherwise.
1788         With optional start, test B beginning at that position.
1789         With optional end, stop comparing B at that position.
1790         prefix can also be a tuple of bytes to try.
1791         """
1792         return False
1793 
1794     def strip(self, *args, **kwargs): # real signature unknown
1795         """
1796         Strip leading and trailing bytes contained in the argument.
1797         
1798         If the argument is omitted or None, strip leading and trailing ASCII whitespace.
1799         """
1800         pass
1801 
1802     def swapcase(self): # real signature unknown; restored from __doc__
1803         """
1804         B.swapcase() -> copy of B
1805         
1806         Return a copy of B with uppercase ASCII characters converted
1807         to lowercase ASCII and vice versa.
1808         """
1809         pass
1810 
1811     def title(self): # real signature unknown; restored from __doc__
1812         """
1813         B.title() -> copy of B
1814         
1815         Return a titlecased version of B, i.e. ASCII words start with uppercase
1816         characters, all remaining cased characters have lowercase.
1817         """
1818         pass
1819 
1820     def translate(self, *args, **kwargs): # real signature unknown
1821         """
1822         Return a copy with each character mapped by the given translation table.
1823         
1824           table
1825             Translation table, which must be a bytes object of length 256.
1826         
1827         All characters occurring in the optional argument delete are removed.
1828         The remaining characters are mapped through the given translation table.
1829         """
1830         pass
1831 
1832     def upper(self): # real signature unknown; restored from __doc__
1833         """
1834         B.upper() -> copy of B
1835         
1836         Return a copy of B with all ASCII characters converted to uppercase.
1837         """
1838         pass
1839 
1840     def zfill(self, width): # real signature unknown; restored from __doc__
1841         """
1842         B.zfill(width) -> copy of B
1843         
1844         Pad a numeric string B with zeros on the left, to fill a field
1845         of the specified width.  B is never truncated.
1846         """
1847         pass
1848 
1849     def __add__(self, *args, **kwargs): # real signature unknown
1850         """ Return self+value. """
1851         pass
1852 
1853     def __alloc__(self): # real signature unknown; restored from __doc__
1854         """
1855         B.__alloc__() -> int
1856         
1857         Return the number of bytes actually allocated.
1858         """
1859         return 0
1860 
1861     def __contains__(self, *args, **kwargs): # real signature unknown
1862         """ Return key in self. """
1863         pass
1864 
1865     def __delitem__(self, *args, **kwargs): # real signature unknown
1866         """ Delete self[key]. """
1867         pass
1868 
1869     def __eq__(self, *args, **kwargs): # real signature unknown
1870         """ Return self==value. """
1871         pass
1872 
1873     def __getattribute__(self, *args, **kwargs): # real signature unknown
1874         """ Return getattr(self, name). """
1875         pass
1876 
1877     def __getitem__(self, *args, **kwargs): # real signature unknown
1878         """ Return self[key]. """
1879         pass
1880 
1881     def __ge__(self, *args, **kwargs): # real signature unknown
1882         """ Return self>=value. """
1883         pass
1884 
1885     def __gt__(self, *args, **kwargs): # real signature unknown
1886         """ Return self>value. """
1887         pass
1888 
1889     def __iadd__(self, *args, **kwargs): # real signature unknown
1890         """ Implement self+=value. """
1891         pass
1892 
1893     def __imul__(self, *args, **kwargs): # real signature unknown
1894         """ Implement self*=value. """
1895         pass
1896 
1897     def __init__(self, source=None, encoding=None, errors=‘strict‘): # known special case of bytearray.__init__
1898         """
1899         bytearray(iterable_of_ints) -> bytearray
1900         bytearray(string, encoding[, errors]) -> bytearray
1901         bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
1902         bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
1903         bytearray() -> empty bytes array
1904         
1905         Construct a mutable bytearray object from:
1906           - an iterable yielding integers in range(256)
1907           - a text string encoded using the specified encoding
1908           - a bytes or a buffer object
1909           - any object implementing the buffer API.
1910           - an integer
1911         # (copied from class doc)
1912         """
1913         pass
1914 
1915     def __iter__(self, *args, **kwargs): # real signature unknown
1916         """ Implement iter(self). """
1917         pass
1918 
1919     def __len__(self, *args, **kwargs): # real signature unknown
1920         """ Return len(self). """
1921         pass
1922 
1923     def __le__(self, *args, **kwargs): # real signature unknown
1924         """ Return self<=value. """
1925         pass
1926 
1927     def __lt__(self, *args, **kwargs): # real signature unknown
1928         """ Return self<value. """
1929         pass
1930 
1931     def __mod__(self, *args, **kwargs): # real signature unknown
1932         """ Return self%value. """
1933         pass
1934 
1935     def __mul__(self, *args, **kwargs): # real signature unknown
1936         """ Return self*value.n """
1937         pass
1938 
1939     @staticmethod # known case of __new__
1940     def __new__(*args, **kwargs): # real signature unknown
1941         """ Create and return a new object.  See help(type) for accurate signature. """
1942         pass
1943 
1944     def __ne__(self, *args, **kwargs): # real signature unknown
1945         """ Return self!=value. """
1946         pass
1947 
1948     def __reduce_ex__(self, *args, **kwargs): # real signature unknown
1949         """ Return state information for pickling. """
1950         pass
1951 
1952     def __reduce__(self, *args, **kwargs): # real signature unknown
1953         """ Return state information for pickling. """
1954         pass
1955 
1956     def __repr__(self, *args, **kwargs): # real signature unknown
1957         """ Return repr(self). """
1958         pass
1959 
1960     def __rmod__(self, *args, **kwargs): # real signature unknown
1961         """ Return value%self. """
1962         pass
1963 
1964     def __rmul__(self, *args, **kwargs): # real signature unknown
1965         """ Return self*value. """
1966         pass
1967 
1968     def __setitem__(self, *args, **kwargs): # real signature unknown
1969         """ Set self[key] to value. """
1970         pass
1971 
1972     def __sizeof__(self, *args, **kwargs): # real signature unknown
1973         """ Returns the size of the bytearray object in memory, in bytes. """
1974         pass
1975 
1976     def __str__(self, *args, **kwargs): # real signature unknown
1977         """ Return str(self). """
1978         pass
1979 
1980     __hash__ = None
1981 
1982 
1983 class bytes(object):
1984     """
1985     bytes(iterable_of_ints) -> bytes
1986     bytes(string, encoding[, errors]) -> bytes
1987     bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
1988     bytes(int) -> bytes object of size given by the parameter initialized with null bytes
1989     bytes() -> empty bytes object
1990     
1991     Construct an immutable array of bytes from:
1992       - an iterable yielding integers in range(256)
1993       - a text string encoded using the specified encoding
1994       - any object implementing the buffer API.
1995       - an integer
1996     """
1997     def capitalize(self): # real signature unknown; restored from __doc__
1998         """
1999         B.capitalize() -> copy of B
2000         
2001         Return a copy of B with only its first character capitalized (ASCII)
2002         and the rest lower-cased.
2003         """
2004         pass
2005 
2006     def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
2007         """
2008         B.center(width[, fillchar]) -> copy of B
2009         
2010         Return B centered in a string of length width.  Padding is
2011         done using the specified fill character (default is a space).
2012         """
2013         pass
2014 
2015     def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
2016         """
2017         B.count(sub[, start[, end]]) -> int
2018         
2019         Return the number of non-overlapping occurrences of subsection sub in
2020         bytes B[start:end].  Optional arguments start and end are interpreted
2021         as in slice notation.
2022         """
2023         return 0
2024 
2025     def decode(self, *args, **kwargs): # real signature unknown
2026         """
2027         Decode the bytes using the codec registered for encoding.
2028         
2029           encoding
2030             The encoding with which to decode the bytes.
2031           errors
2032             The error handling scheme to use for the handling of decoding errors.
2033             The default is ‘strict‘ meaning that decoding errors raise a
2034             UnicodeDecodeError. Other possible values are ‘ignore‘ and ‘replace‘
2035             as well as any other name registered with codecs.register_error that
2036             can handle UnicodeDecodeErrors.
2037         """
2038         pass
2039 
2040     def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
2041         """
2042         B.endswith(suffix[, start[, end]]) -> bool
2043         
2044         Return True if B ends with the specified suffix, False otherwise.
2045         With optional start, test B beginning at that position.
2046         With optional end, stop comparing B at that position.
2047         suffix can also be a tuple of bytes to try.
2048         """
2049         return False
2050 
2051     def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
2052         """
2053         B.expandtabs(tabsize=8) -> copy of B
2054         
2055         Return a copy of B where all tab characters are expanded using spaces.
2056         If tabsize is not given, a tab size of 8 characters is assumed.
2057         """
2058         pass
2059 
2060     def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
2061         """
2062         B.find(sub[, start[, end]]) -> int
2063         
2064         Return the lowest index in B where subsection sub is found,
2065         such that sub is contained within B[start,end].  Optional
2066         arguments start and end are interpreted as in slice notation.
2067         
2068         Return -1 on failure.
2069         """
2070         return 0
2071 
2072     @classmethod # known case
2073     def fromhex(cls, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
2074         """
2075         Create a bytes object from a string of hexadecimal numbers.
2076         
2077         Spaces between two numbers are accepted.
2078         Example: bytes.fromhex(‘B9 01EF‘) -> b‘\\\\xb9\\\\x01\\\\xef‘.
2079         """
2080         pass
2081 
2082     def hex(self): # real signature unknown; restored from __doc__
2083         """
2084         B.hex() -> string
2085         
2086         Create a string of hexadecimal numbers from a bytes object.
2087         Example: b‘\\xb9\\x01\\xef‘.hex() -> ‘b901ef‘.
2088         """
2089         return ""
2090 
2091     def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
2092         """
2093         B.index(sub[, start[, end]]) -> int
2094         
2095         Like B.find() but raise ValueError when the subsection is not found.
2096         """
2097         return 0
2098 
2099     def isalnum(self): # real signature unknown; restored from __doc__
2100         """
2101         B.isalnum() -> bool
2102         
2103         Return True if all characters in B are alphanumeric
2104         and there is at least one character in B, False otherwise.
2105         """
2106         return False
2107 
2108     def isalpha(self): # real signature unknown; restored from __doc__
2109         """
2110         B.isalpha() -> bool
2111         
2112         Return True if all characters in B are alphabetic
2113         and there is at least one character in B, False otherwise.
2114         """
2115         return False
2116 
2117     def isdigit(self): # real signature unknown; restored from __doc__
2118         """
2119         B.isdigit() -> bool
2120         
2121         Return True if all characters in B are digits
2122         and there is at least one character in B, False otherwise.
2123         """
2124         return False
2125 
2126     def islower(self): # real signature unknown; restored from __doc__
2127         """
2128         B.islower() -> bool
2129         
2130         Return True if all cased characters in B are lowercase and there is
2131         at least one cased character in B, False otherwise.
2132         """
2133         return False
2134 
2135     def isspace(self): # real signature unknown; restored from __doc__
2136         """
2137         B.isspace() -> bool
2138         
2139         Return True if all characters in B are whitespace
2140         and there is at least one character in B, False otherwise.
2141         """
2142         return False
2143 
2144     def istitle(self): # real signature unknown; restored from __doc__
2145         """
2146         B.istitle() -> bool
2147         
2148         Return True if B is a titlecased string and there is at least one
2149         character in B, i.e. uppercase characters may only follow uncased
2150         characters and lowercase characters only cased ones. Return False
2151         otherwise.
2152         """
2153         return False
2154 
2155     def isupper(self): # real signature unknown; restored from __doc__
2156         """
2157         B.isupper() -> bool
2158         
2159         Return True if all cased characters in B are uppercase and there is
2160         at least one cased character in B, False otherwise.
2161         """
2162         return False
2163 
2164     def join(self, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
2165         """
2166         Concatenate any number of bytes objects.
2167         
2168         The bytes whose method is called is inserted in between each pair.
2169         
2170         The result is returned as a new bytes object.
2171         
2172         Example: b‘.‘.join([b‘ab‘, b‘pq‘, b‘rs‘]) -> b‘ab.pq.rs‘.
2173         """
2174         pass
2175 
2176     def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
2177         """
2178         B.ljust(width[, fillchar]) -> copy of B
2179         
2180         Return B left justified in a string of length width. Padding is
2181         done using the specified fill character (default is a space).
2182         """
2183         pass
2184 
2185     def lower(self): # real signature unknown; restored from __doc__
2186         """
2187         B.lower() -> copy of B
2188         
2189         Return a copy of B with all ASCII characters converted to lowercase.
2190         """
2191         pass
2192 
2193     def lstrip(self, *args, **kwargs): # real signature unknown
2194         """
2195         Strip leading bytes contained in the argument.
2196         
2197         If the argument is omitted or None, strip leading  ASCII whitespace.
2198         """
2199         pass
2200 
2201     @staticmethod # known case
2202     def maketrans(*args, **kwargs): # real signature unknown
2203         """
2204         Return a translation table useable for the bytes or bytearray translate method.
2205         
2206         The returned table will be one where each byte in frm is mapped to the byte at
2207         the same position in to.
2208         
2209         The bytes objects frm and to must be of the same length.
2210         """
2211         pass
2212 
2213     def partition(self, *args, **kwargs): # real signature unknown
2214         """
2215         Partition the bytes into three parts using the given separator.
2216         
2217         This will search for the separator sep in the bytes. If the separator is found,
2218         returns a 3-tuple containing the part before the separator, the separator
2219         itself, and the part after it.
2220         
2221         If the separator is not found, returns a 3-tuple containing the original bytes
2222         object and two empty bytes objects.
2223         """
2224         pass
2225 
2226     def replace(self, *args, **kwargs): # real signature unknown
2227         """
2228         Return a copy with all occurrences of substring old replaced by new.
2229         
2230           count
2231             Maximum number of occurrences to replace.
2232             -1 (the default value) means replace all occurrences.
2233         
2234         If the optional argument count is given, only the first count occurrences are
2235         replaced.
2236         """
2237         pass
2238 
2239     def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
2240         """
2241         B.rfind(sub[, start[, end]]) -> int
2242         
2243         Return the highest index in B where subsection sub is found,
2244         such that sub is contained within B[start,end].  Optional
2245         arguments start and end are interpreted as in slice notation.
2246         
2247         Return -1 on failure.
2248         """
2249         return 0
2250 
2251     def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
2252         """
2253         B.rindex(sub[, start[, end]]) -> int
2254         
2255         Like B.rfind() but raise ValueError when the subsection is not found.
2256         """
2257         return 0
2258 
2259     def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
2260         """
2261         B.rjust(width[, fillchar]) -> copy of B
2262         
2263         Return B right justified in a string of length width. Padding is
2264         done using the specified fill character (default is a space)
2265         """
2266         pass
2267 
2268     def rpartition(self, *args, **kwargs): # real signature unknown
2269         """
2270         Partition the bytes into three parts using the given separator.
2271         
2272         This will search for the separator sep in the bytes, starting and the end. If
2273         the separator is found, returns a 3-tuple containing the part before the
2274         separator, the separator itself, and the part after it.
2275         
2276         If the separator is not found, returns a 3-tuple containing two empty bytes
2277         objects and the original bytes object.
2278         """
2279         pass
2280 
2281     def rsplit(self, *args, **kwargs): # real signature unknown
2282         """
2283         Return a list of the sections in the bytes, using sep as the delimiter.
2284         
2285           sep
2286             The delimiter according which to split the bytes.
2287             None (the default value) means split on ASCII whitespace characters
2288             (space, tab, return, newline, formfeed, vertical tab).
2289           maxsplit
2290             Maximum number of splits to do.
2291             -1 (the default value) means no limit.
2292         
2293         Splitting is done starting at the end of the bytes and working to the front.
2294         """
2295         pass
2296 
2297     def rstrip(self, *args, **kwargs): # real signature unknown
2298         """
2299         Strip trailing bytes contained in the argument.
2300         
2301         If the argument is omitted or None, strip trailing ASCII whitespace.
2302         """
2303         pass
2304 
2305     def split(self, *args, **kwargs): # real signature unknown
2306         """
2307         Return a list of the sections in the bytes, using sep as the delimiter.
2308         
2309           sep
2310             The delimiter according which to split the bytes.
2311             None (the default value) means split on ASCII whitespace characters
2312             (space, tab, return, newline, formfeed, vertical tab).
2313           maxsplit
2314             Maximum number of splits to do.
2315             -1 (the default value) means no limit.
2316         """
2317         pass
2318 
2319     def splitlines(self, *args, **kwargs): # real signature unknown
2320         """
2321         Return a list of the lines in the bytes, breaking at line boundaries.
2322         
2323         Line breaks are not included in the resulting list unless keepends is given and
2324         true.
2325         """
2326         pass
2327 
2328     def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
2329         """
2330         B.startswith(prefix[, start[, end]]) -> bool
2331         
2332         Return True if B starts with the specified prefix, False otherwise.
2333         With optional start, test B beginning at that position.
2334         With optional end, stop comparing B at that position.
2335         prefix can also be a tuple of bytes to try.
2336         """
2337         return False
2338 
2339     def strip(self, *args, **kwargs): # real signature unknown
2340         """
2341         Strip leading and trailing bytes contained in the argument.
2342         
2343         If the argument is omitted or None, strip leading and trailing ASCII whitespace.
2344         """
2345         pass
2346 
2347     def swapcase(self): # real signature unknown; restored from __doc__
2348         """
2349         B.swapcase() -> copy of B
2350         
2351         Return a copy of B with uppercase ASCII characters converted
2352         to lowercase ASCII and vice versa.
2353         """
2354         pass
2355 
2356     def title(self): # real signature unknown; restored from __doc__
2357         """
2358         B.title() -> copy of B
2359         
2360         Return a titlecased version of B, i.e. ASCII words start with uppercase
2361         characters, all remaining cased characters have lowercase.
2362         """
2363         pass
2364 
2365     def translate(self, *args, **kwargs): # real signature unknown
2366         """
2367         Return a copy with each character mapped by the given translation table.
2368         
2369           table
2370             Translation table, which must be a bytes object of length 256.
2371         
2372         All characters occurring in the optional argument delete are removed.
2373         The remaining characters are mapped through the given translation table.
2374         """
2375         pass
2376 
2377     def upper(self): # real signature unknown; restored from __doc__
2378         """
2379         B.upper() -> copy of B
2380         
2381         Return a copy of B with all ASCII characters converted to uppercase.
2382         """
2383         pass
2384 
2385     def zfill(self, width): # real signature unknown; restored from __doc__
2386         """
2387         B.zfill(width) -> copy of B
2388         
2389         Pad a numeric string B with zeros on the left, to fill a field
2390         of the specified width.  B is never truncated.
2391         """
2392         pass
2393 
2394     def __add__(self, *args, **kwargs): # real signature unknown
2395         """ Return self+value. """
2396         pass
2397 
2398     def __contains__(self, *args, **kwargs): # real signature unknown
2399         """ Return key in self. """
2400         pass
2401 
2402     def __eq__(self, *args, **kwargs): # real signature unknown
2403         """ Return self==value. """
2404         pass
2405 
2406     def __getattribute__(self, *args, **kwargs): # real signature unknown
2407         """ Return getattr(self, name). """
2408         pass
2409 
2410     def __getitem__(self, *args, **kwargs): # real signature unknown
2411         """ Return self[key]. """
2412         pass
2413 
2414     def __getnewargs__(self, *args, **kwargs): # real signature unknown
2415         pass
2416 
2417     def __ge__(self, *args, **kwargs): # real signature unknown
2418         """ Return self>=value. """
2419         pass
2420 
2421     def __gt__(self, *args, **kwargs): # real signature unknown
2422         """ Return self>value. """
2423         pass
2424 
2425     def __hash__(self, *args, **kwargs): # real signature unknown
2426         """ Return hash(self). """
2427         pass
2428 
2429     def __init__(self, value=b‘‘, encoding=None, errors=‘strict‘): # known special case of bytes.__init__
2430         """
2431         bytes(iterable_of_ints) -> bytes
2432         bytes(string, encoding[, errors]) -> bytes
2433         bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
2434         bytes(int) -> bytes object of size given by the parameter initialized with null bytes
2435         bytes() -> empty bytes object
2436         
2437         Construct an immutable array of bytes from:
2438           - an iterable yielding integers in range(256)
2439           - a text string encoded using the specified encoding
2440           - any object implementing the buffer API.
2441           - an integer
2442         # (copied from class doc)
2443         """
2444         pass
2445 
2446     def __iter__(self, *args, **kwargs): # real signature unknown
2447         """ Implement iter(self). """
2448         pass
2449 
2450     def __len__(self, *args, **kwargs): # real signature unknown
2451         """ Return len(self). """
2452         pass
2453 
2454     def __le__(self, *args, **kwargs): # real signature unknown
2455         """ Return self<=value. """
2456         pass
2457 
2458     def __lt__(self, *args, **kwargs): # real signature unknown
2459         """ Return self<value. """
2460         pass
2461 
2462     def __mod__(self, *args, **kwargs): # real signature unknown
2463         """ Return self%value. """
2464         pass
2465 
2466     def __mul__(self, *args, **kwargs): # real signature unknown
2467         """ Return self*value.n """
2468         pass
2469 
2470     @staticmethod # known case of __new__
2471     def __new__(*args, **kwargs): # real signature unknown
2472         """ Create and return a new object.  See help(type) for accurate signature. """
2473         pass
2474 
2475     def __ne__(self, *args, **kwargs): # real signature unknown
2476         """ Return self!=value. """
2477         pass
2478 
2479     def __repr__(self, *args, **kwargs): # real signature unknown
2480         """ Return repr(self). """
2481         pass
2482 
2483     def __rmod__(self, *args, **kwargs): # real signature unknown
2484         """ Return value%self. """
2485         pass
2486 
2487     def __rmul__(self, *args, **kwargs): # real signature unknown
2488         """ Return self*value. """
2489         pass
2490 
2491     def __str__(self, *args, **kwargs): # real signature unknown
2492         """ Return str(self). """
2493         pass
2494 
2495 
2496 class Warning(Exception):
2497     """ Base class for warning categories. """
2498     def __init__(self, *args, **kwargs): # real signature unknown
2499         pass
2500 
2501     @staticmethod # known case of __new__
2502     def __new__(*args, **kwargs): # real signature unknown
2503         """ Create and return a new object.  See help(type) for accurate signature. """
2504         pass
2505 
2506 
2507 class BytesWarning(Warning):
2508     """
2509     Base class for warnings about bytes and buffer related problems, mostly
2510     related to conversion from str or comparing to str.
2511     """
2512     def __init__(self, *args, **kwargs): # real signature unknown
2513         pass
2514 
2515     @staticmethod # known case of __new__
2516     def __new__(*args, **kwargs): # real signature unknown
2517         """ Create and return a new object.  See help(type) for accurate signature. """
2518         pass
2519 
2520 
2521 class ChildProcessError(OSError):
2522     """ Child process error. """
2523     def __init__(self, *args, **kwargs): # real signature unknown
2524         pass
2525 
2526 
2527 class classmethod(object):
2528     """
2529     classmethod(function) -> method
2530     
2531     Convert a function to be a class method.
2532     
2533     A class method receives the class as implicit first argument,
2534     just like an instance method receives the instance.
2535     To declare a class method, use this idiom:
2536     
2537       class C:
2538           @classmethod
2539           def f(cls, arg1, arg2, ...):
2540               ...
2541     
2542     It can be called either on the class (e.g. C.f()) or on an instance
2543     (e.g. C().f()).  The instance is ignored except for its class.
2544     If a class method is called for a derived class, the derived class
2545     object is passed as the implied first argument.
2546     
2547     Class methods are different than C++ or Java static methods.
2548     If you want those, see the staticmethod builtin.
2549     """
2550     def __get__(self, *args, **kwargs): # real signature unknown
2551         """ Return an attribute of instance, which is of type owner. """
2552         pass
2553 
2554     def __init__(self, function): # real signature unknown; restored from __doc__
2555         pass
2556 
2557     @staticmethod # known case of __new__
2558     def __new__(*args, **kwargs): # real signature unknown
2559         """ Create and return a new object.  See help(type) for accurate signature. """
2560         pass
2561 
2562     __func__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
2563 
2564     __isabstractmethod__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
2565 
2566 
2567     __dict__ = None # (!) real value is ‘‘
2568 
2569 
2570 class complex(object):
2571     """
2572     complex(real[, imag]) -> complex number
2573     
2574     Create a complex number from a real part and an optional imaginary part.
2575     This is equivalent to (real + imag*1j) where imag defaults to 0.
2576     """
2577     def conjugate(self): # real signature unknown; restored from __doc__
2578         """
2579         complex.conjugate() -> complex
2580         
2581         Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.
2582         """
2583         return complex
2584 
2585     def __abs__(self, *args, **kwargs): # real signature unknown
2586         """ abs(self) """
2587         pass
2588 
2589     def __add__(self, *args, **kwargs): # real signature unknown
2590         """ Return self+value. """
2591         pass
2592 
2593     def __bool__(self, *args, **kwargs): # real signature unknown
2594         """ self != 0 """
2595         pass
2596 
2597     def __divmod__(self, *args, **kwargs): # real signature unknown
2598         """ Return divmod(self, value). """
2599         pass
2600 
2601     def __eq__(self, *args, **kwargs): # real signature unknown
2602         """ Return self==value. """
2603         pass
2604 
2605     def __float__(self, *args, **kwargs): # real signature unknown
2606         """ float(self) """
2607         pass
2608 
2609     def __floordiv__(self, *args, **kwargs): # real signature unknown
2610         """ Return self//value. """
2611         pass
2612 
2613     def __format__(self): # real signature unknown; restored from __doc__
2614         """
2615         complex.__format__() -> str
2616         
2617         Convert to a string according to format_spec.
2618         """
2619         return ""
2620 
2621     def __getattribute__(self, *args, **kwargs): # real signature unknown
2622         """ Return getattr(self, name). """
2623         pass
2624 
2625     def __getnewargs__(self, *args, **kwargs): # real signature unknown
2626         pass
2627 
2628     def __ge__(self, *args, **kwargs): # real signature unknown
2629         """ Return self>=value. """
2630         pass
2631 
2632     def __gt__(self, *args, **kwargs): # real signature unknown
2633         """ Return self>value. """
2634         pass
2635 
2636     def __hash__(self, *args, **kwargs): # real signature unknown
2637         """ Return hash(self). """
2638         pass
2639 
2640     def __init__(self, real, imag=None): # real signature unknown; restored from __doc__
2641         pass
2642 
2643     def __int__(self, *args, **kwargs): # real signature unknown
2644         """ int(self) """
2645         pass
2646 
2647     def __le__(self, *args, **kwargs): # real signature unknown
2648         """ Return self<=value. """
2649         pass
2650 
2651     def __lt__(self, *args, **kwargs): # real signature unknown
2652         """ Return self<value. """
2653         pass
2654 
2655     def __mod__(self, *args, **kwargs): # real signature unknown
2656         """ Return self%value. """
2657         pass
2658 
2659     def __mul__(self, *args, **kwargs): # real signature unknown
2660         """ Return self*value. """
2661         pass
2662 
2663     def __neg__(self, *args, **kwargs): # real signature unknown
2664         """ -self """
2665         pass
2666 
2667     @staticmethod # known case of __new__
2668     def __new__(*args, **kwargs): # real signature unknown
2669         """ Create and return a new object.  See help(type) for accurate signature. """
2670         pass
2671 
2672     def __ne__(self, *args, **kwargs): # real signature unknown
2673         """ Return self!=value. """
2674         pass
2675 
2676     def __pos__(self, *args, **kwargs): # real signature unknown
2677         """ +self """
2678         pass
2679 
2680     def __pow__(self, *args, **kwargs): # real signature unknown
2681         """ Return pow(self, value, mod). """
2682         pass
2683 
2684     def __radd__(self, *args, **kwargs): # real signature unknown
2685         """ Return value+self. """
2686         pass
2687 
2688     def __rdivmod__(self, *args, **kwargs): # real signature unknown
2689         """ Return divmod(value, self). """
2690         pass
2691 
2692     def __repr__(self, *args, **kwargs): # real signature unknown
2693         """ Return repr(self). """
2694         pass
2695 
2696     def __rfloordiv__(self, *args, **kwargs): # real signature unknown
2697         """ Return value//self. """
2698         pass
2699 
2700     def __rmod__(self, *args, **kwargs): # real signature unknown
2701         """ Return value%self. """
2702         pass
2703 
2704     def __rmul__(self, *args, **kwargs): # real signature unknown
2705         """ Return value*self. """
2706         pass
2707 
2708     def __rpow__(self, *args, **kwargs): # real signature unknown
2709         """ Return pow(value, self, mod). """
2710         pass
2711 
2712     def __rsub__(self, *args, **kwargs): # real signature unknown
2713         """ Return value-self. """
2714         pass
2715 
2716     def __rtruediv__(self, *args, **kwargs): # real signature unknown
2717         """ Return value/self. """
2718         pass
2719 
2720     def __str__(self, *args, **kwargs): # real signature unknown
2721         """ Return str(self). """
2722         pass
2723 
2724     def __sub__(self, *args, **kwargs): # real signature unknown
2725         """ Return self-value. """
2726         pass
2727 
2728     def __truediv__(self, *args, **kwargs): # real signature unknown
2729         """ Return self/value. """
2730         pass
2731 
2732     imag = property(lambda self: 0.0)
2733     """the imaginary part of a complex number
2734 
2735     :type: float
2736     """
2737 
2738     real = property(lambda self: 0.0)
2739     """the real part of a complex number
2740 
2741     :type: float
2742     """
2743 
2744 
2745 
2746 class ConnectionAbortedError(ConnectionError):
2747     """ Connection aborted. """
2748     def __init__(self, *args, **kwargs): # real signature unknown
2749         pass
2750 
2751 
2752 class ConnectionRefusedError(ConnectionError):
2753     """ Connection refused. """
2754     def __init__(self, *args, **kwargs): # real signature unknown
2755         pass
2756 
2757 
2758 class ConnectionResetError(ConnectionError):
2759     """ Connection reset. """
2760     def __init__(self, *args, **kwargs): # real signature unknown
2761         pass
2762 
2763 
2764 class DeprecationWarning(Warning):
2765     """ Base class for warnings about deprecated features. """
2766     def __init__(self, *args, **kwargs): # real signature unknown
2767         pass
2768 
2769     @staticmethod # known case of __new__
2770     def __new__(*args, **kwargs): # real signature unknown
2771         """ Create and return a new object.  See help(type) for accurate signature. """
2772         pass
2773 
2774 
2775 class dict(object):
2776     """
2777     dict() -> new empty dictionary
2778     dict(mapping) -> new dictionary initialized from a mapping object‘s
2779         (key, value) pairs
2780     dict(iterable) -> new dictionary initialized as if via:
2781         d = {}
2782         for k, v in iterable:
2783             d[k] = v
2784     dict(**kwargs) -> new dictionary initialized with the name=value pairs
2785         in the keyword argument list.  For example:  dict(one=1, two=2)
2786     """
2787     def clear(self): # real signature unknown; restored from __doc__
2788         """ D.clear() -> None.  Remove all items from D. """
2789         pass
2790 
2791     def copy(self): # real signature unknown; restored from __doc__
2792         """ D.copy() -> a shallow copy of D """
2793         pass
2794 
2795     @staticmethod # known case
2796     def fromkeys(*args, **kwargs): # real signature unknown
2797         """ Returns a new dict with keys from iterable and values equal to value. """
2798         pass
2799 
2800     def get(self, k, d=None): # real signature unknown; restored from __doc__
2801         """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
2802         pass
2803 
2804     def items(self): # real signature unknown; restored from __doc__
2805         """ D.items() -> a set-like object providing a view on D‘s items """
2806         pass
2807 
2808     def keys(self): # real signature unknown; restored from __doc__
2809         """ D.keys() -> a set-like object providing a view on D‘s keys """
2810         pass
2811 
2812     def pop(self, k, d=None): # real signature unknown; restored from __doc__
2813         """
2814         D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
2815         If key is not found, d is returned if given, otherwise KeyError is raised
2816         """
2817         pass
2818 
2819     def popitem(self): # real signature unknown; restored from __doc__
2820         """
2821         D.popitem() -> (k, v), remove and return some (key, value) pair as a
2822         2-tuple; but raise KeyError if D is empty.
2823         """
2824         pass
2825 
2826     def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
2827         """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
2828         pass
2829 
2830     def update(self, E=None, **F): # known special case of dict.update
2831         """
2832         D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
2833         If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
2834         If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
2835         In either case, this is followed by: for k in F:  D[k] = F[k]
2836         """
2837         pass
2838 
2839     def values(self): # real signature unknown; restored from __doc__
2840         """ D.values() -> an object providing a view on D‘s values """
2841         pass
2842 
2843     def __contains__(self, *args, **kwargs): # real signature unknown
2844         """ True if D has a key k, else False. """
2845         pass
2846 
2847     def __delitem__(self, *args, **kwargs): # real signature unknown
2848         """ Delete self[key]. """
2849         pass
2850 
2851     def __eq__(self, *args, **kwargs): # real signature unknown
2852         """ Return self==value. """
2853         pass
2854 
2855     def __getattribute__(self, *args, **kwargs): # real signature unknown
2856         """ Return getattr(self, name). """
2857         pass
2858 
2859     def __getitem__(self, y): # real signature unknown; restored from __doc__
2860         """ x.__getitem__(y) <==> x[y] """
2861         pass
2862 
2863     def __ge__(self, *args, **kwargs): # real signature unknown
2864         """ Return self>=value. """
2865         pass
2866 
2867     def __gt__(self, *args, **kwargs): # real signature unknown
2868         """ Return self>value. """
2869         pass
2870 
2871     def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
2872         """
2873         dict() -> new empty dictionary
2874         dict(mapping) -> new dictionary initialized from a mapping object‘s
2875             (key, value) pairs
2876         dict(iterable) -> new dictionary initialized as if via:
2877             d = {}
2878             for k, v in iterable:
2879                 d[k] = v
2880         dict(**kwargs) -> new dictionary initialized with the name=value pairs
2881             in the keyword argument list.  For example:  dict(one=1, two=2)
2882         # (copied from class doc)
2883         """
2884         pass
2885 
2886     def __iter__(self, *args, **kwargs): # real signature unknown
2887         """ Implement iter(self). """
2888         pass
2889 
2890     def __len__(self, *args, **kwargs): # real signature unknown
2891         """ Return len(self). """
2892         pass
2893 
2894     def __le__(self, *args, **kwargs): # real signature unknown
2895         """ Return self<=value. """
2896         pass
2897 
2898     def __lt__(self, *args, **kwargs): # real signature unknown
2899         """ Return self<value. """
2900         pass
2901 
2902     @staticmethod # known case of __new__
2903     def __new__(*args, **kwargs): # real signature unknown
2904         """ Create and return a new object.  See help(type) for accurate signature. """
2905         pass
2906 
2907     def __ne__(self, *args, **kwargs): # real signature unknown
2908         """ Return self!=value. """
2909         pass
2910 
2911     def __repr__(self, *args, **kwargs): # real signature unknown
2912         """ Return repr(self). """
2913         pass
2914 
2915     def __setitem__(self, *args, **kwargs): # real signature unknown
2916         """ Set self[key] to value. """
2917         pass
2918 
2919     def __sizeof__(self): # real signature unknown; restored from __doc__
2920         """ D.__sizeof__() -> size of D in memory, in bytes """
2921         pass
2922 
2923     __hash__ = None
2924 
2925 
2926 class enumerate(object):
2927     """
2928     enumerate(iterable[, start]) -> iterator for index, value of iterable
2929     
2930     Return an enumerate object.  iterable must be another object that supports
2931     iteration.  The enumerate object yields pairs containing a count (from
2932     start, which defaults to zero) and a value yielded by the iterable argument.
2933     enumerate is useful for obtaining an indexed list:
2934         (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
2935     """
2936     def __getattribute__(self, *args, **kwargs): # real signature unknown
2937         """ Return getattr(self, name). """
2938         pass
2939 
2940     def __init__(self, iterable, start=0): # known special case of enumerate.__init__
2941         """ Initialize self.  See help(type(self)) for accurate signature. """
2942         pass
2943 
2944     def __iter__(self, *args, **kwargs): # real signature unknown
2945         """ Implement iter(self). """
2946         pass
2947 
2948     @staticmethod # known case of __new__
2949     def __new__(*args, **kwargs): # real signature unknown
2950         """ Create and return a new object.  See help(type) for accurate signature. """
2951         pass
2952 
2953     def __next__(self, *args, **kwargs): # real signature unknown
2954         """ Implement next(self). """
2955         pass
2956 
2957     def __reduce__(self, *args, **kwargs): # real signature unknown
2958         """ Return state information for pickling. """
2959         pass
2960 
2961 
2962 class EOFError(Exception):
2963     """ Read beyond end of file. """
2964     def __init__(self, *args, **kwargs): # real signature unknown
2965         pass
2966 
2967     @staticmethod # known case of __new__
2968     def __new__(*args, **kwargs): # real signature unknown
2969         """ Create and return a new object.  See help(type) for accurate signature. """
2970         pass
2971 
2972 
2973 class FileExistsError(OSError):
2974     """ File already exists. """
2975     def __init__(self, *args, **kwargs): # real signature unknown
2976         pass
2977 
2978 
2979 class FileNotFoundError(OSError):
2980     """ File not found. """
2981     def __init__(self, *args, **kwargs): # real signature unknown
2982         pass
2983 
2984 
2985 class filter(object):
2986     """
2987     filter(function or None, iterable) --> filter object
2988     
2989     Return an iterator yielding those items of iterable for which function(item)
2990     is true. If function is None, return the items that are true.
2991     """
2992     def __getattribute__(self, *args, **kwargs): # real signature unknown
2993         """ Return getattr(self, name). """
2994         pass
2995 
2996     def __init__(self, function_or_None, iterable): # real signature unknown; restored from __doc__
2997         pass
2998 
2999     def __iter__(self, *args, **kwargs): # real signature unknown
3000         """ Implement iter(self). """
3001         pass
3002 
3003     @staticmethod # known case of __new__
3004     def __new__(*args, **kwargs): # real signature unknown
3005         """ Create and return a new object.  See help(type) for accurate signature. """
3006         pass
3007 
3008     def __next__(self, *args, **kwargs): # real signature unknown
3009         """ Implement next(self). """
3010         pass
3011 
3012     def __reduce__(self, *args, **kwargs): # real signature unknown
3013         """ Return state information for pickling. """
3014         pass
3015 
3016 
3017 class float(object):
3018     """
3019     float(x) -> floating point number
3020     
3021     Convert a string or number to a floating point number, if possible.
3022     """
3023     def as_integer_ratio(self): # real signature unknown; restored from __doc__
3024         """
3025         float.as_integer_ratio() -> (int, int)
3026         
3027         Return a pair of integers, whose ratio is exactly equal to the original
3028         float and with a positive denominator.
3029         Raise OverflowError on infinities and a ValueError on NaNs.
3030         
3031         >>> (10.0).as_integer_ratio()
3032         (10, 1)
3033         >>> (0.0).as_integer_ratio()
3034         (0, 1)
3035         >>> (-.25).as_integer_ratio()
3036         (-1, 4)
3037         """
3038         pass
3039 
3040     def conjugate(self, *args, **kwargs): # real signature unknown
3041         """ Return self, the complex conjugate of any float. """
3042         pass
3043 
3044     @staticmethod # known case
3045     def fromhex(string): # real signature unknown; restored from __doc__
3046         """
3047         float.fromhex(string) -> float
3048         
3049         Create a floating-point number from a hexadecimal string.
3050         >>> float.fromhex(‘0x1.ffffp10‘)
3051         2047.984375
3052         >>> float.fromhex(‘-0x1p-1074‘)
3053         -5e-324
3054         """
3055         return 0.0
3056 
3057     def hex(self): # real signature unknown; restored from __doc__
3058         """
3059         float.hex() -> string
3060         
3061         Return a hexadecimal representation of a floating-point number.
3062         >>> (-0.1).hex()
3063         ‘-0x1.999999999999ap-4‘
3064         >>> 3.14159.hex()
3065         ‘0x1.921f9f01b866ep+1‘
3066         """
3067         return ""
3068 
3069     def is_integer(self, *args, **kwargs): # real signature unknown
3070         """ Return True if the float is an integer. """
3071         pass
3072 
3073     def __abs__(self, *args, **kwargs): # real signature unknown
3074         """ abs(self) """
3075         pass
3076 
3077     def __add__(self, *args, **kwargs): # real signature unknown
3078         """ Return self+value. """
3079         pass
3080 
3081     def __bool__(self, *args, **kwargs): # real signature unknown
3082         """ self != 0 """
3083         pass
3084 
3085     def __divmod__(self, *args, **kwargs): # real signature unknown
3086         """ Return divmod(self, value). """
3087         pass
3088 
3089     def __eq__(self, *args, **kwargs): # real signature unknown
3090         """ Return self==value. """
3091         pass
3092 
3093     def __float__(self, *args, **kwargs): # real signature unknown
3094         """ float(self) """
3095         pass
3096 
3097     def __floordiv__(self, *args, **kwargs): # real signature unknown
3098         """ Return self//value. """
3099         pass
3100 
3101     def __format__(self, format_spec): # real signature unknown; restored from __doc__
3102         """
3103         float.__format__(format_spec) -> string
3104         
3105         Formats the float according to format_spec.
3106         """
3107         return ""
3108 
3109     def __getattribute__(self, *args, **kwargs): # real signature unknown
3110         """ Return getattr(self, name). """
3111         pass
3112 
3113     def __getformat__(self, typestr): # real signature unknown; restored from __doc__
3114         """
3115         float.__getformat__(typestr) -> string
3116         
3117         You probably don‘t want to use this function.  It exists mainly to be
3118         used in Python‘s test suite.
3119         
3120         typestr must be ‘double‘ or ‘float‘.  This function returns whichever of
3121         ‘unknown‘, ‘IEEE, big-endian‘ or ‘IEEE, little-endian‘ best describes the
3122         format of floating point numbers used by the C type named by typestr.
3123         """
3124         return ""
3125 
3126     def __getnewargs__(self, *args, **kwargs): # real signature unknown
3127         pass
3128 
3129     def __ge__(self, *args, **kwargs): # real signature unknown
3130         """ Return self>=value. """
3131         pass
3132 
3133     def __gt__(self, *args, **kwargs): # real signature unknown
3134         """ Return self>value. """
3135         pass
3136 
3137     def __hash__(self, *args, **kwargs): # real signature unknown
3138         """ Return hash(self). """
3139         pass
3140 
3141     def __init__(self, x): # real signature unknown; restored from __doc__
3142         pass
3143 
3144     def __int__(self, *args, **kwargs): # real signature unknown
3145         """ int(self) """
3146         pass
3147 
3148     def __le__(self, *args, **kwargs): # real signature unknown
3149         """ Return self<=value. """
3150         pass
3151 
3152     def __lt__(self, *args, **kwargs): # real signature unknown
3153         """ Return self<value. """
3154         pass
3155 
3156     def __mod__(self, *args, **kwargs): # real signature unknown
3157         """ Return self%value. """
3158         pass
3159 
3160     def __mul__(self, *args, **kwargs): # real signature unknown
3161         """ Return self*value. """
3162         pass
3163 
3164     def __neg__(self, *args, **kwargs): # real signature unknown
3165         """ -self """
3166         pass
3167 
3168     @staticmethod # known case of __new__
3169     def __new__(*args, **kwargs): # real signature unknown
3170         """ Create and return a new object.  See help(type) for accurate signature. """
3171         pass
3172 
3173     def __ne__(self, *args, **kwargs): # real signature unknown
3174         """ Return self!=value. """
3175         pass
3176 
3177     def __pos__(self, *args, **kwargs): # real signature unknown
3178         """ +self """
3179         pass
3180 
3181     def __pow__(self, *args, **kwargs): # real signature unknown
3182         """ Return pow(self, value, mod). """
3183         pass
3184 
3185     def __radd__(self, *args, **kwargs): # real signature unknown
3186         """ Return value+self. """
3187         pass
3188 
3189     def __rdivmod__(self, *args, **kwargs): # real signature unknown
3190         """ Return divmod(value, self). """
3191         pass
3192 
3193     def __repr__(self, *args, **kwargs): # real signature unknown
3194         """ Return repr(self). """
3195         pass
3196 
3197     def __rfloordiv__(self, *args, **kwargs): # real signature unknown
3198         """ Return value//self. """
3199         pass
3200 
3201     def __rmod__(self, *args, **kwargs): # real signature unknown
3202         """ Return value%self. """
3203         pass
3204 
3205     def __rmul__(self, *args, **kwargs): # real signature unknown
3206         """ Return value*self. """
3207         pass
3208 
3209     def __round__(self, *args, **kwargs): # real signature unknown
3210         """
3211         Return the Integral closest to x, rounding half toward even.
3212         When an argument is passed, work like built-in round(x, ndigits).
3213         """
3214         pass
3215 
3216     def __rpow__(self, *args, **kwargs): # real signature unknown
3217         """ Return pow(value, self, mod). """
3218         pass
3219 
3220     def __rsub__(self, *args, **kwargs): # real signature unknown
3221         """ Return value-self. """
3222         pass
3223 
3224     def __rtruediv__(self, *args, **kwargs): # real signature unknown
3225         """ Return value/self. """
3226         pass
3227 
3228     def __setformat__(self, typestr, fmt): # real signature unknown; restored from __doc__
3229         """
3230         float.__setformat__(typestr, fmt) -> None
3231         
3232         You probably don‘t want to use this function.  It exists mainly to be
3233         used in Python‘s test suite.
3234         
3235         typestr must be ‘double‘ or ‘float‘.  fmt must be one of ‘unknown‘,
3236         ‘IEEE, big-endian‘ or ‘IEEE, little-endian‘, and in addition can only be
3237         one of the latter two if it appears to match the underlying C reality.
3238         
3239         Override the automatic determination of C-level floating point type.
3240         This affects how floats are converted to and from binary strings.
3241         """
3242         pass
3243 
3244     def __str__(self, *args, **kwargs): # real signature unknown
3245         """ Return str(self). """
3246         pass
3247 
3248     def __sub__(self, *args, **kwargs): # real signature unknown
3249         """ Return self-value. """
3250         pass
3251 
3252     def __truediv__(self, *args, **kwargs): # real signature unknown
3253         """ Return self/value. """
3254         pass
3255 
3256     def __trunc__(self, *args, **kwargs): # real signature unknown
3257         """ Return the Integral closest to x between 0 and x. """
3258         pass
3259 
3260     imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3261     """the imaginary part of a complex number"""
3262 
3263     real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3264     """the real part of a complex number"""
3265 
3266 
3267 
3268 class FloatingPointError(ArithmeticError):
3269     """ Floating point operation failed. """
3270     def __init__(self, *args, **kwargs): # real signature unknown
3271         pass
3272 
3273     @staticmethod # known case of __new__
3274     def __new__(*args, **kwargs): # real signature unknown
3275         """ Create and return a new object.  See help(type) for accurate signature. """
3276         pass
3277 
3278 
3279 class frozenset(object):
3280     """
3281     frozenset() -> empty frozenset object
3282     frozenset(iterable) -> frozenset object
3283     
3284     Build an immutable unordered collection of unique elements.
3285     """
3286     def copy(self, *args, **kwargs): # real signature unknown
3287         """ Return a shallow copy of a set. """
3288         pass
3289 
3290     def difference(self, *args, **kwargs): # real signature unknown
3291         """
3292         Return the difference of two or more sets as a new set.
3293         
3294         (i.e. all elements that are in this set but not the others.)
3295         """
3296         pass
3297 
3298     def intersection(self, *args, **kwargs): # real signature unknown
3299         """
3300         Return the intersection of two sets as a new set.
3301         
3302         (i.e. all elements that are in both sets.)
3303         """
3304         pass
3305 
3306     def isdisjoint(self, *args, **kwargs): # real signature unknown
3307         """ Return True if two sets have a null intersection. """
3308         pass
3309 
3310     def issubset(self, *args, **kwargs): # real signature unknown
3311         """ Report whether another set contains this set. """
3312         pass
3313 
3314     def issuperset(self, *args, **kwargs): # real signature unknown
3315         """ Report whether this set contains another set. """
3316         pass
3317 
3318     def symmetric_difference(self, *args, **kwargs): # real signature unknown
3319         """
3320         Return the symmetric difference of two sets as a new set.
3321         
3322         (i.e. all elements that are in exactly one of the sets.)
3323         """
3324         pass
3325 
3326     def union(self, *args, **kwargs): # real signature unknown
3327         """
3328         Return the union of sets as a new set.
3329         
3330         (i.e. all elements that are in either set.)
3331         """
3332         pass
3333 
3334     def __and__(self, *args, **kwargs): # real signature unknown
3335         """ Return self&value. """
3336         pass
3337 
3338     def __contains__(self, y): # real signature unknown; restored from __doc__
3339         """ x.__contains__(y) <==> y in x. """
3340         pass
3341 
3342     def __eq__(self, *args, **kwargs): # real signature unknown
3343         """ Return self==value. """
3344         pass
3345 
3346     def __getattribute__(self, *args, **kwargs): # real signature unknown
3347         """ Return getattr(self, name). """
3348         pass
3349 
3350     def __ge__(self, *args, **kwargs): # real signature unknown
3351         """ Return self>=value. """
3352         pass
3353 
3354     def __gt__(self, *args, **kwargs): # real signature unknown
3355         """ Return self>value. """
3356         pass
3357 
3358     def __hash__(self, *args, **kwargs): # real signature unknown
3359         """ Return hash(self). """
3360         pass
3361 
3362     def __init__(self, seq=()): # known special case of frozenset.__init__
3363         """ Initialize self.  See help(type(self)) for accurate signature. """
3364         pass
3365 
3366     def __iter__(self, *args, **kwargs): # real signature unknown
3367         """ Implement iter(self). """
3368         pass
3369 
3370     def __len__(self, *args, **kwargs): # real signature unknown
3371         """ Return len(self). """
3372         pass
3373 
3374     def __le__(self, *args, **kwargs): # real signature unknown
3375         """ Return self<=value. """
3376         pass
3377 
3378     def __lt__(self, *args, **kwargs): # real signature unknown
3379         """ Return self<value. """
3380         pass
3381 
3382     @staticmethod # known case of __new__
3383     def __new__(*args, **kwargs): # real signature unknown
3384         """ Create and return a new object.  See help(type) for accurate signature. """
3385         pass
3386 
3387     def __ne__(self, *args, **kwargs): # real signature unknown
3388         """ Return self!=value. """
3389         pass
3390 
3391     def __or__(self, *args, **kwargs): # real signature unknown
3392         """ Return self|value. """
3393         pass
3394 
3395     def __rand__(self, *args, **kwargs): # real signature unknown
3396         """ Return value&self. """
3397         pass
3398 
3399     def __reduce__(self, *args, **kwargs): # real signature unknown
3400         """ Return state information for pickling. """
3401         pass
3402 
3403     def __repr__(self, *args, **kwargs): # real signature unknown
3404         """ Return repr(self). """
3405         pass
3406 
3407     def __ror__(self, *args, **kwargs): # real signature unknown
3408         """ Return value|self. """
3409         pass
3410 
3411     def __rsub__(self, *args, **kwargs): # real signature unknown
3412         """ Return value-self. """
3413         pass
3414 
3415     def __rxor__(self, *args, **kwargs): # real signature unknown
3416         """ Return value^self. """
3417         pass
3418 
3419     def __sizeof__(self): # real signature unknown; restored from __doc__
3420         """ S.__sizeof__() -> size of S in memory, in bytes """
3421         pass
3422 
3423     def __sub__(self, *args, **kwargs): # real signature unknown
3424         """ Return self-value. """
3425         pass
3426 
3427     def __xor__(self, *args, **kwargs): # real signature unknown
3428         """ Return self^value. """
3429         pass
3430 
3431 
3432 class FutureWarning(Warning):
3433     """
3434     Base class for warnings about constructs that will change semantically
3435     in the future.
3436     """
3437     def __init__(self, *args, **kwargs): # real signature unknown
3438         pass
3439 
3440     @staticmethod # known case of __new__
3441     def __new__(*args, **kwargs): # real signature unknown
3442         """ Create and return a new object.  See help(type) for accurate signature. """
3443         pass
3444 
3445 
3446 class GeneratorExit(BaseException):
3447     """ Request that a generator exit. """
3448     def __init__(self, *args, **kwargs): # real signature unknown
3449         pass
3450 
3451     @staticmethod # known case of __new__
3452     def __new__(*args, **kwargs): # real signature unknown
3453         """ Create and return a new object.  See help(type) for accurate signature. """
3454         pass
3455 
3456 
3457 class ImportError(Exception):
3458     """ Import can‘t find module, or can‘t find name in module. """
3459     def __init__(self, *args, **kwargs): # real signature unknown
3460         pass
3461 
3462     def __str__(self, *args, **kwargs): # real signature unknown
3463         """ Return str(self). """
3464         pass
3465 
3466     msg = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3467     """exception message"""
3468 
3469     name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3470     """module name"""
3471 
3472     path = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3473     """module path"""
3474 
3475 
3476 
3477 class ImportWarning(Warning):
3478     """ Base class for warnings about probable mistakes in module imports """
3479     def __init__(self, *args, **kwargs): # real signature unknown
3480         pass
3481 
3482     @staticmethod # known case of __new__
3483     def __new__(*args, **kwargs): # real signature unknown
3484         """ Create and return a new object.  See help(type) for accurate signature. """
3485         pass
3486 
3487 
3488 class SyntaxError(Exception):
3489     """ Invalid syntax. """
3490     def __init__(self, *args, **kwargs): # real signature unknown
3491         pass
3492 
3493     def __str__(self, *args, **kwargs): # real signature unknown
3494         """ Return str(self). """
3495         pass
3496 
3497     filename = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3498     """exception filename"""
3499 
3500     lineno = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3501     """exception lineno"""
3502 
3503     msg = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3504     """exception msg"""
3505 
3506     offset = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3507     """exception offset"""
3508 
3509     print_file_and_line = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3510     """exception print_file_and_line"""
3511 
3512     text = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3513     """exception text"""
3514 
3515 
3516 
3517 class IndentationError(SyntaxError):
3518     """ Improper indentation. """
3519     def __init__(self, *args, **kwargs): # real signature unknown
3520         pass
3521 
3522 
3523 class LookupError(Exception):
3524     """ Base class for lookup errors. """
3525     def __init__(self, *args, **kwargs): # real signature unknown
3526         pass
3527 
3528     @staticmethod # known case of __new__
3529     def __new__(*args, **kwargs): # real signature unknown
3530         """ Create and return a new object.  See help(type) for accurate signature. """
3531         pass
3532 
3533 
3534 class IndexError(LookupError):
3535     """ Sequence index out of range. """
3536     def __init__(self, *args, **kwargs): # real signature unknown
3537         pass
3538 
3539     @staticmethod # known case of __new__
3540     def __new__(*args, **kwargs): # real signature unknown
3541         """ Create and return a new object.  See help(type) for accurate signature. """
3542         pass
3543 
3544 
3545 class InterruptedError(OSError):
3546     """ Interrupted by signal. """
3547     def __init__(self, *args, **kwargs): # real signature unknown
3548         pass
3549 
3550 
3551 class IsADirectoryError(OSError):
3552     """ Operation doesn‘t work on directories. """
3553     def __init__(self, *args, **kwargs): # real signature unknown
3554         pass
3555 
3556 
3557 class KeyboardInterrupt(BaseException):
3558     """ Program interrupted by user. """
3559     def __init__(self, *args, **kwargs): # real signature unknown
3560         pass
3561 
3562     @staticmethod # known case of __new__
3563     def __new__(*args, **kwargs): # real signature unknown
3564         """ Create and return a new object.  See help(type) for accurate signature. """
3565         pass
3566 
3567 
3568 class KeyError(LookupError):
3569     """ Mapping key not found. """
3570     def __init__(self, *args, **kwargs): # real signature unknown
3571         pass
3572 
3573     def __str__(self, *args, **kwargs): # real signature unknown
3574         """ Return str(self). """
3575         pass
3576 
3577 
3578 class list(object):
3579     """
3580     list() -> new empty list
3581     list(iterable) -> new list initialized from iterable‘s items
3582     """
3583     def append(self, p_object): # real signature unknown; restored from __doc__
3584         """ L.append(object) -> None -- append object to end """
3585         pass
3586 
3587     def clear(self): # real signature unknown; restored from __doc__
3588         """ L.clear() -> None -- remove all items from L """
3589         pass
3590 
3591     def copy(self): # real signature unknown; restored from __doc__
3592         """ L.copy() -> list -- a shallow copy of L """
3593         return []
3594 
3595     def count(self, value): # real signature unknown; restored from __doc__
3596         """ L.count(value) -> integer -- return number of occurrences of value """
3597         return 0
3598 
3599     def extend(self, iterable): # real signature unknown; restored from __doc__
3600         """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """
3601         pass
3602 
3603     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
3604         """
3605         L.index(value, [start, [stop]]) -> integer -- return first index of value.
3606         Raises ValueError if the value is not present.
3607         """
3608         return 0
3609 
3610     def insert(self, index, p_object): # real signature unknown; restored from __doc__
3611         """ L.insert(index, object) -- insert object before index """
3612         pass
3613 
3614     def pop(self, index=None): # real signature unknown; restored from __doc__
3615         """
3616         L.pop([index]) -> item -- remove and return item at index (default last).
3617         Raises IndexError if list is empty or index is out of range.
3618         """
3619         pass
3620 
3621     def remove(self, value): # real signature unknown; restored from __doc__
3622         """
3623         L.remove(value) -> None -- remove first occurrence of value.
3624         Raises ValueError if the value is not present.
3625         """
3626         pass
3627 
3628     def reverse(self): # real signature unknown; restored from __doc__
3629         """ L.reverse() -- reverse *IN PLACE* """
3630         pass
3631 
3632     def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
3633         """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
3634         pass
3635 
3636     def __add__(self, *args, **kwargs): # real signature unknown
3637         """ Return self+value. """
3638         pass
3639 
3640     def __contains__(self, *args, **kwargs): # real signature unknown
3641         """ Return key in self. """
3642         pass
3643 
3644     def __delitem__(self, *args, **kwargs): # real signature unknown
3645         """ Delete self[key]. """
3646         pass
3647 
3648     def __eq__(self, *args, **kwargs): # real signature unknown
3649         """ Return self==value. """
3650         pass
3651 
3652     def __getattribute__(self, *args, **kwargs): # real signature unknown
3653         """ Return getattr(self, name). """
3654         pass
3655 
3656     def __getitem__(self, y): # real signature unknown; restored from __doc__
3657         """ x.__getitem__(y) <==> x[y] """
3658         pass
3659 
3660     def __ge__(self, *args, **kwargs): # real signature unknown
3661         """ Return self>=value. """
3662         pass
3663 
3664     def __gt__(self, *args, **kwargs): # real signature unknown
3665         """ Return self>value. """
3666         pass
3667 
3668     def __iadd__(self, *args, **kwargs): # real signature unknown
3669         """ Implement self+=value. """
3670         pass
3671 
3672     def __imul__(self, *args, **kwargs): # real signature unknown
3673         """ Implement self*=value. """
3674         pass
3675 
3676     def __init__(self, seq=()): # known special case of list.__init__
3677         """
3678         list() -> new empty list
3679         list(iterable) -> new list initialized from iterable‘s items
3680         # (copied from class doc)
3681         """
3682         pass
3683 
3684     def __iter__(self, *args, **kwargs): # real signature unknown
3685         """ Implement iter(self). """
3686         pass
3687 
3688     def __len__(self, *args, **kwargs): # real signature unknown
3689         """ Return len(self). """
3690         pass
3691 
3692     def __le__(self, *args, **kwargs): # real signature unknown
3693         """ Return self<=value. """
3694         pass
3695 
3696     def __lt__(self, *args, **kwargs): # real signature unknown
3697         """ Return self<value. """
3698         pass
3699 
3700     def __mul__(self, *args, **kwargs): # real signature unknown
3701         """ Return self*value.n """
3702         pass
3703 
3704     @staticmethod # known case of __new__
3705     def __new__(*args, **kwargs): # real signature unknown
3706         """ Create and return a new object.  See help(type) for accurate signature. """
3707         pass
3708 
3709     def __ne__(self, *args, **kwargs): # real signature unknown
3710         """ Return self!=value. """
3711         pass
3712 
3713     def __repr__(self, *args, **kwargs): # real signature unknown
3714         """ Return repr(self). """
3715         pass
3716 
3717     def __reversed__(self): # real signature unknown; restored from __doc__
3718         """ L.__reversed__() -- return a reverse iterator over the list """
3719         pass
3720 
3721     def __rmul__(self, *args, **kwargs): # real signature unknown
3722         """ Return self*value. """
3723         pass
3724 
3725     def __setitem__(self, *args, **kwargs): # real signature unknown
3726         """ Set self[key] to value. """
3727         pass
3728 
3729     def __sizeof__(self): # real signature unknown; restored from __doc__
3730         """ L.__sizeof__() -- size of L in memory, in bytes """
3731         pass
3732 
3733     __hash__ = None
3734 
3735 
3736 class map(object):
3737     """
3738     map(func, *iterables) --> map object
3739     
3740     Make an iterator that computes the function using arguments from
3741     each of the iterables.  Stops when the shortest iterable is exhausted.
3742     """
3743     def __getattribute__(self, *args, **kwargs): # real signature unknown
3744         """ Return getattr(self, name). """
3745         pass
3746 
3747     def __init__(self, func, *iterables): # real signature unknown; restored from __doc__
3748         pass
3749 
3750     def __iter__(self, *args, **kwargs): # real signature unknown
3751         """ Implement iter(self). """
3752         pass
3753 
3754     @staticmethod # known case of __new__
3755     def __new__(*args, **kwargs): # real signature unknown
3756         """ Create and return a new object.  See help(type) for accurate signature. """
3757         pass
3758 
3759     def __next__(self, *args, **kwargs): # real signature unknown
3760         """ Implement next(self). """
3761         pass
3762 
3763     def __reduce__(self, *args, **kwargs): # real signature unknown
3764         """ Return state information for pickling. """
3765         pass
3766 
3767 
3768 class MemoryError(Exception):
3769     """ Out of memory. """
3770     def __init__(self, *args, **kwargs): # real signature unknown
3771         pass
3772 
3773     @staticmethod # known case of __new__
3774     def __new__(*args, **kwargs): # real signature unknown
3775         """ Create and return a new object.  See help(type) for accurate signature. """
3776         pass
3777 
3778 
3779 class memoryview(object):
3780     """ Create a new memoryview object which references the given object. """
3781     def cast(self, *args, **kwargs): # real signature unknown
3782         """ Cast a memoryview to a new format or shape. """
3783         pass
3784 
3785     def hex(self, *args, **kwargs): # real signature unknown
3786         """ Return the data in the buffer as a string of hexadecimal numbers. """
3787         pass
3788 
3789     def release(self, *args, **kwargs): # real signature unknown
3790         """ Release the underlying buffer exposed by the memoryview object. """
3791         pass
3792 
3793     def tobytes(self, *args, **kwargs): # real signature unknown
3794         """ Return the data in the buffer as a byte string. """
3795         pass
3796 
3797     def tolist(self, *args, **kwargs): # real signature unknown
3798         """ Return the data in the buffer as a list of elements. """
3799         pass
3800 
3801     def __delitem__(self, *args, **kwargs): # real signature unknown
3802         """ Delete self[key]. """
3803         pass
3804 
3805     def __enter__(self, *args, **kwargs): # real signature unknown
3806         pass
3807 
3808     def __eq__(self, *args, **kwargs): # real signature unknown
3809         """ Return self==value. """
3810         pass
3811 
3812     def __exit__(self, *args, **kwargs): # real signature unknown
3813         pass
3814 
3815     def __getattribute__(self, *args, **kwargs): # real signature unknown
3816         """ Return getattr(self, name). """
3817         pass
3818 
3819     def __getitem__(self, *args, **kwargs): # real signature unknown
3820         """ Return self[key]. """
3821         pass
3822 
3823     def __ge__(self, *args, **kwargs): # real signature unknown
3824         """ Return self>=value. """
3825         pass
3826 
3827     def __gt__(self, *args, **kwargs): # real signature unknown
3828         """ Return self>value. """
3829         pass
3830 
3831     def __hash__(self, *args, **kwargs): # real signature unknown
3832         """ Return hash(self). """
3833         pass
3834 
3835     def __init__(self, *args, **kwargs): # real signature unknown
3836         pass
3837 
3838     def __len__(self, *args, **kwargs): # real signature unknown
3839         """ Return len(self). """
3840         pass
3841 
3842     def __le__(self, *args, **kwargs): # real signature unknown
3843         """ Return self<=value. """
3844         pass
3845 
3846     def __lt__(self, *args, **kwargs): # real signature unknown
3847         """ Return self<value. """
3848         pass
3849 
3850     @staticmethod # known case of __new__
3851     def __new__(*args, **kwargs): # real signature unknown
3852         """ Create and return a new object.  See help(type) for accurate signature. """
3853         pass
3854 
3855     def __ne__(self, *args, **kwargs): # real signature unknown
3856         """ Return self!=value. """
3857         pass
3858 
3859     def __repr__(self, *args, **kwargs): # real signature unknown
3860         """ Return repr(self). """
3861         pass
3862 
3863     def __setitem__(self, *args, **kwargs): # real signature unknown
3864         """ Set self[key] to value. """
3865         pass
3866 
3867     contiguous = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3868     """A bool indicating whether the memory is contiguous."""
3869 
3870     c_contiguous = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3871     """A bool indicating whether the memory is C contiguous."""
3872 
3873     format = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3874     """A string containing the format (in struct module style)
3875  for each element in the view."""
3876 
3877     f_contiguous = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3878     """A bool indicating whether the memory is Fortran contiguous."""
3879 
3880     itemsize = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3881     """The size in bytes of each element of the memoryview."""
3882 
3883     nbytes = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3884     """The amount of space in bytes that the array would use in
3885  a contiguous representation."""
3886 
3887     ndim = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3888     """An integer indicating how many dimensions of a multi-dimensional
3889  array the memory represents."""
3890 
3891     obj = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3892     """The underlying object of the memoryview."""
3893 
3894     readonly = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3895     """A bool indicating whether the memory is read only."""
3896 
3897     shape = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3898     """A tuple of ndim integers giving the shape of the memory
3899  as an N-dimensional array."""
3900 
3901     strides = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3902     """A tuple of ndim integers giving the size in bytes to access
3903  each element for each dimension of the array."""
3904 
3905     suboffsets = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3906     """A tuple of integers used internally for PIL-style arrays."""
3907 
3908 
3909 
3910 class ModuleNotFoundError(ImportError):
3911     """ Module not found. """
3912     def __init__(self, *args, **kwargs): # real signature unknown
3913         pass
3914 
3915 
3916 class NameError(Exception):
3917     """ Name not found globally. """
3918     def __init__(self, *args, **kwargs): # real signature unknown
3919         pass
3920 
3921     @staticmethod # known case of __new__
3922     def __new__(*args, **kwargs): # real signature unknown
3923         """ Create and return a new object.  See help(type) for accurate signature. """
3924         pass
3925 
3926 
3927 class NotADirectoryError(OSError):
3928     """ Operation only works on directories. """
3929     def __init__(self, *args, **kwargs): # real signature unknown
3930         pass
3931 
3932 
3933 class RuntimeError(Exception):
3934     """ Unspecified run-time error. """
3935     def __init__(self, *args, **kwargs): # real signature unknown
3936         pass
3937 
3938     @staticmethod # known case of __new__
3939     def __new__(*args, **kwargs): # real signature unknown
3940         """ Create and return a new object.  See help(type) for accurate signature. """
3941         pass
3942 
3943 
3944 class NotImplementedError(RuntimeError):
3945     """ Method or function hasn‘t been implemented yet. """
3946     def __init__(self, *args, **kwargs): # real signature unknown
3947         pass
3948 
3949     @staticmethod # known case of __new__
3950     def __new__(*args, **kwargs): # real signature unknown
3951         """ Create and return a new object.  See help(type) for accurate signature. """
3952         pass
3953 
3954 
3955 class OverflowError(ArithmeticError):
3956     """ Result too large to be represented. """
3957     def __init__(self, *args, **kwargs): # real signature unknown
3958         pass
3959 
3960     @staticmethod # known case of __new__
3961     def __new__(*args, **kwargs): # real signature unknown
3962         """ Create and return a new object.  See help(type) for accurate signature. """
3963         pass
3964 
3965 
3966 class PendingDeprecationWarning(Warning):
3967     """
3968     Base class for warnings about features which will be deprecated
3969     in the future.
3970     """
3971     def __init__(self, *args, **kwargs): # real signature unknown
3972         pass
3973 
3974     @staticmethod # known case of __new__
3975     def __new__(*args, **kwargs): # real signature unknown
3976         """ Create and return a new object.  See help(type) for accurate signature. """
3977         pass
3978 
3979 
3980 class PermissionError(OSError):
3981     """ Not enough permissions. """
3982     def __init__(self, *args, **kwargs): # real signature unknown
3983         pass
3984 
3985 
3986 class ProcessLookupError(OSError):
3987     """ Process not found. """
3988     def __init__(self, *args, **kwargs): # real signature unknown
3989         pass
3990 
3991 
3992 class property(object):
3993     """
3994     property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
3995     
3996     fget is a function to be used for getting an attribute value, and likewise
3997     fset is a function for setting, and fdel a function for del‘ing, an
3998     attribute.  Typical use is to define a managed attribute x:
3999     
4000     class C(object):
4001         def getx(self): return self._x
4002         def setx(self, value): self._x = value
4003         def delx(self): del self._x
4004         x = property(getx, setx, delx, "I‘m the ‘x‘ property.")
4005     
4006     Decorators make defining new properties or modifying existing ones easy:
4007     
4008     class C(object):
4009         @property
4010         def x(self):
4011             "I am the ‘x‘ property."
4012             return self._x
4013         @x.setter
4014         def x(self, value):
4015             self._x = value
4016         @x.deleter
4017         def x(self):
4018             del self._x
4019     """
4020     def deleter(self, *args, **kwargs): # real signature unknown
4021         """ Descriptor to change the deleter on a property. """
4022         pass
4023 
4024     def getter(self, *args, **kwargs): # real signature unknown
4025         """ Descriptor to change the getter on a property. """
4026         pass
4027 
4028     def setter(self, *args, **kwargs): # real signature unknown
4029         """ Descriptor to change the setter on a property. """
4030         pass
4031 
4032     def __delete__(self, *args, **kwargs): # real signature unknown
4033         """ Delete an attribute of instance. """
4034         pass
4035 
4036     def __getattribute__(self, *args, **kwargs): # real signature unknown
4037         """ Return getattr(self, name). """
4038         pass
4039 
4040     def __get__(self, *args, **kwargs): # real signature unknown
4041         """ Return an attribute of instance, which is of type owner. """
4042         pass
4043 
4044     def __init__(self, fget=None, fset=None, fdel=None, doc=None): # known special case of property.__init__
4045         """
4046         property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
4047         
4048         fget is a function to be used for getting an attribute value, and likewise
4049         fset is a function for setting, and fdel a function for del‘ing, an
4050         attribute.  Typical use is to define a managed attribute x:
4051         
4052         class C(object):
4053             def getx(self): return self._x
4054             def setx(self, value): self._x = value
4055             def delx(self): del self._x
4056             x = property(getx, setx, delx, "I‘m the ‘x‘ property.")
4057         
4058         Decorators make defining new properties or modifying existing ones easy:
4059         
4060         class C(object):
4061             @property
4062             def x(self):
4063                 "I am the ‘x‘ property."
4064                 return self._x
4065             @x.setter
4066             def x(self, value):
4067                 self._x = value
4068             @x.deleter
4069             def x(self):
4070                 del self._x
4071         
4072         # (copied from class doc)
4073         """
4074         pass
4075 
4076     @staticmethod # known case of __new__
4077     def __new__(*args, **kwargs): # real signature unknown
4078         """ Create and return a new object.  See help(type) for accurate signature. """
4079         pass
4080 
4081     def __set__(self, *args, **kwargs): # real signature unknown
4082         """ Set an attribute of instance to value. """
4083         pass
4084 
4085     fdel = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4086 
4087     fget = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4088 
4089     fset = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4090 
4091     __isabstractmethod__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4092 
4093 
4094 
4095 class range(object):
4096     """
4097     range(stop) -> range object
4098     range(start, stop[, step]) -> range object
4099     
4100     Return an object that produces a sequence of integers from start (inclusive)
4101     to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
4102     start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
4103     These are exactly the valid indices for a list of 4 elements.
4104     When step is given, it specifies the increment (or decrement).
4105     """
4106     def count(self, value): # real signature unknown; restored from __doc__
4107         """ rangeobject.count(value) -> integer -- return number of occurrences of value """
4108         return 0
4109 
4110     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
4111         """
4112         rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
4113         Raise ValueError if the value is not present.
4114         """
4115         return 0
4116 
4117     def __contains__(self, *args, **kwargs): # real signature unknown
4118         """ Return key in self. """
4119         pass
4120 
4121     def __eq__(self, *args, **kwargs): # real signature unknown
4122         """ Return self==value. """
4123         pass
4124 
4125     def __getattribute__(self, *args, **kwargs): # real signature unknown
4126         """ Return getattr(self, name). """
4127         pass
4128 
4129     def __getitem__(self, *args, **kwargs): # real signature unknown
4130         """ Return self[key]. """
4131         pass
4132 
4133     def __ge__(self, *args, **kwargs): # real signature unknown
4134         """ Return self>=value. """
4135         pass
4136 
4137     def __gt__(self, *args, **kwargs): # real signature unknown
4138         """ Return self>value. """
4139         pass
4140 
4141     def __hash__(self, *args, **kwargs): # real signature unknown
4142         """ Return hash(self). """
4143         pass
4144 
4145     def __init__(self, stop): # real signature unknown; restored from __doc__
4146         pass
4147 
4148     def __iter__(self, *args, **kwargs): # real signature unknown
4149         """ Implement iter(self). """
4150         pass
4151 
4152     def __len__(self, *args, **kwargs): # real signature unknown
4153         """ Return len(self). """
4154         pass
4155 
4156     def __le__(self, *args, **kwargs): # real signature unknown
4157         """ Return self<=value. """
4158         pass
4159 
4160     def __lt__(self, *args, **kwargs): # real signature unknown
4161         """ Return self<value. """
4162         pass
4163 
4164     @staticmethod # known case of __new__
4165     def __new__(*args, **kwargs): # real signature unknown
4166         """ Create and return a new object.  See help(type) for accurate signature. """
4167         pass
4168 
4169     def __ne__(self, *args, **kwargs): # real signature unknown
4170         """ Return self!=value. """
4171         pass
4172 
4173     def __reduce__(self, *args, **kwargs): # real signature unknown
4174         pass
4175 
4176     def __repr__(self, *args, **kwargs): # real signature unknown
4177         """ Return repr(self). """
4178         pass
4179 
4180     def __reversed__(self, *args, **kwargs): # real signature unknown
4181         """ Return a reverse iterator. """
4182         pass
4183 
4184     start = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4185 
4186     step = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4187 
4188     stop = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4189 
4190 
4191 
4192 class RecursionError(RuntimeError):
4193     """ Recursion limit exceeded. """
4194     def __init__(self, *args, **kwargs): # real signature unknown
4195         pass
4196 
4197     @staticmethod # known case of __new__
4198     def __new__(*args, **kwargs): # real signature unknown
4199         """ Create and return a new object.  See help(type) for accurate signature. """
4200         pass
4201 
4202 
4203 class ReferenceError(Exception):
4204     """ Weak ref proxy used after referent went away. """
4205     def __init__(self, *args, **kwargs): # real signature unknown
4206         pass
4207 
4208     @staticmethod # known case of __new__
4209     def __new__(*args, **kwargs): # real signature unknown
4210         """ Create and return a new object.  See help(type) for accurate signature. """
4211         pass
4212 
4213 
4214 class ResourceWarning(Warning):
4215     """ Base class for warnings about resource usage. """
4216     def __init__(self, *args, **kwargs): # real signature unknown
4217         pass
4218 
4219     @staticmethod # known case of __new__
4220     def __new__(*args, **kwargs): # real signature unknown
4221         """ Create and return a new object.  See help(type) for accurate signature. """
4222         pass
4223 
4224 
4225 class reversed(object):
4226     """
4227     reversed(sequence) -> reverse iterator over values of the sequence
4228     
4229     Return a reverse iterator
4230     """
4231     def __getattribute__(self, *args, **kwargs): # real signature unknown
4232         """ Return getattr(self, name). """
4233         pass
4234 
4235     def __init__(self, sequence): # real signature unknown; restored from __doc__
4236         pass
4237 
4238     def __iter__(self, *args, **kwargs): # real signature unknown
4239         """ Implement iter(self). """
4240         pass
4241 
4242     def __length_hint__(self, *args, **kwargs): # real signature unknown
4243         """ Private method returning an estimate of len(list(it)). """
4244         pass
4245 
4246     @staticmethod # known case of __new__
4247     def __new__(*args, **kwargs): # real signature unknown
4248         """ Create and return a new object.  See help(type) for accurate signature. """
4249         pass
4250 
4251     def __next__(self, *args, **kwargs): # real signature unknown
4252         """ Implement next(self). """
4253         pass
4254 
4255     def __reduce__(self, *args, **kwargs): # real signature unknown
4256         """ Return state information for pickling. """
4257         pass
4258 
4259     def __setstate__(self, *args, **kwargs): # real signature unknown
4260         """ Set state information for unpickling. """
4261         pass
4262 
4263 
4264 class RuntimeWarning(Warning):
4265     """ Base class for warnings about dubious runtime behavior. """
4266     def __init__(self, *args, **kwargs): # real signature unknown
4267         pass
4268 
4269     @staticmethod # known case of __new__
4270     def __new__(*args, **kwargs): # real signature unknown
4271         """ Create and return a new object.  See help(type) for accurate signature. """
4272         pass
4273 
4274 
4275 class set(object):
4276     """
4277     set() -> new empty set object
4278     set(iterable) -> new set object
4279     
4280     Build an unordered collection of unique elements.
4281     """
4282     def add(self, *args, **kwargs): # real signature unknown
4283         """
4284         Add an element to a set.
4285         
4286         This has no effect if the element is already present.
4287         """
4288         pass
4289 
4290     def clear(self, *args, **kwargs): # real signature unknown
4291         """ Remove all elements from this set. """
4292         pass
4293 
4294     def copy(self, *args, **kwargs): # real signature unknown
4295         """ Return a shallow copy of a set. """
4296         pass
4297 
4298     def difference(self, *args, **kwargs): # real signature unknown
4299         """
4300         Return the difference of two or more sets as a new set.
4301         
4302         (i.e. all elements that are in this set but not the others.)
4303         """
4304         pass
4305 
4306     def difference_update(self, *args, **kwargs): # real signature unknown
4307         """ Remove all elements of another set from this set. """
4308         pass
4309 
4310     def discard(self, *args, **kwargs): # real signature unknown
4311         """
4312         Remove an element from a set if it is a member.
4313         
4314         If the element is not a member, do nothing.
4315         """
4316         pass
4317 
4318     def intersection(self, *args, **kwargs): # real signature unknown
4319         """
4320         Return the intersection of two sets as a new set.
4321         
4322         (i.e. all elements that are in both sets.)
4323         """
4324         pass
4325 
4326     def intersection_update(self, *args, **kwargs): # real signature unknown
4327         """ Update a set with the intersection of itself and another. """
4328         pass
4329 
4330     def isdisjoint(self, *args, **kwargs): # real signature unknown
4331         """ Return True if two sets have a null intersection. """
4332         pass
4333 
4334     def issubset(self, *args, **kwargs): # real signature unknown
4335         """ Report whether another set contains this set. """
4336         pass
4337 
4338     def issuperset(self, *args, **kwargs): # real signature unknown
4339         """ Report whether this set contains another set. """
4340         pass
4341 
4342     def pop(self, *args, **kwargs): # real signature unknown
4343         """
4344         Remove and return an arbitrary set element.
4345         Raises KeyError if the set is empty.
4346         """
4347         pass
4348 
4349     def remove(self, *args, **kwargs): # real signature unknown
4350         """
4351         Remove an element from a set; it must be a member.
4352         
4353         If the element is not a member, raise a KeyError.
4354         """
4355         pass
4356 
4357     def symmetric_difference(self, *args, **kwargs): # real signature unknown
4358         """
4359         Return the symmetric difference of two sets as a new set.
4360         
4361         (i.e. all elements that are in exactly one of the sets.)
4362         """
4363         pass
4364 
4365     def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
4366         """ Update a set with the symmetric difference of itself and another. """
4367         pass
4368 
4369     def union(self, *args, **kwargs): # real signature unknown
4370         """
4371         Return the union of sets as a new set.
4372         
4373         (i.e. all elements that are in either set.)
4374         """
4375         pass
4376 
4377     def update(self, *args, **kwargs): # real signature unknown
4378         """ Update a set with the union of itself and others. """
4379         pass
4380 
4381     def __and__(self, *args, **kwargs): # real signature unknown
4382         """ Return self&value. """
4383         pass
4384 
4385     def __contains__(self, y): # real signature unknown; restored from __doc__
4386         """ x.__contains__(y) <==> y in x. """
4387         pass
4388 
4389     def __eq__(self, *args, **kwargs): # real signature unknown
4390         """ Return self==value. """
4391         pass
4392 
4393     def __getattribute__(self, *args, **kwargs): # real signature unknown
4394         """ Return getattr(self, name). """
4395         pass
4396 
4397     def __ge__(self, *args, **kwargs): # real signature unknown
4398         """ Return self>=value. """
4399         pass
4400 
4401     def __gt__(self, *args, **kwargs): # real signature unknown
4402         """ Return self>value. """
4403         pass
4404 
4405     def __iand__(self, *args, **kwargs): # real signature unknown
4406         """ Return self&=value. """
4407         pass
4408 
4409     def __init__(self, seq=()): # known special case of set.__init__
4410         """
4411         set() -> new empty set object
4412         set(iterable) -> new set object
4413         
4414         Build an unordered collection of unique elements.
4415         # (copied from class doc)
4416         """
4417         pass
4418 
4419     def __ior__(self, *args, **kwargs): # real signature unknown
4420         """ Return self|=value. """
4421         pass
4422 
4423     def __isub__(self, *args, **kwargs): # real signature unknown
4424         """ Return self-=value. """
4425         pass
4426 
4427     def __iter__(self, *args, **kwargs): # real signature unknown
4428         """ Implement iter(self). """
4429         pass
4430 
4431     def __ixor__(self, *args, **kwargs): # real signature unknown
4432         """ Return self^=value. """
4433         pass
4434 
4435     def __len__(self, *args, **kwargs): # real signature unknown
4436         """ Return len(self). """
4437         pass
4438 
4439     def __le__(self, *args, **kwargs): # real signature unknown
4440         """ Return self<=value. """
4441         pass
4442 
4443     def __lt__(self, *args, **kwargs): # real signature unknown
4444         """ Return self<value. """
4445         pass
4446 
4447     @staticmethod # known case of __new__
4448     def __new__(*args, **kwargs): # real signature unknown
4449         """ Create and return a new object.  See help(type) for accurate signature. """
4450         pass
4451 
4452     def __ne__(self, *args, **kwargs): # real signature unknown
4453         """ Return self!=value. """
4454         pass
4455 
4456     def __or__(self, *args, **kwargs): # real signature unknown
4457         """ Return self|value. """
4458         pass
4459 
4460     def __rand__(self, *args, **kwargs): # real signature unknown
4461         """ Return value&self. """
4462         pass
4463 
4464     def __reduce__(self, *args, **kwargs): # real signature unknown
4465         """ Return state information for pickling. """
4466         pass
4467 
4468     def __repr__(self, *args, **kwargs): # real signature unknown
4469         """ Return repr(self). """
4470         pass
4471 
4472     def __ror__(self, *args, **kwargs): # real signature unknown
4473         """ Return value|self. """
4474         pass
4475 
4476     def __rsub__(self, *args, **kwargs): # real signature unknown
4477         """ Return value-self. """
4478         pass
4479 
4480     def __rxor__(self, *args, **kwargs): # real signature unknown
4481         """ Return value^self. """
4482         pass
4483 
4484     def __sizeof__(self): # real signature unknown; restored from __doc__
4485         """ S.__sizeof__() -> size of S in memory, in bytes """
4486         pass
4487 
4488     def __sub__(self, *args, **kwargs): # real signature unknown
4489         """ Return self-value. """
4490         pass
4491 
4492     def __xor__(self, *args, **kwargs): # real signature unknown
4493         """ Return self^value. """
4494         pass
4495 
4496     __hash__ = None
4497 
4498 
4499 class slice(object):
4500     """
4501     slice(stop)
4502     slice(start, stop[, step])
4503     
4504     Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]).
4505     """
4506     def indices(self, len): # real signature unknown; restored from __doc__
4507         """
4508         S.indices(len) -> (start, stop, stride)
4509         
4510         Assuming a sequence of length len, calculate the start and stop
4511         indices, and the stride length of the extended slice described by
4512         S. Out of bounds indices are clipped in a manner consistent with the
4513         handling of normal slices.
4514         """
4515         pass
4516 
4517     def __eq__(self, *args, **kwargs): # real signature unknown
4518         """ Return self==value. """
4519         pass
4520 
4521     def __getattribute__(self, *args, **kwargs): # real signature unknown
4522         """ Return getattr(self, name). """
4523         pass
4524 
4525     def __ge__(self, *args, **kwargs): # real signature unknown
4526         """ Return self>=value. """
4527         pass
4528 
4529     def __gt__(self, *args, **kwargs): # real signature unknown
4530         """ Return self>value. """
4531         pass
4532 
4533     def __init__(self, stop): # real signature unknown; restored from __doc__
4534         pass
4535 
4536     def __le__(self, *args, **kwargs): # real signature unknown
4537         """ Return self<=value. """
4538         pass
4539 
4540     def __lt__(self, *args, **kwargs): # real signature unknown
4541         """ Return self<value. """
4542         pass
4543 
4544     @staticmethod # known case of __new__
4545     def __new__(*args, **kwargs): # real signature unknown
4546         """ Create and return a new object.  See help(type) for accurate signature. """
4547         pass
4548 
4549     def __ne__(self, *args, **kwargs): # real signature unknown
4550         """ Return self!=value. """
4551         pass
4552 
4553     def __reduce__(self, *args, **kwargs): # real signature unknown
4554         """ Return state information for pickling. """
4555         pass
4556 
4557     def __repr__(self, *args, **kwargs): # real signature unknown
4558         """ Return repr(self). """
4559         pass
4560 
4561     start = property(lambda self: 0)
4562     """:type: int"""
4563 
4564     step = property(lambda self: 0)
4565     """:type: int"""
4566 
4567     stop = property(lambda self: 0)
4568     """:type: int"""
4569 
4570 
4571     __hash__ = None
4572 
4573 
4574 class staticmethod(object):
4575     """
4576     staticmethod(function) -> method
4577     
4578     Convert a function to be a static method.
4579     
4580     A static method does not receive an implicit first argument.
4581     To declare a static method, use this idiom:
4582     
4583          class C:
4584              @staticmethod
4585              def f(arg1, arg2, ...):
4586                  ...
4587     
4588     It can be called either on the class (e.g. C.f()) or on an instance
4589     (e.g. C().f()).  The instance is ignored except for its class.
4590     
4591     Static methods in Python are similar to those found in Java or C++.
4592     For a more advanced concept, see the classmethod builtin.
4593     """
4594     def __get__(self, *args, **kwargs): # real signature unknown
4595         """ Return an attribute of instance, which is of type owner. """
4596         pass
4597 
4598     def __init__(self, function): # real signature unknown; restored from __doc__
4599         pass
4600 
4601     @staticmethod # known case of __new__
4602     def __new__(*args, **kwargs): # real signature unknown
4603         """ Create and return a new object.  See help(type) for accurate signature. """
4604         pass
4605 
4606     __func__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4607 
4608     __isabstractmethod__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4609 
4610 
4611     __dict__ = None # (!) real value is ‘‘
4612 
4613 
4614 class StopAsyncIteration(Exception):
4615     """ Signal the end from iterator.__anext__(). """
4616     def __init__(self, *args, **kwargs): # real signature unknown
4617         pass
4618 
4619     @staticmethod # known case of __new__
4620     def __new__(*args, **kwargs): # real signature unknown
4621         """ Create and return a new object.  See help(type) for accurate signature. """
4622         pass
4623 
4624 
4625 class StopIteration(Exception):
4626     """ Signal the end from iterator.__next__(). """
4627     def __init__(self, *args, **kwargs): # real signature unknown
4628         pass
4629 
4630     value = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4631     """generator return value"""
4632 
4633 
4634 
4635 class str(object):
4636     """
4637     str(object=‘‘) -> str
4638     str(bytes_or_buffer[, encoding[, errors]]) -> str
4639     
4640     Create a new string object from the given object. If encoding or
4641     errors is specified, then the object must expose a data buffer
4642     that will be decoded using the given encoding and error handler.
4643     Otherwise, returns the result of object.__str__() (if defined)
4644     or repr(object).
4645     encoding defaults to sys.getdefaultencoding().
4646     errors defaults to ‘strict‘.
4647     """
4648     def capitalize(self): # real signature unknown; restored from __doc__
4649         """
4650         S.capitalize() -> str
4651         
4652         Return a capitalized version of S, i.e. make the first character
4653         have upper case and the rest lower case.
4654         """
4655         return ""
4656 
4657     def casefold(self): # real signature unknown; restored from __doc__
4658         """
4659         S.casefold() -> str
4660         
4661         Return a version of S suitable for caseless comparisons.
4662         """
4663         return ""
4664 
4665     def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
4666         """
4667         S.center(width[, fillchar]) -> str
4668         
4669         Return S centered in a string of length width. Padding is
4670         done using the specified fill character (default is a space)
4671         """
4672         return ""
4673 
4674     def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
4675         """
4676         S.count(sub[, start[, end]]) -> int
4677         
4678         Return the number of non-overlapping occurrences of substring sub in
4679         string S[start:end].  Optional arguments start and end are
4680         interpreted as in slice notation.
4681         """
4682         return 0
4683 
4684     def encode(self, encoding=‘utf-8‘, errors=‘strict‘): # real signature unknown; restored from __doc__
4685         """
4686         S.encode(encoding=‘utf-8‘, errors=‘strict‘) -> bytes
4687         
4688         Encode S using the codec registered for encoding. Default encoding
4689         is ‘utf-8‘. errors may be given to set a different error
4690         handling scheme. Default is ‘strict‘ meaning that encoding errors raise
4691         a UnicodeEncodeError. Other possible values are ‘ignore‘, ‘replace‘ and
4692         ‘xmlcharrefreplace‘ as well as any other name registered with
4693         codecs.register_error that can handle UnicodeEncodeErrors.
4694         """
4695         return b""
4696 
4697     def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
4698         """
4699         S.endswith(suffix[, start[, end]]) -> bool
4700         
4701         Return True if S ends with the specified suffix, False otherwise.
4702         With optional start, test S beginning at that position.
4703         With optional end, stop comparing S at that position.
4704         suffix can also be a tuple of strings to try.
4705         """
4706         return False
4707 
4708     def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
4709         """
4710         S.expandtabs(tabsize=8) -> str
4711         
4712         Return a copy of S where all tab characters are expanded using spaces.
4713         If tabsize is not given, a tab size of 8 characters is assumed.
4714         """
4715         return ""
4716 
4717     def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
4718         """
4719         S.find(sub[, start[, end]]) -> int
4720         
4721         Return the lowest index in S where substring sub is found,
4722         such that sub is contained within S[start:end].  Optional
4723         arguments start and end are interpreted as in slice notation.
4724         
4725         Return -1 on failure.
4726         """
4727         return 0
4728 
4729     def format(self, *args, **kwargs): # known special case of str.format
4730         """
4731         S.format(*args, **kwargs) -> str
4732         
4733         Return a formatted version of S, using substitutions from args and kwargs.
4734         The substitutions are identified by braces (‘{‘ and ‘}‘).
4735         """
4736         pass
4737 
4738     def format_map(self, mapping): # real signature unknown; restored from __doc__
4739         """
4740         S.format_map(mapping) -> str
4741         
4742         Return a formatted version of S, using substitutions from mapping.
4743         The substitutions are identified by braces (‘{‘ and ‘}‘).
4744         """
4745         return ""
4746 
4747     def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
4748         """
4749         S.index(sub[, start[, end]]) -> int
4750         
4751         Like S.find() but raise ValueError when the substring is not found.
4752         """
4753         return 0
4754 
4755     def isalnum(self): # real signature unknown; restored from __doc__
4756         """
4757         S.isalnum() -> bool
4758         
4759         Return True if all characters in S are alphanumeric
4760         and there is at least one character in S, False otherwise.
4761         """
4762         return False
4763 
4764     def isalpha(self): # real signature unknown; restored from __doc__
4765         """
4766         S.isalpha() -> bool
4767         
4768         Return True if all characters in S are alphabetic
4769         and there is at least one character in S, False otherwise.
4770         """
4771         return False
4772 
4773     def isdecimal(self): # real signature unknown; restored from __doc__
4774         """
4775         S.isdecimal() -> bool
4776         
4777         Return True if there are only decimal characters in S,
4778         False otherwise.
4779         """
4780         return False
4781 
4782     def isdigit(self): # real signature unknown; restored from __doc__
4783         """
4784         S.isdigit() -> bool
4785         
4786         Return True if all characters in S are digits
4787         and there is at least one character in S, False otherwise.
4788         """
4789         return False
4790 
4791     def isidentifier(self): # real signature unknown; restored from __doc__
4792         """
4793         S.isidentifier() -> bool
4794         
4795         Return True if S is a valid identifier according
4796         to the language definition.
4797         
4798         Use keyword.iskeyword() to test for reserved identifiers
4799         such as "def" and "class".
4800         """
4801         return False
4802 
4803     def islower(self): # real signature unknown; restored from __doc__
4804         """
4805         S.islower() -> bool
4806         
4807         Return True if all cased characters in S are lowercase and there is
4808         at least one cased character in S, False otherwise.
4809         """
4810         return False
4811 
4812     def isnumeric(self): # real signature unknown; restored from __doc__
4813         """
4814         S.isnumeric() -> bool
4815         
4816         Return True if there are only numeric characters in S,
4817         False otherwise.
4818         """
4819         return False
4820 
4821     def isprintable(self): # real signature unknown; restored from __doc__
4822         """
4823         S.isprintable() -> bool
4824         
4825         Return True if all characters in S are considered
4826         printable in repr() or S is empty, False otherwise.
4827         """
4828         return False
4829 
4830     def isspace(self): # real signature unknown; restored from __doc__
4831         """
4832         S.isspace() -> bool
4833         
4834         Return True if all characters in S are whitespace
4835         and there is at least one character in S, False otherwise.
4836         """
4837         return False
4838 
4839     def istitle(self): # real signature unknown; restored from __doc__
4840         """
4841         S.istitle() -> bool
4842         
4843         Return True if S is a titlecased string and there is at least one
4844         character in S, i.e. upper- and titlecase characters may only
4845         follow uncased characters and lowercase characters only cased ones.
4846         Return False otherwise.
4847         """
4848         return False
4849 
4850     def isupper(self): # real signature unknown; restored from __doc__
4851         """
4852         S.isupper() -> bool
4853         
4854         Return True if all cased characters in S are uppercase and there is
4855         at least one cased character in S, False otherwise.
4856         """
4857         return False
4858 
4859     def join(self, iterable): # real signature unknown; restored from __doc__
4860         """
4861         S.join(iterable) -> str
4862         
4863         Return a string which is the concatenation of the strings in the
4864         iterable.  The separator between elements is S.
4865         """
4866         return ""
4867 
4868     def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
4869         """
4870         S.ljust(width[, fillchar]) -> str
4871         
4872         Return S left-justified in a Unicode string of length width. Padding is
4873         done using the specified fill character (default is a space).
4874         """
4875         return ""
4876 
4877     def lower(self): # real signature unknown; restored from __doc__
4878         """
4879         S.lower() -> str
4880         
4881         Return a copy of the string S converted to lowercase.
4882         """
4883         return ""
4884 
4885     def lstrip(self, chars=None): # real signature unknown; restored from __doc__
4886         """
4887         S.lstrip([chars]) -> str
4888         
4889         Return a copy of the string S with leading whitespace removed.
4890         If chars is given and not None, remove characters in chars instead.
4891         """
4892         return ""
4893 
4894     def maketrans(self, *args, **kwargs): # real signature unknown
4895         """
4896         Return a translation table usable for str.translate().
4897         
4898         If there is only one argument, it must be a dictionary mapping Unicode
4899         ordinals (integers) or characters to Unicode ordinals, strings or None.
4900         Character keys will be then converted to ordinals.
4901         If there are two arguments, they must be strings of equal length, and
4902         in the resulting dictionary, each character in x will be mapped to the
4903         character at the same position in y. If there is a third argument, it
4904         must be a string, whose characters will be mapped to None in the result.
4905         """
4906         pass
4907 
4908     def partition(self, sep): # real signature unknown; restored from __doc__
4909         """
4910         S.partition(sep) -> (head, sep, tail)
4911         
4912         Search for the separator sep in S, and return the part before it,
4913         the separator itself, and the part after it.  If the separator is not
4914         found, return S and two empty strings.
4915         """
4916         pass
4917 
4918     def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
4919         """
4920         S.replace(old, new[, count]) -> str
4921         
4922         Return a copy of S with all occurrences of substring
4923         old replaced by new.  If the optional argument count is
4924         given, only the first count occurrences are replaced.
4925         """
4926         return ""
4927 
4928     def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
4929         """
4930         S.rfind(sub[, start[, end]]) -> int
4931         
4932         Return the highest index in S where substring sub is found,
4933         such that sub is contained within S[start:end].  Optional
4934         arguments start and end are interpreted as in slice notation.
4935         
4936         Return -1 on failure.
4937         """
4938         return 0
4939 
4940     def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
4941         """
4942         S.rindex(sub[, start[, end]]) -> int
4943         
4944         Like S.rfind() but raise ValueError when the substring is not found.
4945         """
4946         return 0
4947 
4948     def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
4949         """
4950         S.rjust(width[, fillchar]) -> str
4951         
4952         Return S right-justified in a string of length width. Padding is
4953         done using the specified fill character (default is a space).
4954         """
4955         return ""
4956 
4957     def rpartition(self, sep): # real signature unknown; restored from __doc__
4958         """
4959         S.rpartition(sep) -> (head, sep, tail)
4960         
4961         Search for the separator sep in S, starting at the end of S, and return
4962         the part before it, the separator itself, and the part after it.  If the
4963         separator is not found, return two empty strings and S.
4964         """
4965         pass
4966 
4967     def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
4968         """
4969         S.rsplit(sep=None, maxsplit=-1) -> list of strings
4970         
4971         Return a list of the words in S, using sep as the
4972         delimiter string, starting at the end of the string and
4973         working to the front.  If maxsplit is given, at most maxsplit
4974         splits are done. If sep is not specified, any whitespace string
4975         is a separator.
4976         """
4977         return []
4978 
4979     def rstrip(self, chars=None): # real signature unknown; restored from __doc__
4980         """
4981         S.rstrip([chars]) -> str
4982         
4983         Return a copy of the string S with trailing whitespace removed.
4984         If chars is given and not None, remove characters in chars instead.
4985         """
4986         return ""
4987 
4988     def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
4989         """
4990         S.split(sep=None, maxsplit=-1) -> list of strings
4991         
4992         Return a list of the words in S, using sep as the
4993         delimiter string.  If maxsplit is given, at most maxsplit
4994         splits are done. If sep is not specified or is None, any
4995         whitespace string is a separator and empty strings are
4996         removed from the result.
4997         """
4998         return []
4999 
5000     def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
5001         """
5002         S.splitlines([keepends]) -> list of strings
5003         
5004         Return a list of the lines in S, breaking at line boundaries.
5005         Line breaks are not included in the resulting list unless keepends
5006         is given and true.
5007         """
5008         return []
5009 
5010     def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
5011         """
5012         S.startswith(prefix[, start[, end]]) -> bool
5013         
5014         Return True if S starts with the specified prefix, False otherwise.
5015         With optional start, test S beginning at that position.
5016         With optional end, stop comparing S at that position.
5017         prefix can also be a tuple of strings to try.
5018         """
5019         return False
5020 
5021     def strip(self, chars=None): # real signature unknown; restored from __doc__
5022         """
5023         S.strip([chars]) -> str
5024         
5025         Return a copy of the string S with leading and trailing
5026         whitespace removed.
5027         If chars is given and not None, remove characters in chars instead.
5028         """
5029         return ""
5030 
5031     def swapcase(self): # real signature unknown; restored from __doc__
5032         """
5033         S.swapcase() -> str
5034         
5035         Return a copy of S with uppercase characters converted to lowercase
5036         and vice versa.
5037         """
5038         return ""
5039 
5040     def title(self): # real signature unknown; restored from __doc__
5041         """
5042         S.title() -> str
5043         
5044         Return a titlecased version of S, i.e. words start with title case
5045         characters, all remaining cased characters have lower case.
5046         """
5047         return ""
5048 
5049     def translate(self, table): # real signature unknown; restored from __doc__
5050         """
5051         S.translate(table) -> str
5052         
5053         Return a copy of the string S in which each character has been mapped
5054         through the given translation table. The table must implement
5055         lookup/indexing via __getitem__, for instance a dictionary or list,
5056         mapping Unicode ordinals to Unicode ordinals, strings, or None. If
5057         this operation raises LookupError, the character is left untouched.
5058         Characters mapped to None are deleted.
5059         """
5060         return ""
5061 
5062     def upper(self): # real signature unknown; restored from __doc__
5063         """
5064         S.upper() -> str
5065         
5066         Return a copy of S converted to uppercase.
5067         """
5068         return ""
5069 
5070     def zfill(self, width): # real signature unknown; restored from __doc__
5071         """
5072         S.zfill(width) -> str
5073         
5074         Pad a numeric string S with zeros on the left, to fill a field
5075         of the specified width. The string S is never truncated.
5076         """
5077         return ""
5078 
5079     def __add__(self, *args, **kwargs): # real signature unknown
5080         """ Return self+value. """
5081         pass
5082 
5083     def __contains__(self, *args, **kwargs): # real signature unknown
5084         """ Return key in self. """
5085         pass
5086 
5087     def __eq__(self, *args, **kwargs): # real signature unknown
5088         """ Return self==value. """
5089         pass
5090 
5091     def __format__(self, format_spec): # real signature unknown; restored from __doc__
5092         """
5093         S.__format__(format_spec) -> str
5094         
5095         Return a formatted version of S as described by format_spec.
5096         """
5097         return ""
5098 
5099     def __getattribute__(self, *args, **kwargs): # real signature unknown
5100         """ Return getattr(self, name). """
5101         pass
5102 
5103     def __getitem__(self, *args, **kwargs): # real signature unknown
5104         """ Return self[key]. """
5105         pass
5106 
5107     def __getnewargs__(self, *args, **kwargs): # real signature unknown
5108         pass
5109 
5110     def __ge__(self, *args, **kwargs): # real signature unknown
5111         """ Return self>=value. """
5112         pass
5113 
5114     def __gt__(self, *args, **kwargs): # real signature unknown
5115         """ Return self>value. """
5116         pass
5117 
5118     def __hash__(self, *args, **kwargs): # real signature unknown
5119         """ Return hash(self). """
5120         pass
5121 
5122     def __init__(self, value=‘‘, encoding=None, errors=‘strict‘): # known special case of str.__init__
5123         """
5124         str(object=‘‘) -> str
5125         str(bytes_or_buffer[, encoding[, errors]]) -> str
5126         
5127         Create a new string object from the given object. If encoding or
5128         errors is specified, then the object must expose a data buffer
5129         that will be decoded using the given encoding and error handler.
5130         Otherwise, returns the result of object.__str__() (if defined)
5131         or repr(object).
5132         encoding defaults to sys.getdefaultencoding().
5133         errors defaults to ‘strict‘.
5134         # (copied from class doc)
5135         """
5136         pass
5137 
5138     def __iter__(self, *args, **kwargs): # real signature unknown
5139         """ Implement iter(self). """
5140         pass
5141 
5142     def __len__(self, *args, **kwargs): # real signature unknown
5143         """ Return len(self). """
5144         pass
5145 
5146     def __le__(self, *args, **kwargs): # real signature unknown
5147         """ Return self<=value. """
5148         pass
5149 
5150     def __lt__(self, *args, **kwargs): # real signature unknown
5151         """ Return self<value. """
5152         pass
5153 
5154     def __mod__(self, *args, **kwargs): # real signature unknown
5155         """ Return self%value. """
5156         pass
5157 
5158     def __mul__(self, *args, **kwargs): # real signature unknown
5159         """ Return self*value.n """
5160         pass
5161 
5162     @staticmethod # known case of __new__
5163     def __new__(*args, **kwargs): # real signature unknown
5164         """ Create and return a new object.  See help(type) for accurate signature. """
5165         pass
5166 
5167     def __ne__(self, *args, **kwargs): # real signature unknown
5168         """ Return self!=value. """
5169         pass
5170 
5171     def __repr__(self, *args, **kwargs): # real signature unknown
5172         """ Return repr(self). """
5173         pass
5174 
5175     def __rmod__(self, *args, **kwargs): # real signature unknown
5176         """ Return value%self. """
5177         pass
5178 
5179     def __rmul__(self, *args, **kwargs): # real signature unknown
5180         """ Return self*value. """
5181         pass
5182 
5183     def __sizeof__(self): # real signature unknown; restored from __doc__
5184         """ S.__sizeof__() -> size of S in memory, in bytes """
5185         pass
5186 
5187     def __str__(self, *args, **kwargs): # real signature unknown
5188         """ Return str(self). """
5189         pass
5190 
5191 
5192 class super(object):
5193     """
5194     super() -> same as super(__class__, <first argument>)
5195     super(type) -> unbound super object
5196     super(type, obj) -> bound super object; requires isinstance(obj, type)
5197     super(type, type2) -> bound super object; requires issubclass(type2, type)
5198     Typical use to call a cooperative superclass method:
5199     class C(B):
5200         def meth(self, arg):
5201             super().meth(arg)
5202     This works for class methods too:
5203     class C(B):
5204         @classmethod
5205         def cmeth(cls, arg):
5206             super().cmeth(arg)
5207     """
5208     def __getattribute__(self, *args, **kwargs): # real signature unknown
5209         """ Return getattr(self, name). """
5210         pass
5211 
5212     def __get__(self, *args, **kwargs): # real signature unknown
5213         """ Return an attribute of instance, which is of type owner. """
5214         pass
5215 
5216     def __init__(self, type1=None, type2=None): # known special case of super.__init__
5217         """
5218         super() -> same as super(__class__, <first argument>)
5219         super(type) -> unbound super object
5220         super(type, obj) -> bound super object; requires isinstance(obj, type)
5221         super(type, type2) -> bound super object; requires issubclass(type2, type)
5222         Typical use to call a cooperative superclass method:
5223         class C(B):
5224             def meth(self, arg):
5225                 super().meth(arg)
5226         This works for class methods too:
5227         class C(B):
5228             @classmethod
5229             def cmeth(cls, arg):
5230                 super().cmeth(arg)
5231         
5232         # (copied from class doc)
5233         """
5234         pass
5235 
5236     @staticmethod # known case of __new__
5237     def __new__(*args, **kwargs): # real signature unknown
5238         """ Create and return a new object.  See help(type) for accurate signature. """
5239         pass
5240 
5241     def __repr__(self, *args, **kwargs): # real signature unknown
5242         """ Return repr(self). """
5243         pass
5244 
5245     __self_class__ = property(lambda self: type(object))
5246     """the type of the instance invoking super(); may be None
5247 
5248     :type: type
5249     """
5250 
5251     __self__ = property(lambda self: type(object))
5252     """the instance invoking super(); may be None
5253 
5254     :type: type
5255     """
5256 
5257     __thisclass__ = property(lambda self: type(object))
5258     """the class invoking super()
5259 
5260     :type: type
5261     """
5262 
5263 
5264 
5265 class SyntaxWarning(Warning):
5266     """ Base class for warnings about dubious syntax. """
5267     def __init__(self, *args, **kwargs): # real signature unknown
5268         pass
5269 
5270     @staticmethod # known case of __new__
5271     def __new__(*args, **kwargs): # real signature unknown
5272         """ Create and return a new object.  See help(type) for accurate signature. """
5273         pass
5274 
5275 
5276 class SystemError(Exception):
5277     """
5278     Internal error in the Python interpreter.
5279     
5280     Please report this to the Python maintainer, along with the traceback,
5281     the Python version, and the hardware/OS platform and version.
5282     """
5283     def __init__(self, *args, **kwargs): # real signature unknown
5284         pass
5285 
5286     @staticmethod # known case of __new__
5287     def __new__(*args, **kwargs): # real signature unknown
5288         """ Create and return a new object.  See help(type) for accurate signature. """
5289         pass
5290 
5291 
5292 class SystemExit(BaseException):
5293     """ Request to exit from the interpreter. """
5294     def __init__(self, *args, **kwargs): # real signature unknown
5295         pass
5296 
5297     code = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5298     """exception code"""
5299 
5300 
5301 
5302 class TabError(IndentationError):
5303     """ Improper mixture of spaces and tabs. """
5304     def __init__(self, *args, **kwargs): # real signature unknown
5305         pass
5306 
5307 
5308 class TimeoutError(OSError):
5309     """ Timeout expired. """
5310     def __init__(self, *args, **kwargs): # real signature unknown
5311         pass
5312 
5313 
5314 class tuple(object):
5315     """
5316     tuple() -> empty tuple
5317     tuple(iterable) -> tuple initialized from iterable‘s items
5318     
5319     If the argument is a tuple, the return value is the same object.
5320     """
5321     def count(self, value): # real signature unknown; restored from __doc__
5322         """ T.count(value) -> integer -- return number of occurrences of value """
5323         return 0
5324 
5325     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
5326         """
5327         T.index(value, [start, [stop]]) -> integer -- return first index of value.
5328         Raises ValueError if the value is not present.
5329         """
5330         return 0
5331 
5332     def __add__(self, *args, **kwargs): # real signature unknown
5333         """ Return self+value. """
5334         pass
5335 
5336     def __contains__(self, *args, **kwargs): # real signature unknown
5337         """ Return key in self. """
5338         pass
5339 
5340     def __eq__(self, *args, **kwargs): # real signature unknown
5341         """ Return self==value. """
5342         pass
5343 
5344     def __getattribute__(self, *args, **kwargs): # real signature unknown
5345         """ Return getattr(self, name). """
5346         pass
5347 
5348     def __getitem__(self, *args, **kwargs): # real signature unknown
5349         """ Return self[key]. """
5350         pass
5351 
5352     def __getnewargs__(self, *args, **kwargs): # real signature unknown
5353         pass
5354 
5355     def __ge__(self, *args, **kwargs): # real signature unknown
5356         """ Return self>=value. """
5357         pass
5358 
5359     def __gt__(self, *args, **kwargs): # real signature unknown
5360         """ Return self>value. """
5361         pass
5362 
5363     def __hash__(self, *args, **kwargs): # real signature unknown
5364         """ Return hash(self). """
5365         pass
5366 
5367     def __init__(self, seq=()): # known special case of tuple.__init__
5368         """
5369         tuple() -> empty tuple
5370         tuple(iterable) -> tuple initialized from iterable‘s items
5371         
5372         If the argument is a tuple, the return value is the same object.
5373         # (copied from class doc)
5374         """
5375         pass
5376 
5377     def __iter__(self, *args, **kwargs): # real signature unknown
5378         """ Implement iter(self). """
5379         pass
5380 
5381     def __len__(self, *args, **kwargs): # real signature unknown
5382         """ Return len(self). """
5383         pass
5384 
5385     def __le__(self, *args, **kwargs): # real signature unknown
5386         """ Return self<=value. """
5387         pass
5388 
5389     def __lt__(self, *args, **kwargs): # real signature unknown
5390         """ Return self<value. """
5391         pass
5392 
5393     def __mul__(self, *args, **kwargs): # real signature unknown
5394         """ Return self*value.n """
5395         pass
5396 
5397     @staticmethod # known case of __new__
5398     def __new__(*args, **kwargs): # real signature unknown
5399         """ Create and return a new object.  See help(type) for accurate signature. """
5400         pass
5401 
5402     def __ne__(self, *args, **kwargs): # real signature unknown
5403         """ Return self!=value. """
5404         pass
5405 
5406     def __repr__(self, *args, **kwargs): # real signature unknown
5407         """ Return repr(self). """
5408         pass
5409 
5410     def __rmul__(self, *args, **kwargs): # real signature unknown
5411         """ Return self*value. """
5412         pass
5413 
5414 
5415 class type(object):
5416     """
5417     type(object_or_name, bases, dict)
5418     type(object) -> the object‘s type
5419     type(name, bases, dict) -> a new type
5420     """
5421     def mro(self): # real signature unknown; restored from __doc__
5422         """
5423         mro() -> list
5424         return a type‘s method resolution order
5425         """
5426         return []
5427 
5428     def __call__(self, *args, **kwargs): # real signature unknown
5429         """ Call self as a function. """
5430         pass
5431 
5432     def __delattr__(self, *args, **kwargs): # real signature unknown
5433         """ Implement delattr(self, name). """
5434         pass
5435 
5436     def __dir__(self): # real signature unknown; restored from __doc__
5437         """
5438         __dir__() -> list
5439         specialized __dir__ implementation for types
5440         """
5441         return []
5442 
5443     def __getattribute__(self, *args, **kwargs): # real signature unknown
5444         """ Return getattr(self, name). """
5445         pass
5446 
5447     def __init__(cls, what, bases=None, dict=None): # known special case of type.__init__
5448         """
5449         type(object_or_name, bases, dict)
5450         type(object) -> the object‘s type
5451         type(name, bases, dict) -> a new type
5452         # (copied from class doc)
5453         """
5454         pass
5455 
5456     def __instancecheck__(self): # real signature unknown; restored from __doc__
5457         """
5458         __instancecheck__() -> bool
5459         check if an object is an instance
5460         """
5461         return False
5462 
5463     @staticmethod # known case of __new__
5464     def __new__(*args, **kwargs): # real signature unknown
5465         """ Create and return a new object.  See help(type) for accurate signature. """
5466         pass
5467 
5468     def __prepare__(self): # real signature unknown; restored from __doc__
5469         """
5470         __prepare__() -> dict
5471         used to create the namespace for the class statement
5472         """
5473         return {}
5474 
5475     def __repr__(self, *args, **kwargs): # real signature unknown
5476         """ Return repr(self). """
5477         pass
5478 
5479     def __setattr__(self, *args, **kwargs): # real signature unknown
5480         """ Implement setattr(self, name, value). """
5481         pass
5482 
5483     def __sizeof__(self): # real signature unknown; restored from __doc__
5484         """
5485         __sizeof__() -> int
5486         return memory consumption of the type object
5487         """
5488         return 0
5489 
5490     def __subclasscheck__(self): # real signature unknown; restored from __doc__
5491         """
5492         __subclasscheck__() -> bool
5493         check if a class is a subclass
5494         """
5495         return False
5496 
5497     def __subclasses__(self): # real signature unknown; restored from __doc__
5498         """ __subclasses__() -> list of immediate subclasses """
5499         return []
5500 
5501     __abstractmethods__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5502 
5503 
5504     __bases__ = (
5505         object,
5506     )
5507     __base__ = object
5508     __basicsize__ = 864
5509     __dictoffset__ = 264
5510     __dict__ = None # (!) real value is ‘‘
5511     __flags__ = -2146675712
5512     __itemsize__ = 40
5513     __mro__ = (
5514         None, # (!) forward: type, real value is ‘‘
5515         object,
5516     )
5517     __name__ = ‘type‘
5518     __qualname__ = ‘type‘
5519     __text_signature__ = None
5520     __weakrefoffset__ = 368
5521 
5522 
5523 class TypeError(Exception):
5524     """ Inappropriate argument type. """
5525     def __init__(self, *args, **kwargs): # real signature unknown
5526         pass
5527 
5528     @staticmethod # known case of __new__
5529     def __new__(*args, **kwargs): # real signature unknown
5530         """ Create and return a new object.  See help(type) for accurate signature. """
5531         pass
5532 
5533 
5534 class UnboundLocalError(NameError):
5535     """ Local name referenced but not bound to a value. """
5536     def __init__(self, *args, **kwargs): # real signature unknown
5537         pass
5538 
5539     @staticmethod # known case of __new__
5540     def __new__(*args, **kwargs): # real signature unknown
5541         """ Create and return a new object.  See help(type) for accurate signature. """
5542         pass
5543 
5544 
5545 class ValueError(Exception):
5546     """ Inappropriate argument value (of correct type). """
5547     def __init__(self, *args, **kwargs): # real signature unknown
5548         pass
5549 
5550     @staticmethod # known case of __new__
5551     def __new__(*args, **kwargs): # real signature unknown
5552         """ Create and return a new object.  See help(type) for accurate signature. """
5553         pass
5554 
5555 
5556 class UnicodeError(ValueError):
5557     """ Unicode related error. """
5558     def __init__(self, *args, **kwargs): # real signature unknown
5559         pass
5560 
5561     @staticmethod # known case of __new__
5562     def __new__(*args, **kwargs): # real signature unknown
5563         """ Create and return a new object.  See help(type) for accurate signature. """
5564         pass
5565 
5566 
5567 class UnicodeDecodeError(UnicodeError):
5568     """ Unicode decoding error. """
5569     def __init__(self, *args, **kwargs): # real signature unknown
5570         pass
5571 
5572     @staticmethod # known case of __new__
5573     def __new__(*args, **kwargs): # real signature unknown
5574         """ Create and return a new object.  See help(type) for accurate signature. """
5575         pass
5576 
5577     def __str__(self, *args, **kwargs): # real signature unknown
5578         """ Return str(self). """
5579         pass
5580 
5581     encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5582     """exception encoding"""
5583 
5584     end = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5585     """exception end"""
5586 
5587     object = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5588     """exception object"""
5589 
5590     reason = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5591     """exception reason"""
5592 
5593     start = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5594     """exception start"""
5595 
5596 
5597 
5598 class UnicodeEncodeError(UnicodeError):
5599     """ Unicode encoding error. """
5600     def __init__(self, *args, **kwargs): # real signature unknown
5601         pass
5602 
5603     @staticmethod # known case of __new__
5604     def __new__(*args, **kwargs): # real signature unknown
5605         """ Create and return a new object.  See help(type) for accurate signature. """
5606         pass
5607 
5608     def __str__(self, *args, **kwargs): # real signature unknown
5609         """ Return str(self). """
5610         pass
5611 
5612     encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5613     """exception encoding"""
5614 
5615     end = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5616     """exception end"""
5617 
5618     object = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5619     """exception object"""
5620 
5621     reason = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5622     """exception reason"""
5623 
5624     start = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5625     """exception start"""
5626 
5627 
5628 
5629 class UnicodeTranslateError(UnicodeError):
5630     """ Unicode translation error. """
5631     def __init__(self, *args, **kwargs): # real signature unknown
5632         pass
5633 
5634     @staticmethod # known case of __new__
5635     def __new__(*args, **kwargs): # real signature unknown
5636         """ Create and return a new object.  See help(type) for accurate signature. """
5637         pass
5638 
5639     def __str__(self, *args, **kwargs): # real signature unknown
5640         """ Return str(self). """
5641         pass
5642 
5643     encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5644     """exception encoding"""
5645 
5646     end = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5647     """exception end"""
5648 
5649     object = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5650     """exception object"""
5651 
5652     reason = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5653     """exception reason"""
5654 
5655     start = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5656     """exception start"""
5657 
5658 
5659 
5660 class UnicodeWarning(Warning):
5661     """
5662     Base class for warnings about Unicode related problems, mostly
5663     related to conversion problems.
5664     """
5665     def __init__(self, *args, **kwargs): # real signature unknown
5666         pass
5667 
5668     @staticmethod # known case of __new__
5669     def __new__(*args, **kwargs): # real signature unknown
5670         """ Create and return a new object.  See help(type) for accurate signature. """
5671         pass
5672 
5673 
5674 class UserWarning(Warning):
5675     """ Base class for warnings generated by user code. """
5676     def __init__(self, *args, **kwargs): # real signature unknown
5677         pass
5678 
5679     @staticmethod # known case of __new__
5680     def __new__(*args, **kwargs): # real signature unknown
5681         """ Create and return a new object.  See help(type) for accurate signature. """
5682         pass
5683 
5684 
5685 class ZeroDivisionError(ArithmeticError):
5686     """ Second argument to a division or modulo operation was zero. """
5687     def __init__(self, *args, **kwargs): # real signature unknown
5688         pass
5689 
5690     @staticmethod # known case of __new__
5691     def __new__(*args, **kwargs): # real signature unknown
5692         """ Create and return a new object.  See help(type) for accurate signature. """
5693         pass
5694 
5695 
5696 class zip(object):
5697     """
5698     zip(iter1 [,iter2 [...]]) --> zip object
5699     
5700     Return a zip object whose .__next__() method returns a tuple where
5701     the i-th element comes from the i-th iterable argument.  The .__next__()
5702     method continues until the shortest iterable in the argument sequence
5703     is exhausted and then it raises StopIteration.
5704     """
5705     def __getattribute__(self, *args, **kwargs): # real signature unknown
5706         """ Return getattr(self, name). """
5707         pass
5708 
5709     def __init__(self, iter1, iter2=None, *some): # real signature unknown; restored from __doc__
5710         pass
5711 
5712     def __iter__(self, *args, **kwargs): # real signature unknown
5713         """ Implement iter(self). """
5714         pass
5715 
5716     @staticmethod # known case of __new__
5717     def __new__(*args, **kwargs): # real signature unknown
5718         """ Create and return a new object.  See help(type) for accurate signature. """
5719         pass
5720 
5721     def __next__(self, *args, **kwargs): # real signature unknown
5722         """ Implement next(self). """
5723         pass
5724 
5725     def __reduce__(self, *args, **kwargs): # real signature unknown
5726         """ Return state information for pickling. """
5727         pass
5728 
5729 
5730 class __loader__(object):
5731     """
5732     Meta path import for built-in modules.
5733     
5734         All methods are either class or static methods to avoid the need to
5735         instantiate the class.
5736     """
5737     def create_module(self, *args, **kwargs): # real signature unknown
5738         """ Create a built-in module """
5739         pass
5740 
5741     def exec_module(self, *args, **kwargs): # real signature unknown
5742         """ Exec a built-in module """
5743         pass
5744 
5745     def find_module(self, *args, **kwargs): # real signature unknown
5746         """
5747         Find the built-in module.
5748         
5749                 If ‘path‘ is ever specified then the search is considered a failure.
5750         
5751                 This method is deprecated.  Use find_spec() instead.
5752         """
5753         pass
5754 
5755     def find_spec(self, *args, **kwargs): # real signature unknown
5756         pass
5757 
5758     def get_code(self, *args, **kwargs): # real signature unknown
5759         """ Return None as built-in modules do not have code objects. """
5760         pass
5761 
5762     def get_source(self, *args, **kwargs): # real signature unknown
5763         """ Return None as built-in modules do not have source code. """
5764         pass
5765 
5766     def is_package(self, *args, **kwargs): # real signature unknown
5767         """ Return False as built-in modules are never packages. """
5768         pass
5769 
5770     def load_module(self, *args, **kwargs): # real signature unknown
5771         """
5772         Load the specified module into sys.modules and return it.
5773         
5774             This method is deprecated.  Use loader.exec_module instead.
5775         """
5776         pass
5777 
5778     def module_repr(module): # reliably restored by inspect
5779         """
5780         Return repr for the module.
5781         
5782                 The method is deprecated.  The import machinery does the job itself.
5783         """
5784         pass
5785 
5786     def __init__(self, *args, **kwargs): # real signature unknown
5787         pass
5788 
5789     __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5790     """list of weak references to the object (if defined)"""
5791 
5792 
5793     __dict__ = None # (!) real value is ‘‘
5794 
5795 
5796 # variables with complex values
5797 
5798 Ellipsis = None # (!) real value is ‘‘
5799 
5800 NotImplemented = None # (!) real value is ‘‘
5801 
5802 __spec__ = None # (!) real value is ‘‘

集合set()

python set类是在python的sets模块中，大家现在使用的python2.7.x中，不需要导入sets模块可以直接创建集合。

集合（set）是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

Python 集合操作符和关系符号:

a = set()                     # 创建一个空set集合
b = set([1,2,3,4,5,6])        # 创建一个参数为list的set集合
c = set(("a","b","c","d"))    # 创建一个参数为元组的set集合
print(a)
print(b)
print(c)

以上实例输出结果：

set()
{1, 2, 3, 4, 5, 6}
{‘c‘, ‘a‘, ‘b‘, ‘d‘}

pop(随机删除并返回集合s中某个值

#!/usr/bin/python3

a = set()                     # 创建一个空set集合
b = set([1,2,3,4,5,6])        # 创建一个参数为list的set集合
c = set(("abc","bcd","cde","def"))    # 创建一个参数为元组的set集合
print("-----------添加-----------------")
a.add("boy")
a.add("playboy")
b.add(101)
c.add("gril")
print(a)
print(b)
print(c)
print("-----------删除clear pop remove-----------------")
a.clear()    #删除clear
print(a)

b.pop()      #pop() 随机删除并返回集合s中某个值
print(b)

#remove从集合中移除一个元素;它必须是一个成员。如果元素不是成员，则抛出一个关键错误

b.remove(101)

print(b)

　　代码执行结果：

-----------添加-----------------
{‘boy‘, ‘playboy‘}
{1, 2, 3, 4, 5, 6, 101}
{‘bcd‘, ‘gril‘, ‘abc‘, ‘cde‘, ‘def‘}
-----------删除clear pop remove-----------------
set()
{2, 3, 4, 5, 6, 101}
{2, 3, 4, 5, 6}

交集 intesection

#!/usr/bin/python3

#intesection
#交集
a = set([10,11,12,13])
b = set([12,13,14,15])
res = a.intersection(b)
print(a)
print(b)
print(res)
dif = a.difference(b)
print(dif)

执行结果：

{10, 11, 12, 13}
{12, 13, 14, 15}
{12, 13}
{10, 11}