在Python set是基本数据类型的一种集合类型，它有可变集合(set())和不可变集合(frozenset)两种。创建集合set、集合set添加、集合删除、交集、并集、差集的操作都是非常实用的方法。
创建集合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 ''
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中某个值
'''
学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：711312441
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
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
#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}
