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