标签：
查看整数类型的方法
>>> a = 1 >>> dir(a) [‘__abs__‘, ‘__add__‘, ‘__and__‘, ‘__class__‘, ‘__cmp__‘, ‘__coerce__‘, ‘__delattr__‘, ‘__div__‘, ‘__divmod__‘, ‘__doc__‘, ‘__float__‘, ‘__floordiv__‘, ‘__format__‘, ‘__getattribute__‘, ‘__getnewargs__‘, ‘__ha sh__‘, ‘__hex__‘, ‘__index__‘, ‘__init__‘, ‘__int__‘, ‘__invert__‘, ‘__long__‘, ‘__lshift__‘, ‘__mod__‘, ‘__mul__‘, ‘__neg__‘, ‘__new__‘, ‘__nonzero__‘, ‘__oct__‘, ‘__or__‘, ‘__pos__‘, ‘__pow__‘, ‘__radd__‘, ‘ __rand__‘, ‘__rdiv__‘, ‘__rdivmod__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__rfloordiv__‘, ‘__rlshift__‘, ‘__rmod__‘, ‘__rmul__‘, ‘__ror__‘, ‘__rpow__‘, ‘__rrshift__‘, ‘__rshift__‘, ‘__rsub__‘, ‘__rtrue div__‘, ‘__rxor__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__sub__‘, ‘__subclasshook__‘, ‘__truediv__‘, ‘__trunc__‘, ‘__xor__‘, ‘bit_length‘, ‘conjugate‘, ‘denominator‘, ‘imag‘, ‘numerator‘, ‘real‘] >>> type(a) <type ‘int‘>
或者在pycharm里面，输入int，按住crtl，然后鼠标点击int查看其方法
class int(object):
"""
int(x=0) -> int or long
int(x, base=10) -> int or long
Convert a number or string to an integer, or return 0 if no arguments
are given. If x is floating point, the conversion truncates towards zero.
If x is outside the integer range, the function returns a long instead.
If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base. The
literal can be preceded by ‘+‘ or ‘-‘ and be surrounded by whitespace.
The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to
interpret the base from the string as an integer literal.
>>> int(‘0b100‘, base=0)
4
"""
def bit_length(self): # real signature unknown; restored from __doc__
"""
int.bit_length() -> int
Number of bits necessary to represent self in binary.
>>> bin(37)
‘0b100101‘
>>> (37).bit_length()
6
"""
return 0
def conjugate(self, *args, **kwargs): # real signature unknown
""" Returns self, the complex conjugate of any int. """
pass
def __abs__(self): # real signature unknown; restored from __doc__
""" x.__abs__() <==> abs(x) """
pass
def __add__(self, y): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass
def __and__(self, y): # real signature unknown; restored from __doc__
""" x.__and__(y) <==> x&y """
pass
def __cmp__(self, y): # real signature unknown; restored from __doc__
""" x.__cmp__(y) <==> cmp(x,y) """
pass
def __coerce__(self, y): # real signature unknown; restored from __doc__
""" x.__coerce__(y) <==> coerce(x, y) """
pass
def __divmod__(self, y): # real signature unknown; restored from __doc__
""" x.__divmod__(y) <==> divmod(x, y) """
pass
def __div__(self, y): # real signature unknown; restored from __doc__
""" x.__div__(y) <==> x/y """
pass
def __float__(self): # real signature unknown; restored from __doc__
""" x.__float__() <==> float(x) """
pass
def __floordiv__(self, y): # real signature unknown; restored from __doc__
""" x.__floordiv__(y) <==> x//y """
pass
def __format__(self, *args, **kwargs): # real signature unknown
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown
pass
def __hash__(self): # real signature unknown; restored from __doc__
""" x.__hash__() <==> hash(x) """
pass
def __hex__(self): # real signature unknown; restored from __doc__
""" x.__hex__() <==> hex(x) """
pass
def __index__(self): # real signature unknown; restored from __doc__
""" x[y:z] <==> x[y.__index__():z.__index__()] """
pass
def __init__(self, x, base=10): # known special case of int.__init__
"""
int(x=0) -> int or long
int(x, base=10) -> int or long
Convert a number or string to an integer, or return 0 if no arguments
are given. If x is floating point, the conversion truncates towards zero.
If x is outside the integer range, the function returns a long instead.
If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base. The
literal can be preceded by ‘+‘ or ‘-‘ and be surrounded by whitespace.
The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to
interpret the base from the string as an integer literal.
>>> int(‘0b100‘, base=0)
4
# (copied from class doc)
"""
pass
def __int__(self): # real signature unknown; restored from __doc__
""" x.__int__() <==> int(x) """
pass
def __invert__(self): # real signature unknown; restored from __doc__
""" x.__invert__() <==> ~x """
pass
def __long__(self): # real signature unknown; restored from __doc__
""" x.__long__() <==> long(x) """
pass
def __lshift__(self, y): # real signature unknown; restored from __doc__
""" x.__lshift__(y) <==> x<<y """
pass
def __mod__(self, y): # real signature unknown; restored from __doc__
""" x.__mod__(y) <==> x%y """
pass
def __mul__(self, y): # real signature unknown; restored from __doc__
""" x.__mul__(y) <==> x*y """
pass
def __neg__(self): # real signature unknown; restored from __doc__
""" x.__neg__() <==> -x """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __nonzero__(self): # real signature unknown; restored from __doc__
""" x.__nonzero__() <==> x != 0 """
pass
def __oct__(self): # real signature unknown; restored from __doc__
""" x.__oct__() <==> oct(x) """
pass
def __or__(self, y): # real signature unknown; restored from __doc__
""" x.__or__(y) <==> x|y """
pass
def __pos__(self): # real signature unknown; restored from __doc__
""" x.__pos__() <==> +x """
pass
def __pow__(self, y, z=None): # real signature unknown; restored from __doc__
""" x.__pow__(y[, z]) <==> pow(x, y[, z]) """
pass
def __radd__(self, y): # real signature unknown; restored from __doc__
""" x.__radd__(y) <==> y+x """
pass
def __rand__(self, y): # real signature unknown; restored from __doc__
""" x.__rand__(y) <==> y&x """
pass
def __rdivmod__(self, y): # real signature unknown; restored from __doc__
""" x.__rdivmod__(y) <==> divmod(y, x) """
pass
def __rdiv__(self, y): # real signature unknown; restored from __doc__
""" x.__rdiv__(y) <==> y/x """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __rfloordiv__(self, y): # real signature unknown; restored from __doc__
""" x.__rfloordiv__(y) <==> y//x """
pass
def __rlshift__(self, y): # real signature unknown; restored from __doc__
""" x.__rlshift__(y) <==> y<<x """
pass
def __rmod__(self, y): # real signature unknown; restored from __doc__
""" x.__rmod__(y) <==> y%x """
pass
def __rmul__(self, y): # real signature unknown; restored from __doc__
""" x.__rmul__(y) <==> y*x """
pass
def __ror__(self, y): # real signature unknown; restored from __doc__
""" x.__ror__(y) <==> y|x """
pass
def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__
""" y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
pass
def __rrshift__(self, y): # real signature unknown; restored from __doc__
""" x.__rrshift__(y) <==> y>>x """
pass
def __rshift__(self, y): # real signature unknown; restored from __doc__
""" x.__rshift__(y) <==> x>>y """
pass
def __rsub__(self, y): # real signature unknown; restored from __doc__
""" x.__rsub__(y) <==> y-x """
pass
def __rtruediv__(self, y): # real signature unknown; restored from __doc__
""" x.__rtruediv__(y) <==> y/x """
pass
def __rxor__(self, y): # real signature unknown; restored from __doc__
""" x.__rxor__(y) <==> y^x """
pass
def __str__(self): # real signature unknown; restored from __doc__
""" x.__str__() <==> str(x) """
pass
def __sub__(self, y): # real signature unknown; restored from __doc__
""" x.__sub__(y) <==> x-y """
pass
def __truediv__(self, y): # real signature unknown; restored from __doc__
""" x.__truediv__(y) <==> x/y """
pass
def __trunc__(self, *args, **kwargs): # real signature unknown
""" Truncating an Integral returns itself. """
pass
def __xor__(self, y): # real signature unknown; restored from __doc__
""" x.__xor__(y) <==> x^y """
pass
denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""the denominator of a rational number in lowest terms"""
imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""the imaginary part of a complex number"""
numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""the numerator of a rational number in lowest terms"""
real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""the real part of a complex number"""
class bool(int):
"""
bool(x) -> bool
Returns True when the argument x is true, False otherwise.
The builtins True and False are the only two instances of the class bool.
The class bool is a subclass of the class int, and cannot be subclassed.
"""
def __and__(self, y): # real signature unknown; restored from __doc__
""" x.__and__(y) <==> x&y """
pass
def __init__(self, x): # real signature unknown; restored from __doc__
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __or__(self, y): # real signature unknown; restored from __doc__
""" x.__or__(y) <==> x|y """
pass
def __rand__(self, y): # real signature unknown; restored from __doc__
""" x.__rand__(y) <==> y&x """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __ror__(self, y): # real signature unknown; restored from __doc__
""" x.__ror__(y) <==> y|x """
pass
def __rxor__(self, y): # real signature unknown; restored from __doc__
""" x.__rxor__(y) <==> y^x """
pass
def __str__(self): # real signature unknown; restored from __doc__
""" x.__str__() <==> str(x) """
pass
def __xor__(self, y): # real signature unknown; restored from __doc__
""" x.__xor__(y) <==> x^y """
pass
class buffer(object):
"""
buffer(object [, offset[, size]])
Create a new buffer object which references the given object.
The buffer will reference a slice of the target object from the
start of the object (or at the specified offset). The slice will
extend to the end of the target object (or with the specified size).
"""
def __add__(self, y): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass
def __cmp__(self, y): # real signature unknown; restored from __doc__
""" x.__cmp__(y) <==> cmp(x,y) """
pass
def __delitem__(self, y): # real signature unknown; restored from __doc__
""" x.__delitem__(y) <==> del x[y] """
pass
def __delslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__delslice__(i, j) <==> del x[i:j]
Use of negative indices is not supported.
"""
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
def __getslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
"""
pass
def __hash__(self): # real signature unknown; restored from __doc__
""" x.__hash__() <==> hash(x) """
pass
def __init__(self, p_object, offset=None, size=None): # real signature unknown; restored from __doc__
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __mul__(self, n): # real signature unknown; restored from __doc__
""" x.__mul__(n) <==> x*n """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __rmul__(self, n): # real signature unknown; restored from __doc__
""" x.__rmul__(n) <==> n*x """
pass
def __setitem__(self, i, y): # real signature unknown; restored from __doc__
""" x.__setitem__(i, y) <==> x[i]=y """
pass
def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
"""
x.__setslice__(i, j, y) <==> x[i:j]=y
Use of negative indices is not supported.
"""
pass
def __str__(self): # real signature unknown; restored from __doc__
""" x.__str__() <==> str(x) """
pass
class bytearray(object):
"""
bytearray(iterable_of_ints) -> bytearray.
bytearray(string, encoding[, errors]) -> bytearray.
bytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray.
bytearray(memory_view) -> bytearray.
Construct an mutable bytearray object from:
- an iterable yielding integers in range(256)
- a text string encoded using the specified encoding
- a bytes or a bytearray object
- any object implementing the buffer API.
bytearray(int) -> bytearray.
Construct a zero-initialized bytearray of the given length.
"""
def append(self, p_int): # real signature unknown; restored from __doc__
"""
B.append(int) -> None
Append a single item to the end of B.
"""
pass
def capitalize(self): # real signature unknown; restored from __doc__
"""
B.capitalize() -> copy of B
Return a copy of B with only its first character capitalized (ASCII)
and the rest lower-cased.
"""
pass
def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
B.center(width[, fillchar]) -> copy of B
Return B centered in a string of length width. Padding is
done using the specified fill character (default is a space).
"""
pass
def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
B.count(sub [,start [,end]]) -> int
Return the number of non-overlapping occurrences of subsection sub in
bytes B[start:end]. Optional arguments start and end are interpreted
as in slice notation.
"""
return 0
def decode(self, encoding=None, errors=None): # real signature unknown; restored from __doc__
"""
B.decode([encoding[, errors]]) -> unicode object.
Decodes B 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 u""
def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
"""
B.endswith(suffix [,start [,end]]) -> bool
Return True if B ends with the specified suffix, False otherwise.
With optional start, test B beginning at that position.
With optional end, stop comparing B at that position.
suffix can also be a tuple of strings to try.
"""
return False
def expandtabs(self, tabsize=None): # real signature unknown; restored from __doc__
"""
B.expandtabs([tabsize]) -> copy of B
Return a copy of B where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
"""
pass
def extend(self, iterable_int): # real signature unknown; restored from __doc__
"""
B.extend(iterable int) -> None
Append all the elements from the iterator or sequence to the
end of B.
"""
pass
def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
B.find(sub [,start [,end]]) -> int
Return the lowest index in B where subsection sub is found,
such that sub is contained within B[start,end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
"""
return 0
@classmethod # known case
def fromhex(cls, string): # real signature unknown; restored from __doc__
"""
bytearray.fromhex(string) -> bytearray
Create a bytearray object from a string of hexadecimal numbers.
Spaces between two numbers are accepted.
Example: bytearray.fromhex(‘B9 01EF‘) -> bytearray(b‘\xb9\x01\xef‘).
"""
return bytearray
def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
B.index(sub [,start [,end]]) -> int
Like B.find() but raise ValueError when the subsection is not found.
"""
return 0
def insert(self, index, p_int): # real signature unknown; restored from __doc__
"""
B.insert(index, int) -> None
Insert a single item into the bytearray before the given index.
"""
pass
def isalnum(self): # real signature unknown; restored from __doc__
"""
B.isalnum() -> bool
Return True if all characters in B are alphanumeric
and there is at least one character in B, False otherwise.
"""
return False
def isalpha(self): # real signature unknown; restored from __doc__
"""
B.isalpha() -> bool
Return True if all characters in B are alphabetic
and there is at least one character in B, False otherwise.
"""
return False
def isdigit(self): # real signature unknown; restored from __doc__
"""
B.isdigit() -> bool
Return True if all characters in B are digits
and there is at least one character in B, False otherwise.
"""
return False
def islower(self): # real signature unknown; restored from __doc__
"""
B.islower() -> bool
Return True if all cased characters in B are lowercase and there is
at least one cased character in B, False otherwise.
"""
return False
def isspace(self): # real signature unknown; restored from __doc__
"""
B.isspace() -> bool
Return True if all characters in B are whitespace
and there is at least one character in B, False otherwise.
"""
return False
def istitle(self): # real signature unknown; restored from __doc__
"""
B.istitle() -> bool
Return True if B is a titlecased string and there is at least one
character in B, i.e. uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return False
otherwise.
"""
return False
def isupper(self): # real signature unknown; restored from __doc__
"""
B.isupper() -> bool
Return True if all cased characters in B are uppercase and there is
at least one cased character in B, False otherwise.
"""
return False
def join(self, iterable_of_bytes): # real signature unknown; restored from __doc__
"""
B.join(iterable_of_bytes) -> bytes
Concatenates any number of bytearray objects, with B in between each pair.
"""
return ""
def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
B.ljust(width[, fillchar]) -> copy of B
Return B left justified in a string of length width. Padding is
done using the specified fill character (default is a space).
"""
pass
def lower(self): # real signature unknown; restored from __doc__
"""
B.lower() -> copy of B
Return a copy of B with all ASCII characters converted to lowercase.
"""
pass
def lstrip(self, bytes=None): # real signature unknown; restored from __doc__
"""
B.lstrip([bytes]) -> bytearray
Strip leading bytes contained in the argument.
If the argument is omitted, strip leading ASCII whitespace.
"""
return bytearray
def partition(self, sep): # real signature unknown; restored from __doc__
"""
B.partition(sep) -> (head, sep, tail)
Searches for the separator sep in B, and returns the part before it,
the separator itself, and the part after it. If the separator is not
found, returns B and two empty bytearray objects.
"""
pass
def pop(self, index=None): # real signature unknown; restored from __doc__
"""
B.pop([index]) -> int
Remove and return a single item from B. If no index
argument is given, will pop the last value.
"""
return 0
def remove(self, p_int): # real signature unknown; restored from __doc__
"""
B.remove(int) -> None
Remove the first occurance of a value in B.
"""
pass
def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
"""
B.replace(old, new[, count]) -> bytes
Return a copy of B with all occurrences of subsection
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
"""
return ""
def reverse(self): # real signature unknown; restored from __doc__
"""
B.reverse() -> None
Reverse the order of the values in B in place.
"""
pass
def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
B.rfind(sub [,start [,end]]) -> int
Return the highest index in B where subsection sub is found,
such that sub is contained within B[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): # real signature unknown; restored from __doc__
"""
B.rindex(sub [,start [,end]]) -> int
Like B.rfind() but raise ValueError when the subsection is not found.
"""
return 0
def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
B.rjust(width[, fillchar]) -> copy of B
Return B right justified in a string of length width. Padding is
done using the specified fill character (default is a space)
"""
pass
def rpartition(self, sep): # real signature unknown; restored from __doc__
"""
B.rpartition(sep) -> (head, sep, tail)
Searches for the separator sep in B, starting at the end of B,
and returns the part before it, the separator itself, and the
part after it. If the separator is not found, returns two empty
bytearray objects and B.
"""
pass
def rsplit(self, sep, maxsplit=None): # real signature unknown; restored from __doc__
"""
B.rsplit(sep[, maxsplit]) -> list of bytearray
Return a list of the sections in B, using sep as the delimiter,
starting at the end of B and working to the front.
If sep is not given, B is split on ASCII whitespace characters
(space, tab, return, newline, formfeed, vertical tab).
If maxsplit is given, at most maxsplit splits are done.
"""
return []
def rstrip(self, bytes=None): # real signature unknown; restored from __doc__
"""
B.rstrip([bytes]) -> bytearray
Strip trailing bytes contained in the argument.
If the argument is omitted, strip trailing ASCII whitespace.
"""
return bytearray
def split(self, sep=None, maxsplit=None): # real signature unknown; restored from __doc__
"""
B.split([sep[, maxsplit]]) -> list of bytearray
Return a list of the sections in B, using sep as the delimiter.
If sep is not given, B is split on ASCII whitespace characters
(space, tab, return, newline, formfeed, vertical tab).
If maxsplit is given, at most maxsplit splits are done.
"""
return []
def splitlines(self, keepends=False): # real signature unknown; restored from __doc__
"""
B.splitlines(keepends=False) -> list of lines
Return a list of the lines in B, 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): # real signature unknown; restored from __doc__
"""
B.startswith(prefix [,start [,end]]) -> bool
Return True if B starts with the specified prefix, False otherwise.
With optional start, test B beginning at that position.
With optional end, stop comparing B at that position.
prefix can also be a tuple of strings to try.
"""
return False
def strip(self, bytes=None): # real signature unknown; restored from __doc__
"""
B.strip([bytes]) -> bytearray
Strip leading and trailing bytes contained in the argument.
If the argument is omitted, strip ASCII whitespace.
"""
return bytearray
def swapcase(self): # real signature unknown; restored from __doc__
"""
B.swapcase() -> copy of B
Return a copy of B with uppercase ASCII characters converted
to lowercase ASCII and vice versa.
"""
pass
def title(self): # real signature unknown; restored from __doc__
"""
B.title() -> copy of B
Return a titlecased version of B, i.e. ASCII words start with uppercase
characters, all remaining cased characters have lowercase.
"""
pass
def translate(self, table, deletechars=None): # real signature unknown; restored from __doc__
"""
B.translate(table[, deletechars]) -> bytearray
Return a copy of B, 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 bytes object of length 256.
"""
return bytearray
def upper(self): # real signature unknown; restored from __doc__
"""
B.upper() -> copy of B
Return a copy of B with all ASCII characters converted to uppercase.
"""
pass
def zfill(self, width): # real signature unknown; restored from __doc__
"""
B.zfill(width) -> copy of B
Pad a numeric string B with zeros on the left, to fill a field
of the specified width. B is never truncated.
"""
pass
def __add__(self, y): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass
def __alloc__(self): # real signature unknown; restored from __doc__
"""
B.__alloc__() -> int
Returns the number of bytes actually allocated.
"""
return 0
def __contains__(self, y): # real signature unknown; restored from __doc__
""" x.__contains__(y) <==> y in x """
pass
def __delitem__(self, y): # real signature unknown; restored from __doc__
""" x.__delitem__(y) <==> del x[y] """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __iadd__(self, y): # real signature unknown; restored from __doc__
""" x.__iadd__(y) <==> x+=y """
pass
def __imul__(self, y): # real signature unknown; restored from __doc__
""" x.__imul__(y) <==> x*=y """
pass
def __init__(self, source=None, encoding=None, errors=‘strict‘): # known special case of bytearray.__init__
"""
bytearray(iterable_of_ints) -> bytearray.
bytearray(string, encoding[, errors]) -> bytearray.
bytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray.
bytearray(memory_view) -> bytearray.
Construct an mutable bytearray object from:
- an iterable yielding integers in range(256)
- a text string encoded using the specified encoding
- a bytes or a bytearray object
- any object implementing the buffer API.
bytearray(int) -> bytearray.
Construct a zero-initialized bytearray of the given length.
# (copied from class doc)
"""
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
def __mul__(self, n): # real signature unknown; restored from __doc__
""" x.__mul__(n) <==> x*n """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __reduce__(self, *args, **kwargs): # real signature unknown
""" Return state information for pickling. """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __rmul__(self, n): # real signature unknown; restored from __doc__
""" x.__rmul__(n) <==> n*x """
pass
def __setitem__(self, i, y): # real signature unknown; restored from __doc__
""" x.__setitem__(i, y) <==> x[i]=y """
pass
def __sizeof__(self): # real signature unknown; restored from __doc__
"""
B.__sizeof__() -> int
Returns the size of B in memory, in bytes
"""
return 0
def __str__(self): # real signature unknown; restored from __doc__
""" x.__str__() <==> str(x) """
pass
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): # real signature unknown; restored from __doc__
"""
S.capitalize() -> string
Return a copy of the string S with only its first character
capitalized.
"""
return ""
def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
"""
return 0
def isalnum(self): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
S.lower() -> string
Return a copy of the string S converted to lowercase.
"""
return ""
def lstrip(self, chars=None): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
S.swapcase() -> string
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
"""
return ""
def title(self): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
S.upper() -> string
Return a copy of the string S converted to uppercase.
"""
return ""
def zfill(self, width): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass
def __contains__(self, y): # real signature unknown; restored from __doc__
""" x.__contains__(y) <==> y in x """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __format__(self, format_spec): # real signature unknown; restored from __doc__
"""
S.__format__(format_spec) -> string
Return a formatted version of S as described by format_spec.
"""
return ""
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown
pass
def __getslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
"""
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __hash__(self): # real signature unknown; restored from __doc__
""" 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): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
def __mod__(self, y): # real signature unknown; restored from __doc__
""" x.__mod__(y) <==> x%y """
pass
def __mul__(self, n): # real signature unknown; restored from __doc__
""" x.__mul__(n) <==> x*n """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __rmod__(self, y): # real signature unknown; restored from __doc__
""" x.__rmod__(y) <==> y%x """
pass
def __rmul__(self, n): # real signature unknown; restored from __doc__
""" x.__rmul__(n) <==> n*x """
pass
def __sizeof__(self): # real signature unknown; restored from __doc__
""" S.__sizeof__() -> size of S in memory, in bytes """
pass
def __str__(self): # real signature unknown; restored from __doc__
""" x.__str__() <==> str(x) """
pass
bytes = str
class classmethod(object):
"""
classmethod(function) -> method
Convert a function to be a class method.
A class method receives the class as implicit first argument,
just like an instance method receives the instance.
To declare a class method, use this idiom:
class C:
def f(cls, arg1, arg2, ...): ...
f = classmethod(f)
It can be called either on the class (e.g. C.f()) or on an instance
(e.g. C().f()). The instance is ignored except for its class.
If a class method is called for a derived class, the derived class
object is passed as the implied first argument.
Class methods are different than C++ or Java static methods.
If you want those, see the staticmethod builtin.
"""
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __get__(self, obj, type=None): # real signature unknown; restored from __doc__
""" descr.__get__(obj[, type]) -> value """
pass
def __init__(self, function): # real signature unknown; restored from __doc__
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
__func__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
class complex(object):
"""
complex(real[, imag]) -> complex number
Create a complex number from a real part and an optional imaginary part.
This is equivalent to (real + imag*1j) where imag defaults to 0.
"""
def conjugate(self): # real signature unknown; restored from __doc__
"""
complex.conjugate() -> complex
Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.
"""
return complex
def __abs__(self): # real signature unknown; restored from __doc__
""" x.__abs__() <==> abs(x) """
pass
def __add__(self, y): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass
def __coerce__(self, y): # real signature unknown; restored from __doc__
""" x.__coerce__(y) <==> coerce(x, y) """
pass
def __divmod__(self, y): # real signature unknown; restored from __doc__
""" x.__divmod__(y) <==> divmod(x, y) """
pass
def __div__(self, y): # real signature unknown; restored from __doc__
""" x.__div__(y) <==> x/y """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __float__(self): # real signature unknown; restored from __doc__
""" x.__float__() <==> float(x) """
pass
def __floordiv__(self, y): # real signature unknown; restored from __doc__
""" x.__floordiv__(y) <==> x//y """
pass
def __format__(self): # real signature unknown; restored from __doc__
"""
complex.__format__() -> str
Convert to a string according to format_spec.
"""
return ""
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __hash__(self): # real signature unknown; restored from __doc__
""" x.__hash__() <==> hash(x) """
pass
def __init__(self, real, imag=None): # real signature unknown; restored from __doc__
pass
def __int__(self): # real signature unknown; restored from __doc__
""" x.__int__() <==> int(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __long__(self): # real signature unknown; restored from __doc__
""" x.__long__() <==> long(x) """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
def __mod__(self, y): # real signature unknown; restored from __doc__
""" x.__mod__(y) <==> x%y """
pass
def __mul__(self, y): # real signature unknown; restored from __doc__
""" x.__mul__(y) <==> x*y """
pass
def __neg__(self): # real signature unknown; restored from __doc__
""" x.__neg__() <==> -x """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __nonzero__(self): # real signature unknown; restored from __doc__
""" x.__nonzero__() <==> x != 0 """
pass
def __pos__(self): # real signature unknown; restored from __doc__
""" x.__pos__() <==> +x """
pass
def __pow__(self, y, z=None): # real signature unknown; restored from __doc__
""" x.__pow__(y[, z]) <==> pow(x, y[, z]) """
pass
def __radd__(self, y): # real signature unknown; restored from __doc__
""" x.__radd__(y) <==> y+x """
pass
def __rdivmod__(self, y): # real signature unknown; restored from __doc__
""" x.__rdivmod__(y) <==> divmod(y, x) """
pass
def __rdiv__(self, y): # real signature unknown; restored from __doc__
""" x.__rdiv__(y) <==> y/x """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __rfloordiv__(self, y): # real signature unknown; restored from __doc__
""" x.__rfloordiv__(y) <==> y//x """
pass
def __rmod__(self, y): # real signature unknown; restored from __doc__
""" x.__rmod__(y) <==> y%x """
pass
def __rmul__(self, y): # real signature unknown; restored from __doc__
""" x.__rmul__(y) <==> y*x """
pass
def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__
""" y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
pass
def __rsub__(self, y): # real signature unknown; restored from __doc__
""" x.__rsub__(y) <==> y-x """
pass
def __rtruediv__(self, y): # real signature unknown; restored from __doc__
""" x.__rtruediv__(y) <==> y/x """
pass
def __str__(self): # real signature unknown; restored from __doc__
""" x.__str__() <==> str(x) """
pass
def __sub__(self, y): # real signature unknown; restored from __doc__
""" x.__sub__(y) <==> x-y """
pass
def __truediv__(self, y): # real signature unknown; restored from __doc__
""" x.__truediv__(y) <==> x/y """
pass
imag = property(lambda self: 0.0)
"""the imaginary part of a complex number
:type: float
"""
real = property(lambda self: 0.0)
"""the real part of a complex number
:type: float
"""
class dict(object):
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object‘s
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
"""
def clear(self): # real signature unknown; restored from __doc__
""" D.clear() -> None. Remove all items from D. """
pass
def copy(self): # real signature unknown; restored from __doc__
""" D.copy() -> a shallow copy of D """
pass
@staticmethod # known case
def fromkeys(S, v=None): # real signature unknown; restored from __doc__
"""
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.
"""
pass
def get(self, k, d=None): # real signature unknown; restored from __doc__
""" D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """
pass
def has_key(self, k): # real signature unknown; restored from __doc__
""" D.has_key(k) -> True if D has a key k, else False """
return False
def items(self): # real signature unknown; restored from __doc__
""" D.items() -> list of D‘s (key, value) pairs, as 2-tuples """
return []
def iteritems(self): # real signature unknown; restored from __doc__
""" D.iteritems() -> an iterator over the (key, value) items of D """
pass
def iterkeys(self): # real signature unknown; restored from __doc__
""" D.iterkeys() -> an iterator over the keys of D """
pass
def itervalues(self): # real signature unknown; restored from __doc__
""" D.itervalues() -> an iterator over the values of D """
pass
def keys(self): # real signature unknown; restored from __doc__
""" D.keys() -> list of D‘s keys """
return []
def pop(self, k, d=None): # real signature unknown; restored from __doc__
"""
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
"""
pass
def popitem(self): # real signature unknown; restored from __doc__
"""
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
"""
pass
def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
""" D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
pass
def update(self, E=None, **F): # known special case of dict.update
"""
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E present and has a .keys() method, does: for k in E: D[k] = E[k]
If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
"""
pass
def values(self): # real signature unknown; restored from __doc__
""" D.values() -> list of D‘s values """
return []
def viewitems(self): # real signature unknown; restored from __doc__
""" D.viewitems() -> a set-like object providing a view on D‘s items """
pass
def viewkeys(self): # real signature unknown; restored from __doc__
""" D.viewkeys() -> a set-like object providing a view on D‘s keys """
pass
def viewvalues(self): # real signature unknown; restored from __doc__
""" D.viewvalues() -> an object providing a view on D‘s values """
pass
def __cmp__(self, y): # real signature unknown; restored from __doc__
""" x.__cmp__(y) <==> cmp(x,y) """
pass
def __contains__(self, k): # real signature unknown; restored from __doc__
""" D.__contains__(k) -> True if D has a key k, else False """
return False
def __delitem__(self, y): # real signature unknown; restored from __doc__
""" x.__delitem__(y) <==> del x[y] """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object‘s
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
# (copied from class doc)
"""
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __setitem__(self, i, y): # real signature unknown; restored from __doc__
""" x.__setitem__(i, y) <==> x[i]=y """
pass
def __sizeof__(self): # real signature unknown; restored from __doc__
""" D.__sizeof__() -> size of D in memory, in bytes """
pass
__hash__ = None
class enumerate(object):
"""
enumerate(iterable[, start]) -> iterator for index, value of iterable
Return an enumerate object. iterable must be another object that supports
iteration. The enumerate object yields pairs containing a count (from
start, which defaults to zero) and a value yielded by the iterable argument.
enumerate is useful for obtaining an indexed list:
(0, seq[0]), (1, seq[1]), (2, seq[2]), ...
"""
def next(self): # real signature unknown; restored from __doc__
""" x.next() -> the next value, or raise StopIteration """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __init__(self, iterable, start=0): # known special case of enumerate.__init__
""" x.__init__(...) initializes x; see help(type(x)) for signature """
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
class file(object):
"""
file(name[, mode[, buffering]]) -> file object
Open a file. The mode can be ‘r‘, ‘w‘ or ‘a‘ for reading (default),
writing or appending. The file will be created if it doesn‘t exist
when opened for writing or appending; it will be truncated when
opened for writing. Add a ‘b‘ to the mode for binary files.
Add a ‘+‘ to the mode to allow simultaneous reading and writing.
If the buffering argument is given, 0 means unbuffered, 1 means line
buffered, and larger numbers specify the buffer size. The preferred way
to open a file is with the builtin open() function.
Add a ‘U‘ to mode to open the file for input with universal newline
support. Any line ending in the input file will be seen as a ‘\n‘
in Python. Also, a file so opened gains the attribute ‘newlines‘;
the value for this attribute is one of None (no newline read yet),
‘\r‘, ‘\n‘, ‘\r\n‘ or a tuple containing all the newline types seen.
‘U‘ cannot be combined with ‘w‘ or ‘+‘ mode.
"""
def close(self): # real signature unknown; restored from __doc__
"""
close() -> None or (perhaps) an integer. Close the file.
Sets data attribute .closed to True. A closed file cannot be used for
further I/O operations. close() may be called more than once without
error. Some kinds of file objects (for example, opened by popen())
may return an exit status upon closing.
"""
pass
def fileno(self): # real signature unknown; restored from __doc__
"""
fileno() -> integer "file descriptor".
This is needed for lower-level file interfaces, such os.read().
"""
return 0
def flush(self): # real signature unknown; restored from __doc__
""" flush() -> None. Flush the internal I/O buffer. """
pass
def isatty(self): # real signature unknown; restored from __doc__
""" isatty() -> true or false. True if the file is connected to a tty device. """
return False
def next(self): # real signature unknown; restored from __doc__
""" x.next() -> the next value, or raise StopIteration """
pass
def read(self, size=None): # real signature unknown; restored from __doc__
"""
read([size]) -> read at most size bytes, returned as a string.
If the size argument is negative or omitted, read until EOF is reached.
Notice that when in non-blocking mode, less data than what was requested
may be returned, even if no size parameter was given.
"""
pass
def readinto(self): # real signature unknown; restored from __doc__
""" readinto() -> Undocumented. Don‘t use this; it may go away. """
pass
def readline(self, size=None): # real signature unknown; restored from __doc__
"""
readline([size]) -> next line from the file, as a string.
Retain newline. A non-negative size argument limits the maximum
number of bytes to return (an incomplete line may be returned then).
Return an empty string at EOF.
"""
pass
def readlines(self, size=None): # real signature unknown; restored from __doc__
"""
readlines([size]) -> list of strings, each a line from the file.
Call readline() repeatedly and return a list of the lines so read.
The optional size argument, if given, is an approximate bound on the
total number of bytes in the lines returned.
"""
return []
def seek(self, offset, whence=None): # real signature unknown; restored from __doc__
"""
seek(offset[, whence]) -> None. Move to new file position.
Argument offset is a byte count. Optional argument whence defaults to
0 (offset from start of file, offset should be >= 0); other values are 1
(move relative to current position, positive or negative), and 2 (move
relative to end of file, usually negative, although many platforms allow
seeking beyond the end of a file). If the file is opened in text mode,
only offsets returned by tell() are legal. Use of other offsets causes
undefined behavior.
Note that not all file objects are seekable.
"""
pass
def tell(self): # real signature unknown; restored from __doc__
""" tell() -> current file position, an integer (may be a long integer). """
pass
def truncate(self, size=None): # real signature unknown; restored from __doc__
"""
truncate([size]) -> None. Truncate the file to at most size bytes.
Size defaults to the current file position, as returned by tell().
"""
pass
def write(self, p_str): # real signature unknown; restored from __doc__
"""
write(str) -> None. Write string str to file.
Note that due to buffering, flush() or close() may be needed before
the file on disk reflects the data written.
"""
pass
def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__
"""
writelines(sequence_of_strings) -> None. Write the strings to the file.
Note that newlines are not added. The sequence can be any iterable object
producing strings. This is equivalent to calling write() for each string.
"""
pass
def xreadlines(self): # real signature unknown; restored from __doc__
"""
xreadlines() -> returns self.
For backward compatibility. File objects now include the performance
optimizations previously implemented in the xreadlines module.
"""
pass
def __delattr__(self, name): # real signature unknown; restored from __doc__
""" x.__delattr__(‘name‘) <==> del x.name """
pass
def __enter__(self): # real signature unknown; restored from __doc__
""" __enter__() -> self. """
return self
def __exit__(self, *excinfo): # real signature unknown; restored from __doc__
""" __exit__(*excinfo) -> None. Closes the file. """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __init__(self, name, mode=None, buffering=None): # real signature unknown; restored from __doc__
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __setattr__(self, name, value): # real signature unknown; restored from __doc__
""" x.__setattr__(‘name‘, value) <==> x.name = value """
pass
closed = property(lambda self: True)
"""True if the file is closed
:type: bool
"""
encoding = property(lambda self: ‘‘)
"""file encoding
:type: string
"""
errors = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""Unicode error handler"""
mode = property(lambda self: ‘‘)
"""file mode (‘r‘, ‘U‘, ‘w‘, ‘a‘, possibly with ‘b‘ or ‘+‘ added)
:type: string
"""
name = property(lambda self: ‘‘)
"""file name
:type: string
"""
newlines = property(lambda self: ‘‘)
"""end-of-line convention used in this file
:type: string
"""
softspace = property(lambda self: True)
"""flag indicating that a space needs to be printed; used by print
:type: bool
"""
class float(object):
"""
float(x) -> floating point number
Convert a string or number to a floating point number, if possible.
"""
def as_integer_ratio(self): # real signature unknown; restored from __doc__
"""
float.as_integer_ratio() -> (int, int)
Return a pair of integers, whose ratio is exactly equal to the original
float and with a positive denominator.
Raise OverflowError on infinities and a ValueError on NaNs.
>>> (10.0).as_integer_ratio()
(10, 1)
>>> (0.0).as_integer_ratio()
(0, 1)
>>> (-.25).as_integer_ratio()
(-1, 4)
"""
pass
def conjugate(self, *args, **kwargs): # real signature unknown
""" Return self, the complex conjugate of any float. """
pass
def fromhex(self, string): # real signature unknown; restored from __doc__
"""
float.fromhex(string) -> float
Create a floating-point number from a hexadecimal string.
>>> float.fromhex(‘0x1.ffffp10‘)
2047.984375
>>> float.fromhex(‘-0x1p-1074‘)
-4.9406564584124654e-324
"""
return 0.0
def hex(self): # real signature unknown; restored from __doc__
"""
float.hex() -> string
Return a hexadecimal representation of a floating-point number.
>>> (-0.1).hex()
‘-0x1.999999999999ap-4‘
>>> 3.14159.hex()
‘0x1.921f9f01b866ep+1‘
"""
return ""
def is_integer(self, *args, **kwargs): # real signature unknown
""" Return True if the float is an integer. """
pass
def __abs__(self): # real signature unknown; restored from __doc__
""" x.__abs__() <==> abs(x) """
pass
def __add__(self, y): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass
def __coerce__(self, y): # real signature unknown; restored from __doc__
""" x.__coerce__(y) <==> coerce(x, y) """
pass
def __divmod__(self, y): # real signature unknown; restored from __doc__
""" x.__divmod__(y) <==> divmod(x, y) """
pass
def __div__(self, y): # real signature unknown; restored from __doc__
""" x.__div__(y) <==> x/y """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __float__(self): # real signature unknown; restored from __doc__
""" x.__float__() <==> float(x) """
pass
def __floordiv__(self, y): # real signature unknown; restored from __doc__
""" x.__floordiv__(y) <==> x//y """
pass
def __format__(self, format_spec): # real signature unknown; restored from __doc__
"""
float.__format__(format_spec) -> string
Formats the float according to format_spec.
"""
return ""
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getformat__(self, typestr): # real signature unknown; restored from __doc__
"""
float.__getformat__(typestr) -> string
You probably don‘t want to use this function. It exists mainly to be
used in Python‘s test suite.
typestr must be ‘double‘ or ‘float‘. This function returns whichever of
‘unknown‘, ‘IEEE, big-endian‘ or ‘IEEE, little-endian‘ best describes the
format of floating point numbers used by the C type named by typestr.
"""
return ""
def __getnewargs__(self, *args, **kwargs): # real signature unknown
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __hash__(self): # real signature unknown; restored from __doc__
""" x.__hash__() <==> hash(x) """
pass
def __init__(self, x): # real signature unknown; restored from __doc__
pass
def __int__(self): # real signature unknown; restored from __doc__
""" x.__int__() <==> int(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __long__(self): # real signature unknown; restored from __doc__
""" x.__long__() <==> long(x) """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
def __mod__(self, y): # real signature unknown; restored from __doc__
""" x.__mod__(y) <==> x%y """
pass
def __mul__(self, y): # real signature unknown; restored from __doc__
""" x.__mul__(y) <==> x*y """
pass
def __neg__(self): # real signature unknown; restored from __doc__
""" x.__neg__() <==> -x """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __nonzero__(self): # real signature unknown; restored from __doc__
""" x.__nonzero__() <==> x != 0 """
pass
def __pos__(self): # real signature unknown; restored from __doc__
""" x.__pos__() <==> +x """
pass
def __pow__(self, y, z=None): # real signature unknown; restored from __doc__
""" x.__pow__(y[, z]) <==> pow(x, y[, z]) """
pass
def __radd__(self, y): # real signature unknown; restored from __doc__
""" x.__radd__(y) <==> y+x """
pass
def __rdivmod__(self, y): # real signature unknown; restored from __doc__
""" x.__rdivmod__(y) <==> divmod(y, x) """
pass
def __rdiv__(self, y): # real signature unknown; restored from __doc__
""" x.__rdiv__(y) <==> y/x """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __rfloordiv__(self, y): # real signature unknown; restored from __doc__
""" x.__rfloordiv__(y) <==> y//x """
pass
def __rmod__(self, y): # real signature unknown; restored from __doc__
""" x.__rmod__(y) <==> y%x """
pass
def __rmul__(self, y): # real signature unknown; restored from __doc__
""" x.__rmul__(y) <==> y*x """
pass
def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__
""" y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
pass
def __rsub__(self, y): # real signature unknown; restored from __doc__
""" x.__rsub__(y) <==> y-x """
pass
def __rtruediv__(self, y): # real signature unknown; restored from __doc__
""" x.__rtruediv__(y) <==> y/x """
pass
def __setformat__(self, typestr, fmt): # real signature unknown; restored from __doc__
"""
float.__setformat__(typestr, fmt) -> None
You probably don‘t want to use this function. It exists mainly to be
used in Python‘s test suite.
typestr must be ‘double‘ or ‘float‘. fmt must be one of ‘unknown‘,
‘IEEE, big-endian‘ or ‘IEEE, little-endian‘, and in addition can only be
one of the latter two if it appears to match the underlying C reality.
Override the automatic determination of C-level floating point type.
This affects how floats are converted to and from binary strings.
"""
pass
def __str__(self): # real signature unknown; restored from __doc__
""" x.__str__() <==> str(x) """
pass
def __sub__(self, y): # real signature unknown; restored from __doc__
""" x.__sub__(y) <==> x-y """
pass
def __truediv__(self, y): # real signature unknown; restored from __doc__
""" x.__truediv__(y) <==> x/y """
pass
def __trunc__(self, *args, **kwargs): # real signature unknown
""" Return the Integral closest to x between 0 and x. """
pass
imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""the imaginary part of a complex number"""
real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""the real part of a complex number"""
class frozenset(object):
"""
frozenset() -> empty frozenset object
frozenset(iterable) -> frozenset object
Build an immutable unordered collection of unique elements.
"""
def copy(self, *args, **kwargs): # real signature unknown
""" Return a shallow copy of a set. """
pass
def difference(self, *args, **kwargs): # real signature unknown
"""
Return the difference of two or more sets as a new set.
(i.e. all elements that are in this set but not the others.)
"""
pass
def intersection(self, *args, **kwargs): # real signature unknown
"""
Return the intersection of two or more sets as a new set.
(i.e. elements that are common to all of the sets.)
"""
pass
def isdisjoint(self, *args, **kwargs): # real signature unknown
""" Return True if two sets have a null intersection. """
pass
def issubset(self, *args, **kwargs): # real signature unknown
""" Report whether another set contains this set. """
pass
def issuperset(self, *args, **kwargs): # real signature unknown
""" Report whether this set contains another set. """
pass
def symmetric_difference(self, *args, **kwargs): # real signature unknown
"""
Return the symmetric difference of two sets as a new set.
(i.e. all elements that are in exactly one of the sets.)
"""
pass
def union(self, *args, **kwargs): # real signature unknown
"""
Return the union of sets as a new set.
(i.e. all elements that are in either set.)
"""
pass
def __and__(self, y): # real signature unknown; restored from __doc__
""" x.__and__(y) <==> x&y """
pass
def __cmp__(self, y): # real signature unknown; restored from __doc__
""" x.__cmp__(y) <==> cmp(x,y) """
pass
def __contains__(self, y): # real signature unknown; restored from __doc__
""" x.__contains__(y) <==> y in x. """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __hash__(self): # real signature unknown; restored from __doc__
""" x.__hash__() <==> hash(x) """
pass
def __init__(self, seq=()): # known special case of frozenset.__init__
""" x.__init__(...) initializes x; see help(type(x)) for signature """
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __or__(self, y): # real signature unknown; restored from __doc__
""" x.__or__(y) <==> x|y """
pass
def __rand__(self, y): # real signature unknown; restored from __doc__
""" x.__rand__(y) <==> y&x """
pass
def __reduce__(self, *args, **kwargs): # real signature unknown
""" Return state information for pickling. """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __ror__(self, y): # real signature unknown; restored from __doc__
""" x.__ror__(y) <==> y|x """
pass
def __rsub__(self, y): # real signature unknown; restored from __doc__
""" x.__rsub__(y) <==> y-x """
pass
def __rxor__(self, y): # real signature unknown; restored from __doc__
""" x.__rxor__(y) <==> y^x """
pass
def __sizeof__(self): # real signature unknown; restored from __doc__
""" S.__sizeof__() -> size of S in memory, in bytes """
pass
def __sub__(self, y): # real signature unknown; restored from __doc__
""" x.__sub__(y) <==> x-y """
pass
def __xor__(self, y): # real signature unknown; restored from __doc__
""" x.__xor__(y) <==> x^y """
pass
class list(object):
"""
list() -> new empty list
list(iterable) -> new list initialized from iterable‘s items
"""
def append(self, p_object): # real signature unknown; restored from __doc__
""" L.append(object) -- append object to end """
pass
def count(self, value): # real signature unknown; restored from __doc__
""" L.count(value) -> integer -- return number of occurrences of value """
return 0
def extend(self, iterable): # real signature unknown; restored from __doc__
""" L.extend(iterable) -- extend list by appending elements from the iterable """
pass
def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
"""
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
"""
return 0
def insert(self, index, p_object): # real signature unknown; restored from __doc__
""" L.insert(index, object) -- insert object before index """
pass
def pop(self, index=None): # real signature unknown; restored from __doc__
"""
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
"""
pass
def remove(self, value): # real signature unknown; restored from __doc__
"""
L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.
"""
pass
def reverse(self): # real signature unknown; restored from __doc__
""" L.reverse() -- reverse *IN PLACE* """
pass
def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__
"""
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1
"""
pass
def __add__(self, y): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass
def __contains__(self, y): # real signature unknown; restored from __doc__
""" x.__contains__(y) <==> y in x """
pass
def __delitem__(self, y): # real signature unknown; restored from __doc__
""" x.__delitem__(y) <==> del x[y] """
pass
def __delslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__delslice__(i, j) <==> del x[i:j]
Use of negative indices is not supported.
"""
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
def __getslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
"""
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __iadd__(self, y): # real signature unknown; restored from __doc__
""" x.__iadd__(y) <==> x+=y """
pass
def __imul__(self, y): # real signature unknown; restored from __doc__
""" x.__imul__(y) <==> x*=y """
pass
def __init__(self, seq=()): # known special case of list.__init__
"""
list() -> new empty list
list(iterable) -> new list initialized from iterable‘s items
# (copied from class doc)
"""
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
def __mul__(self, n): # real signature unknown; restored from __doc__
""" x.__mul__(n) <==> x*n """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __reversed__(self): # real signature unknown; restored from __doc__
""" L.__reversed__() -- return a reverse iterator over the list """
pass
def __rmul__(self, n): # real signature unknown; restored from __doc__
""" x.__rmul__(n) <==> n*x """
pass
def __setitem__(self, i, y): # real signature unknown; restored from __doc__
""" x.__setitem__(i, y) <==> x[i]=y """
pass
def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
"""
x.__setslice__(i, j, y) <==> x[i:j]=y
Use of negative indices is not supported.
"""
pass
def __sizeof__(self): # real signature unknown; restored from __doc__
""" L.__sizeof__() -- size of L in memory, in bytes """
pass
__hash__ = None
class long(object):
"""
long(x=0) -> long
long(x, base=10) -> long
Convert a number or string to a long integer, or return 0L if no arguments
are given. If x is floating point, the conversion truncates towards zero.
If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base. The
literal can be preceded by ‘+‘ or ‘-‘ and be surrounded by whitespace.
The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to
interpret the base from the string as an integer literal.
>>> int(‘0b100‘, base=0)
4L
"""
def bit_length(self): # real signature unknown; restored from __doc__
"""
long.bit_length() -> int or long
Number of bits necessary to represent self in binary.
>>> bin(37L)
‘0b100101‘
>>> (37L).bit_length()
6
"""
return 0
def conjugate(self, *args, **kwargs): # real signature unknown
""" Returns self, the complex conjugate of any long. """
pass
def __abs__(self): # real signature unknown; restored from __doc__
""" x.__abs__() <==> abs(x) """
pass
def __add__(self, y): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass
def __and__(self, y): # real signature unknown; restored from __doc__
""" x.__and__(y) <==> x&y """
pass
def __cmp__(self, y): # real signature unknown; restored from __doc__
""" x.__cmp__(y) <==> cmp(x,y) """
pass
def __coerce__(self, y): # real signature unknown; restored from __doc__
""" x.__coerce__(y) <==> coerce(x, y) """
pass
def __divmod__(self, y): # real signature unknown; restored from __doc__
""" x.__divmod__(y) <==> divmod(x, y) """
pass
def __div__(self, y): # real signature unknown; restored from __doc__
""" x.__div__(y) <==> x/y """
pass
def __float__(self): # real signature unknown; restored from __doc__
""" x.__float__() <==> float(x) """
pass
def __floordiv__(self, y): # real signature unknown; restored from __doc__
""" x.__floordiv__(y) <==> x//y """
pass
def __format__(self, *args, **kwargs): # real signature unknown
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown
pass
def __hash__(self): # real signature unknown; restored from __doc__
""" x.__hash__() <==> hash(x) """
pass
def __hex__(self): # real signature unknown; restored from __doc__
""" x.__hex__() <==> hex(x) """
pass
def __index__(self): # real signature unknown; restored from __doc__
""" x[y:z] <==> x[y.__index__():z.__index__()] """
pass
def __init__(self, x=0): # real signature unknown; restored from __doc__
pass
def __int__(self): # real signature unknown; restored from __doc__
""" x.__int__() <==> int(x) """
pass
def __invert__(self): # real signature unknown; restored from __doc__
""" x.__invert__() <==> ~x """
pass
def __long__(self): # real signature unknown; restored from __doc__
""" x.__long__() <==> long(x) """
pass
def __lshift__(self, y): # real signature unknown; restored from __doc__
""" x.__lshift__(y) <==> x<<y """
pass
def __mod__(self, y): # real signature unknown; restored from __doc__
""" x.__mod__(y) <==> x%y """
pass
def __mul__(self, y): # real signature unknown; restored from __doc__
""" x.__mul__(y) <==> x*y """
pass
def __neg__(self): # real signature unknown; restored from __doc__
""" x.__neg__() <==> -x """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __nonzero__(self): # real signature unknown; restored from __doc__
""" x.__nonzero__() <==> x != 0 """
pass
def __oct__(self): # real signature unknown; restored from __doc__
""" x.__oct__() <==> oct(x) """
pass
def __or__(self, y): # real signature unknown; restored from __doc__
""" x.__or__(y) <==> x|y """
pass
def __pos__(self): # real signature unknown; restored from __doc__
""" x.__pos__() <==> +x """
pass
def __pow__(self, y, z=None): # real signature unknown; restored from __doc__
""" x.__pow__(y[, z]) <==> pow(x, y[, z]) """
pass
def __radd__(self, y): # real signature unknown; restored from __doc__
""" x.__radd__(y) <==> y+x """
pass
def __rand__(self, y): # real signature unknown; restored from __doc__
""" x.__rand__(y) <==> y&x """
pass
def __rdivmod__(self, y): # real signature unknown; restored from __doc__
""" x.__rdivmod__(y) <==> divmod(y, x) """
pass
def __rdiv__(self, y): # real signature unknown; restored from __doc__
""" x.__rdiv__(y) <==> y/x """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __rfloordiv__(self, y): # real signature unknown; restored from __doc__
""" x.__rfloordiv__(y) <==> y//x """
pass
def __rlshift__(self, y): # real signature unknown; restored from __doc__
""" x.__rlshift__(y) <==> y<<x """
pass
def __rmod__(self, y): # real signature unknown; restored from __doc__
""" x.__rmod__(y) <==> y%x """
pass
def __rmul__(self, y): # real signature unknown; restored from __doc__
""" x.__rmul__(y) <==> y*x """
pass
def __ror__(self, y): # real signature unknown; restored from __doc__
""" x.__ror__(y) <==> y|x """
pass
def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__
""" y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
pass
def __rrshift__(self, y): # real signature unknown; restored from __doc__
""" x.__rrshift__(y) <==> y>>x """
pass
def __rshift__(self, y): # real signature unknown; restored from __doc__
""" x.__rshift__(y) <==> x>>y """
pass
def __rsub__(self, y): # real signature unknown; restored from __doc__
""" x.__rsub__(y) <==> y-x """
pass
def __rtruediv__(self, y): # real signature unknown; restored from __doc__
""" x.__rtruediv__(y) <==> y/x """
pass
def __rxor__(self, y): # real signature unknown; restored from __doc__
""" x.__rxor__(y) <==> y^x """
pass
def __sizeof__(self, *args, **kwargs): # real signature unknown
""" Returns size in memory, in bytes """
pass
def __str__(self): # real signature unknown; restored from __doc__
""" x.__str__() <==> str(x) """
pass
def __sub__(self, y): # real signature unknown; restored from __doc__
""" x.__sub__(y) <==> x-y """
pass
def __truediv__(self, y): # real signature unknown; restored from __doc__
""" x.__truediv__(y) <==> x/y """
pass
def __trunc__(self, *args, **kwargs): # real signature unknown
""" Truncating an Integral returns itself. """
pass
def __xor__(self, y): # real signature unknown; restored from __doc__
""" x.__xor__(y) <==> x^y """
pass
denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""the denominator of a rational number in lowest terms"""
imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""the imaginary part of a complex number"""
numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""the numerator of a rational number in lowest terms"""
real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
"""the real part of a complex number"""
class memoryview(object):
"""
memoryview(object)
Create a new memoryview object which references the given object.
"""
def tobytes(self, *args, **kwargs): # real signature unknown
pass
def tolist(self, *args, **kwargs): # real signature unknown
pass
def __delitem__(self, y): # real signature unknown; restored from __doc__
""" x.__delitem__(y) <==> del x[y] """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __init__(self, p_object): # real signature unknown; restored from __doc__
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __setitem__(self, i, y): # real signature unknown; restored from __doc__
""" x.__setitem__(i, y) <==> x[i]=y """
pass
format = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
itemsize = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
ndim = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
readonly = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
shape = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
strides = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
suboffsets = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
class property(object):
"""
property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget is a function to be used for getting an attribute value, and likewise
fset is a function for setting, and fdel a function for del‘ing, an
attribute. Typical use is to define a managed attribute x:
class C(object):
def getx(self): return self._x
def setx(self, value): self._x = value
def delx(self): del self._x
x = property(getx, setx, delx, "I‘m the ‘x‘ property.")
Decorators make defining new properties or modifying existing ones easy:
class C(object):
@property
def x(self):
"I am the ‘x‘ property."
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
"""
def deleter(self, *args, **kwargs): # real signature unknown
""" Descriptor to change the deleter on a property. """
pass
def getter(self, *args, **kwargs): # real signature unknown
""" Descriptor to change the getter on a property. """
pass
def setter(self, *args, **kwargs): # real signature unknown
""" Descriptor to change the setter on a property. """
pass
def __delete__(self, obj): # real signature unknown; restored from __doc__
""" descr.__delete__(obj) """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __get__(self, obj, type=None): # real signature unknown; restored from __doc__
""" descr.__get__(obj[, type]) -> value """
pass
def __init__(self, fget=None, fset=None, fdel=None, doc=None): # known special case of property.__init__
"""
property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget is a function to be used for getting an attribute value, and likewise
fset is a function for setting, and fdel a function for del‘ing, an
attribute. Typical use is to define a managed attribute x:
class C(object):
def getx(self): return self._x
def setx(self, value): self._x = value
def delx(self): del self._x
x = property(getx, setx, delx, "I‘m the ‘x‘ property.")
Decorators make defining new properties or modifying existing ones easy:
class C(object):
@property
def x(self):
"I am the ‘x‘ property."
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
# (copied from class doc)
"""
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __set__(self, obj, value): # real signature unknown; restored from __doc__
""" descr.__set__(obj, value) """
pass
fdel = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
fget = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
fset = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
class reversed(object):
"""
reversed(sequence) -> reverse iterator over values of the sequence
Return a reverse iterator
"""
def next(self): # real signature unknown; restored from __doc__
""" x.next() -> the next value, or raise StopIteration """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __init__(self, sequence): # real signature unknown; restored from __doc__
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
def __length_hint__(self, *args, **kwargs): # real signature unknown
""" Private method returning an estimate of len(list(it)). """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
class set(object):
"""
set() -> new empty set object
set(iterable) -> new set object
Build an unordered collection of unique elements.
"""
def add(self, *args, **kwargs): # real signature unknown
"""
Add an element to a set.
This has no effect if the element is already present.
"""
pass
def clear(self, *args, **kwargs): # real signature unknown
""" Remove all elements from this set. """
pass
def copy(self, *args, **kwargs): # real signature unknown
""" Return a shallow copy of a set. """
pass
def difference(self, *args, **kwargs): # real signature unknown
"""
Return the difference of two or more sets as a new set.
(i.e. all elements that are in this set but not the others.)
"""
pass
def difference_update(self, *args, **kwargs): # real signature unknown
""" Remove all elements of another set from this set. """
pass
def discard(self, *args, **kwargs): # real signature unknown
"""
Remove an element from a set if it is a member.
If the element is not a member, do nothing.
"""
pass
def intersection(self, *args, **kwargs): # real signature unknown
"""
Return the intersection of two or more sets as a new set.
(i.e. elements that are common to all of the sets.)
"""
pass
def intersection_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the intersection of itself and another. """
pass
def isdisjoint(self, *args, **kwargs): # real signature unknown
""" Return True if two sets have a null intersection. """
pass
def issubset(self, *args, **kwargs): # real signature unknown
""" Report whether another set contains this set. """
pass
def issuperset(self, *args, **kwargs): # real signature unknown
""" Report whether this set contains another set. """
pass
def pop(self, *args, **kwargs): # real signature unknown
"""
Remove and return an arbitrary set element.
Raises KeyError if the set is empty.
"""
pass
def remove(self, *args, **kwargs): # real signature unknown
"""
Remove an element from a set; it must be a member.
If the element is not a member, raise a KeyError.
"""
pass
def symmetric_difference(self, *args, **kwargs): # real signature unknown
"""
Return the symmetric difference of two sets as a new set.
(i.e. all elements that are in exactly one of the sets.)
"""
pass
def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the symmetric difference of itself and another. """
pass
def union(self, *args, **kwargs): # real signature unknown
"""
Return the union of sets as a new set.
(i.e. all elements that are in either set.)
"""
pass
def update(self, *args, **kwargs): # real signature unknown
""" Update a set with the union of itself and others. """
pass
def __and__(self, y): # real signature unknown; restored from __doc__
""" x.__and__(y) <==> x&y """
pass
def __cmp__(self, y): # real signature unknown; restored from __doc__
""" x.__cmp__(y) <==> cmp(x,y) """
pass
def __contains__(self, y): # real signature unknown; restored from __doc__
""" x.__contains__(y) <==> y in x. """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __iand__(self, y): # real signature unknown; restored from __doc__
""" x.__iand__(y) <==> x&=y """
pass
def __init__(self, seq=()): # known special case of set.__init__
"""
set() -> new empty set object
set(iterable) -> new set object
Build an unordered collection of unique elements.
# (copied from class doc)
"""
pass
def __ior__(self, y): # real signature unknown; restored from __doc__
""" x.__ior__(y) <==> x|=y """
pass
def __isub__(self, y): # real signature unknown; restored from __doc__
""" x.__isub__(y) <==> x-=y """
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
def __ixor__(self, y): # real signature unknown; restored from __doc__
""" x.__ixor__(y) <==> x^=y """
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __or__(self, y): # real signature unknown; restored from __doc__
""" x.__or__(y) <==> x|y """
pass
def __rand__(self, y): # real signature unknown; restored from __doc__
""" x.__rand__(y) <==> y&x """
pass
def __reduce__(self, *args, **kwargs): # real signature unknown
""" Return state information for pickling. """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __ror__(self, y): # real signature unknown; restored from __doc__
""" x.__ror__(y) <==> y|x """
pass
def __rsub__(self, y): # real signature unknown; restored from __doc__
""" x.__rsub__(y) <==> y-x """
pass
def __rxor__(self, y): # real signature unknown; restored from __doc__
""" x.__rxor__(y) <==> y^x """
pass
def __sizeof__(self): # real signature unknown; restored from __doc__
""" S.__sizeof__() -> size of S in memory, in bytes """
pass
def __sub__(self, y): # real signature unknown; restored from __doc__
""" x.__sub__(y) <==> x-y """
pass
def __xor__(self, y): # real signature unknown; restored from __doc__
""" x.__xor__(y) <==> x^y """
pass
__hash__ = None
class slice(object):
"""
slice(stop)
slice(start, stop[, step])
Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).
"""
def indices(self, len): # real signature unknown; restored from __doc__
"""
S.indices(len) -> (start, stop, stride)
Assuming a sequence of length len, calculate the start and stop
indices, and the stride length of the extended slice described by
S. Out of bounds indices are clipped in a manner consistent with the
handling of normal slices.
"""
pass
def __cmp__(self, y): # real signature unknown; restored from __doc__
""" x.__cmp__(y) <==> cmp(x,y) """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __hash__(self): # real signature unknown; restored from __doc__
""" x.__hash__() <==> hash(x) """
pass
def __init__(self, stop): # real signature unknown; restored from __doc__
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __reduce__(self, *args, **kwargs): # real signature unknown
""" Return state information for pickling. """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
start = property(lambda self: 0)
""":type: int"""
step = property(lambda self: 0)
""":type: int"""
stop = property(lambda self: 0)
""":type: int"""
class staticmethod(object):
"""
staticmethod(function) -> method
Convert a function to be a static method.
A static method does not receive an implicit first argument.
To declare a static method, use this idiom:
class C:
def f(arg1, arg2, ...): ...
f = staticmethod(f)
It can be called either on the class (e.g. C.f()) or on an instance
(e.g. C().f()). The instance is ignored except for its class.
Static methods in Python are similar to those found in Java or C++.
For a more advanced concept, see the classmethod builtin.
"""
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __get__(self, obj, type=None): # real signature unknown; restored from __doc__
""" descr.__get__(obj[, type]) -> value """
pass
def __init__(self, function): # real signature unknown; restored from __doc__
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
__func__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
class super(object):
"""
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type) -> unbound super object
super(type, type2) -> bound super object; requires issubclass(type2, type)
Typical use to call a cooperative superclass method:
class C(B):
def meth(self, arg):
super(C, self).meth(arg)
"""
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __get__(self, obj, type=None): # real signature unknown; restored from __doc__
""" descr.__get__(obj[, type]) -> value """
pass
def __init__(self, type1, type2=None): # known special case of super.__init__
"""
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type) -> unbound super object
super(type, type2) -> bound super object; requires issubclass(type2, type)
Typical use to call a cooperative superclass method:
class C(B):
def meth(self, arg):
super(C, self).meth(arg)
# (copied from class doc)
"""
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
__self_class__ = property(lambda self: type(object))
"""the type of the instance invoking super(); may be None
:type: type
"""
__self__ = property(lambda self: type(object))
"""the instance invoking super(); may be None
:type: type
"""
__thisclass__ = property(lambda self: type(object))
"""the class invoking super()
:type: type
"""
class tuple(object):
"""
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable‘s items
If the argument is a tuple, the return value is the same object.
"""
def count(self, value): # real signature unknown; restored from __doc__
""" T.count(value) -> integer -- return number of occurrences of value """
return 0
def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
"""
T.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
"""
return 0
def __add__(self, y): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass
def __contains__(self, y): # real signature unknown; restored from __doc__
""" x.__contains__(y) <==> y in x """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown
pass
def __getslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
"""
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __hash__(self): # real signature unknown; restored from __doc__
""" x.__hash__() <==> hash(x) """
pass
def __init__(self, seq=()): # known special case of tuple.__init__
"""
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable‘s items
If the argument is a tuple, the return value is the same object.
# (copied from class doc)
"""
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
def __mul__(self, n): # real signature unknown; restored from __doc__
""" x.__mul__(n) <==> x*n """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __rmul__(self, n): # real signature unknown; restored from __doc__
""" x.__rmul__(n) <==> n*x """
pass
class type(object):
"""
type(object) -> the object‘s type
type(name, bases, dict) -> a new type
"""
def mro(self): # real signature unknown; restored from __doc__
"""
mro() -> list
return a type‘s method resolution order
"""
return []
def __call__(self, *more): # real signature unknown; restored from __doc__
""" x.__call__(...) <==> x(...) """
pass
def __delattr__(self, name): # real signature unknown; restored from __doc__
""" x.__delattr__(‘name‘) <==> del x.name """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __hash__(self): # real signature unknown; restored from __doc__
""" x.__hash__() <==> hash(x) """
pass
def __init__(cls, what, bases=None, dict=None): # known special case of type.__init__
"""
type(object) -> the object‘s type
type(name, bases, dict) -> a new type
# (copied from class doc)
"""
pass
def __instancecheck__(self): # real signature unknown; restored from __doc__
"""
__instancecheck__() -> bool
check if an object is an instance
"""
return False
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __setattr__(self, name, value): # real signature unknown; restored from __doc__
""" x.__setattr__(‘name‘, value) <==> x.name = value """
pass
def __subclasscheck__(self): # real signature unknown; restored from __doc__
"""
__subclasscheck__() -> bool
check if a class is a subclass
"""
return False
def __subclasses__(self): # real signature unknown; restored from __doc__
""" __subclasses__() -> list of immediate subclasses """
return []
__abstractmethods__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
__bases__ = (
object,
)
__base__ = object
__basicsize__ = 436
__dictoffset__ = 132
__dict__ = None # (!) real value is ‘‘
__flags__ = -2146544149
__itemsize__ = 20
__mro__ = (
None, # (!) forward: type, real value is ‘‘
object,
)
__name__ = ‘type‘
__weakrefoffset__ = 184
class unicode(basestring):
"""
unicode(object=‘‘) -> unicode object
unicode(string[, encoding[, errors]]) -> unicode object
Create a new Unicode object from the given encoded string.
encoding defaults to the current default string encoding.
errors can be ‘strict‘, ‘replace‘ or ‘ignore‘ and defaults to ‘strict‘.
"""
def capitalize(self): # real signature unknown; restored from __doc__
"""
S.capitalize() -> unicode
Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case.
"""
return u""
def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.center(width[, fillchar]) -> unicode
Return S centered in a Unicode string of length width. Padding is
done using the specified fill character (default is a space)
"""
return u""
def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
Unicode string S[start:end]. Optional arguments start and end are
interpreted as in slice notation.
"""
return 0
def decode(self, encoding=None, errors=None): # real signature unknown; restored from __doc__
"""
S.decode([encoding[,errors]]) -> string or unicode
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 ""
def encode(self, encoding=None, errors=None): # real signature unknown; restored from __doc__
"""
S.encode([encoding[,errors]]) -> string or unicode
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 can handle UnicodeEncodeErrors.
"""
return ""
def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
S.expandtabs([tabsize]) -> unicode
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 u""
def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
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 unicode.format
"""
S.format(*args, **kwargs) -> unicode
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): # real signature unknown; restored from __doc__
"""
S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
"""
return 0
def isalnum(self): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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 isdecimal(self): # real signature unknown; restored from __doc__
"""
S.isdecimal() -> bool
Return True if there are only decimal characters in S,
False otherwise.
"""
return False
def isdigit(self): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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 isnumeric(self): # real signature unknown; restored from __doc__
"""
S.isnumeric() -> bool
Return True if there are only numeric characters in S,
False otherwise.
"""
return False
def isspace(self): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
S.istitle() -> bool
Return True if S is a titlecased string and there is at least one
character in S, i.e. upper- and titlecase characters may only
follow uncased characters and lowercase characters only cased ones.
Return False otherwise.
"""
return False
def isupper(self): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
S.join(iterable) -> unicode
Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.
"""
return u""
def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.ljust(width[, fillchar]) -> int
Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
"""
return 0
def lower(self): # real signature unknown; restored from __doc__
"""
S.lower() -> unicode
Return a copy of the string S converted to lowercase.
"""
return u""
def lstrip(self, chars=None): # real signature unknown; restored from __doc__
"""
S.lstrip([chars]) -> 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 a str, it will be converted to unicode before stripping
"""
return u""
def partition(self, sep): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
S.replace(old, new[, count]) -> unicode
Return a copy of 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 u""
def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
S.rjust(width[, fillchar]) -> unicode
Return S right-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
"""
return u""
def rpartition(self, sep): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
S.rsplit([sep [,maxsplit]]) -> list of strings
Return a list of the words in 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, any whitespace string
is a separator.
"""
return []
def rstrip(self, chars=None): # real signature unknown; restored from __doc__
"""
S.rstrip([chars]) -> 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 a str, it will be converted to unicode before stripping
"""
return u""
def split(self, sep=None, maxsplit=None): # real signature unknown; restored from __doc__
"""
S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in 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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
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): # real signature unknown; restored from __doc__
"""
S.strip([chars]) -> 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 a str, it will be converted to unicode before stripping
"""
return u""
def swapcase(self): # real signature unknown; restored from __doc__
"""
S.swapcase() -> unicode
Return a copy of S with uppercase characters converted to lowercase
and vice versa.
"""
return u""
def title(self): # real signature unknown; restored from __doc__
"""
S.title() -> unicode
Return a titlecased version of S, i.e. words start with title case
characters, all remaining cased characters have lower case.
"""
return u""
def translate(self, table): # real signature unknown; restored from __doc__
"""
S.translate(table) -> unicode
Return a copy of the string S, where all characters have been mapped
through the given translation table, which must be a mapping of
Unicode ordinals to Unicode ordinals, Unicode strings or None.
Unmapped characters are left untouched. Characters mapped to None
are deleted.
"""
return u""
def upper(self): # real signature unknown; restored from __doc__
"""
S.upper() -> unicode
Return a copy of S converted to uppercase.
"""
return u""
def zfill(self, width): # real signature unknown; restored from __doc__
"""
S.zfill(width) -> unicode
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 u""
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): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass
def __contains__(self, y): # real signature unknown; restored from __doc__
""" x.__contains__(y) <==> y in x """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __format__(self, format_spec): # real signature unknown; restored from __doc__
"""
S.__format__(format_spec) -> unicode
Return a formatted version of S as described by format_spec.
"""
return u""
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown
pass
def __getslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
"""
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __hash__(self): # real signature unknown; restored from __doc__
""" x.__hash__() <==> hash(x) """
pass
def __init__(self, string=u‘‘, encoding=None, errors=‘strict‘): # known special case of unicode.__init__
"""
unicode(object=‘‘) -> unicode object
unicode(string[, encoding[, errors]]) -> unicode object
Create a new Unicode object from the given encoded string.
encoding defaults to the current default string encoding.
errors can be ‘strict‘, ‘replace‘ or ‘ignore‘ and defaults to ‘strict‘.
# (copied from class doc)
"""
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
def __mod__(self, y): # real signature unknown; restored from __doc__
""" x.__mod__(y) <==> x%y """
pass
def __mul__(self, n): # real signature unknown; restored from __doc__
""" x.__mul__(n) <==> x*n """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __rmod__(self, y): # real signature unknown; restored from __doc__
""" x.__rmod__(y) <==> y%x """
pass
def __rmul__(self, n): # real signature unknown; restored from __doc__
""" x.__rmul__(n) <==> n*x """
pass
def __sizeof__(self): # real signature unknown; restored from __doc__
""" S.__sizeof__() -> size of S in memory, in bytes """
pass
def __str__(self): # real signature unknown; restored from __doc__
""" x.__str__() <==> str(x) """
pass
class xrange(object):
"""
xrange(stop) -> xrange object
xrange(start, stop[, step]) -> xrange object
Like range(), but instead of returning a list, returns an object that
generates the numbers in the range on demand. For looping, this is
slightly faster than range() and more memory efficient.
"""
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__(‘name‘) <==> x.name """
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
def __init__(self, stop): # real signature unknown; restored from __doc__
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __reduce__(self, *args, **kwargs): # real signature unknown
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __reversed__(self, *args, **kwargs): # real signature unknown
""" Returns a reverse iterator. """
pass
# variables with complex values
Ellipsis = None # (!) real value is ‘‘
NotImplemented = None # (!) real value is ‘‘
基本常用的很少，主要大部分都是私有方法
2、浮点型
如：3.14、2.88
查看方法同上
3、字符串（很常用）
方法如下
1 class str(basestring): 2 """ 3 str(object=‘‘) -> string 4 5 Return a nice string representation of the object. 6 If the argument is a string, the return value is the same object. 7 """ 8 def capitalize(self): # real signature unknown; restored from __doc__ 9 """ 10 S.capitalize() -> string 11 12 Return a copy of the string S with only its first character 13 capitalized. 14 """ 15 return "" 16 17 def center(self, width, fillchar=None): # real signature unknown; restored from __doc__ 18 """ 19 S.center(width[, fillchar]) -> string 20 21 Return S centered in a string of length width. Padding is 22 done using the specified fill character (default is a space) 23 """ 24 return "" 25 26 def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 27 """ 28 S.count(sub[, start[, end]]) -> int 29 30 Return the number of non-overlapping occurrences of substring sub in 31 string S[start:end]. Optional arguments start and end are interpreted 32 as in slice notation. 33 """ 34 return 0 35 36 def decode(self, encoding=None, errors=None): # real signature unknown; restored from __doc__ 37 """ 38 S.decode([encoding[,errors]]) -> object 39 40 Decodes S using the codec registered for encoding. encoding defaults 41 to the default encoding. errors may be given to set a different error 42 handling scheme. Default is ‘strict‘ meaning that encoding errors raise 43 a UnicodeDecodeError. Other possible values are ‘ignore‘ and ‘replace‘ 44 as well as any other name registered with codecs.register_error that is 45 able to handle UnicodeDecodeErrors. 46 """ 47 return object() 48 49 def encode(self, encoding=None, errors=None): # real signature unknown; restored from __doc__ 50 """ 51 S.encode([encoding[,errors]]) -> object 52 53 Encodes S using the codec registered for encoding. encoding defaults 54 to the default encoding. errors may be given to set a different error 55 handling scheme. Default is ‘strict‘ meaning that encoding errors raise 56 a UnicodeEncodeError. Other possible values are ‘ignore‘, ‘replace‘ and 57 ‘xmlcharrefreplace‘ as well as any other name registered with 58 codecs.register_error that is able to handle UnicodeEncodeErrors. 59 """ 60 return object() 61 62 def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__ 63 """ 64 S.endswith(suffix[, start[, end]]) -> bool 65 66 Return True if S ends with the specified suffix, False otherwise. 67 With optional start, test S beginning at that position. 68 With optional end, stop comparing S at that position. 69 suffix can also be a tuple of strings to try. 70 """ 71 return False 72 73 def expandtabs(self, tabsize=None): # real signature unknown; restored from __doc__ 74 """ 75 S.expandtabs([tabsize]) -> string 76 77 Return a copy of S where all tab characters are expanded using spaces. 78 If tabsize is not given, a tab size of 8 characters is assumed. 79 """ 80 return "" 81 82 def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 83 """ 84 S.find(sub [,start [,end]]) -> int 85 86 Return the lowest index in S where substring sub is found, 87 such that sub is contained within S[start:end]. Optional 88 arguments start and end are interpreted as in slice notation. 89 90 Return -1 on failure. 91 """ 92 return 0 93 94 def format(*args, **kwargs): # known special case of str.format 95 """ 96 S.format(*args, **kwargs) -> string 97 98 Return a formatted version of S, using substitutions from args and kwargs. 99 The substitutions are identified by braces (‘{‘ and ‘}‘). 100 """ 101 pass 102 103 def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 104 """ 105 S.index(sub [,start [,end]]) -> int 106 107 Like S.find() but raise ValueError when the substring is not found. 108 """ 109 return 0 110 111 def isalnum(self): # real signature unknown; restored from __doc__ 112 """ 113 S.isalnum() -> bool 114 115 Return True if all characters in S are alphanumeric 116 and there is at least one character in S, False otherwise. 117 """ 118 return False 119 120 def isalpha(self): # real signature unknown; restored from __doc__ 121 """ 122 S.isalpha() -> bool 123 124 Return True if all characters in S are alphabetic 125 and there is at least one character in S, False otherwise. 126 """ 127 return False 128 129 def isdigit(self): # real signature unknown; restored from __doc__ 130 """ 131 S.isdigit() -> bool 132 133 Return True if all characters in S are digits 134 and there is at least one character in S, False otherwise. 135 """ 136 return False 137 138 def islower(self): # real signature unknown; restored from __doc__ 139 """ 140 S.islower() -> bool 141 142 Return True if all cased characters in S are lowercase and there is 143 at least one cased character in S, False otherwise. 144 """ 145 return False 146 147 def isspace(self): # real signature unknown; restored from __doc__ 148 """ 149 S.isspace() -> bool 150 151 Return True if all characters in S are whitespace 152 and there is at least one character in S, False otherwise. 153 """ 154 return False 155 156 def istitle(self): # real signature unknown; restored from __doc__ 157 """ 158 S.istitle() -> bool 159 160 Return True if S is a titlecased string and there is at least one 161 character in S, i.e. uppercase characters may only follow uncased 162 characters and lowercase characters only cased ones. Return False 163 otherwise. 164 """ 165 return False 166 167 def isupper(self): # real signature unknown; restored from __doc__ 168 """ 169 S.isupper() -> bool 170 171 Return True if all cased characters in S are uppercase and there is 172 at least one cased character in S, False otherwise. 173 """ 174 return False 175 176 def join(self, iterable): # real signature unknown; restored from __doc__ 177 """ 178 S.join(iterable) -> string 179 180 Return a string which is the concatenation of the strings in the 181 iterable. The separator between elements is S. 182 """ 183 return "" 184 185 def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__ 186 """ 187 S.ljust(width[, fillchar]) -> string 188 189 Return S left-justified in a string of length width. Padding is 190 done using the specified fill character (default is a space). 191 """ 192 return "" 193 194 def lower(self): # real signature unknown; restored from __doc__ 195 """ 196 S.lower() -> string 197 198 Return a copy of the string S converted to lowercase. 199 """ 200 return "" 201 202 def lstrip(self, chars=None): # real signature unknown; restored from __doc__ 203 """ 204 S.lstrip([chars]) -> string or unicode 205 206 Return a copy of the string S with leading whitespace removed. 207 If chars is given and not None, remove characters in chars instead. 208 If chars is unicode, S will be converted to unicode before stripping 209 """ 210 return "" 211 212 def partition(self, sep): # real signature unknown; restored from __doc__ 213 """ 214 S.partition(sep) -> (head, sep, tail) 215 216 Search for the separator sep in S, and return the part before it, 217 the separator itself, and the part after it. If the separator is not 218 found, return S and two empty strings. 219 """ 220 pass 221 222 def replace(self, old, new, count=None): # real signature unknown; restored from __doc__ 223 """ 224 S.replace(old, new[, count]) -> string 225 226 Return a copy of string S with all occurrences of substring 227 old replaced by new. If the optional argument count is 228 given, only the first count occurrences are replaced. 229 """ 230 return "" 231 232 def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 233 """ 234 S.rfind(sub [,start [,end]]) -> int 235 236 Return the highest index in S where substring sub is found, 237 such that sub is contained within S[start:end]. Optional 238 arguments start and end are interpreted as in slice notation. 239 240 Return -1 on failure. 241 """ 242 return 0 243 244 def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 245 """ 246 S.rindex(sub [,start [,end]]) -> int 247 248 Like S.rfind() but raise ValueError when the substring is not found. 249 """ 250 return 0 251 252 def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__ 253 """ 254 S.rjust(width[, fillchar]) -> string 255 256 Return S right-justified in a string of length width. Padding is 257 done using the specified fill character (default is a space) 258 """ 259 return "" 260 261 def rpartition(self, sep): # real signature unknown; restored from __doc__ 262 """ 263 S.rpartition(sep) -> (head, sep, tail) 264 265 Search for the separator sep in S, starting at the end of S, and return 266 the part before it, the separator itself, and the part after it. If the 267 separator is not found, return two empty strings and S. 268 """ 269 pass 270 271 def rsplit(self, sep=None, maxsplit=None): # real signature unknown; restored from __doc__ 272 """ 273 S.rsplit([sep [,maxsplit]]) -> list of strings 274 275 Return a list of the words in the string S, using sep as the 276 delimiter string, starting at the end of the string and working 277 to the front. If maxsplit is given, at most maxsplit splits are 278 done. If sep is not specified or is None, any whitespace string 279 is a separator. 280 """ 281 return [] 282 283 def rstrip(self, chars=None): # real signature unknown; restored from __doc__ 284 """ 285 S.rstrip([chars]) -> string or unicode 286 287 Return a copy of the string S with trailing whitespace removed. 288 If chars is given and not None, remove characters in chars instead. 289 If chars is unicode, S will be converted to unicode before stripping 290 """ 291 return "" 292 293 def split(self, sep=None, maxsplit=None): # real signature unknown; restored from __doc__ 294 """ 295 S.split([sep [,maxsplit]]) -> list of strings 296 297 Return a list of the words in the string S, using sep as the 298 delimiter string. If maxsplit is given, at most maxsplit 299 splits are done. If sep is not specified or is None, any 300 whitespace string is a separator and empty strings are removed 301 from the result. 302 """ 303 return [] 304 305 def splitlines(self, keepends=False): # real signature unknown; restored from __doc__ 306 """ 307 S.splitlines(keepends=False) -> list of strings 308 309 Return a list of the lines in S, breaking at line boundaries. 310 Line breaks are not included in the resulting list unless keepends 311 is given and true. 312 """ 313 return [] 314 315 def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__ 316 """ 317 S.startswith(prefix[, start[, end]]) -> bool 318 319 Return True if S starts with the specified prefix, False otherwise. 320 With optional start, test S beginning at that position. 321 With optional end, stop comparing S at that position. 322 prefix can also be a tuple of strings to try. 323 """ 324 return False 325 326 def strip(self, chars=None): # real signature unknown; restored from __doc__ 327 """ 328 S.strip([chars]) -> string or unicode 329 330 Return a copy of the string S with leading and trailing 331 whitespace removed. 332 If chars is given and not None, remove characters in chars instead. 333 If chars is unicode, S will be converted to unicode before stripping 334 """ 335 return "" 336 337 def swapcase(self): # real signature unknown; restored from __doc__ 338 """ 339 S.swapcase() -> string 340 341 Return a copy of the string S with uppercase characters 342 converted to lowercase and vice versa. 343 """ 344 return "" 345 346 def title(self): # real signature unknown; restored from __doc__ 347 """ 348 S.title() -> string 349 350 Return a titlecased version of S, i.e. words start with uppercase 351 characters, all remaining cased characters have lowercase. 352 """ 353 return "" 354 355 def translate(self, table, deletechars=None): # real signature unknown; restored from __doc__ 356 """ 357 S.translate(table [,deletechars]) -> string 358 359 Return a copy of the string S, where all characters occurring 360 in the optional argument deletechars are removed, and the 361 remaining characters have been mapped through the given 362 translation table, which must be a string of length 256 or None. 363 If the table argument is None, no translation is applied and 364 the operation simply removes the characters in deletechars. 365 """ 366 return "" 367 368 def upper(self): # real signature unknown; restored from __doc__ 369 """ 370 S.upper() -> string 371 372 Return a copy of the string S converted to uppercase. 373 """ 374 return "" 375 376 def zfill(self, width): # real signature unknown; restored from __doc__ 377 """ 378 S.zfill(width) -> string 379 380 Pad a numeric string S with zeros on the left, to fill a field 381 of the specified width. The string S is never truncated. 382 """ 383 return "" 384 385 def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown 386 pass 387 388 def _formatter_parser(self, *args, **kwargs): # real signature unknown 389 pass 390 391 def __add__(self, y): # real signature unknown; restored from __doc__ 392 """ x.__add__(y) <==> x+y """ 393 pass 394 395 def __contains__(self, y): # real signature unknown; restored from __doc__ 396 """ x.__contains__(y) <==> y in x """ 397 pass 398 399 def __eq__(self, y): # real signature unknown; restored from __doc__ 400 """ x.__eq__(y) <==> x==y """ 401 pass 402 403 def __format__(self, format_spec): # real signature unknown; restored from __doc__ 404 """ 405 S.__format__(format_spec) -> string 406 407 Return a formatted version of S as described by format_spec. 408 """ 409 return "" 410 411 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 412 """ x.__getattribute__(‘name‘) <==> x.name """ 413 pass 414 415 def __getitem__(self, y): # real signature unknown; restored from __doc__ 416 """ x.__getitem__(y) <==> x[y] """ 417 pass 418 419 def __getnewargs__(self, *args, **kwargs): # real signature unknown 420 pass 421 422 def __getslice__(self, i, j): # real signature unknown; restored from __doc__ 423 """ 424 x.__getslice__(i, j) <==> x[i:j] 425 426 Use of negative indices is not supported. 427 """ 428 pass 429 430 def __ge__(self, y): # real signature unknown; restored from __doc__ 431 """ x.__ge__(y) <==> x>=y """ 432 pass 433 434 def __gt__(self, y): # real signature unknown; restored from __doc__ 435 """ x.__gt__(y) <==> x>y """ 436 pass 437 438 def __hash__(self): # real signature unknown; restored from __doc__ 439 """ x.__hash__() <==> hash(x) """ 440 pass 441 442 def __init__(self, string=‘‘): # known special case of str.__init__ 443 """ 444 str(object=‘‘) -> string 445 446 Return a nice string representation of the object. 447 If the argument is a string, the return value is the same object. 448 # (copied from class doc) 449 """ 450 pass 451 452 def __len__(self): # real signature unknown; restored from __doc__ 453 """ x.__len__() <==> len(x) """ 454 pass 455 456 def __le__(self, y): # real signature unknown; restored from __doc__ 457 """ x.__le__(y) <==> x<=y """ 458 pass 459 460 def __lt__(self, y): # real signature unknown; restored from __doc__ 461 """ x.__lt__(y) <==> x<y """ 462 pass 463 464 def __mod__(self, y): # real signature unknown; restored from __doc__ 465 """ x.__mod__(y) <==> x%y """ 466 pass 467 468 def __mul__(self, n): # real signature unknown; restored from __doc__ 469 """ x.__mul__(n) <==> x*n """ 470 pass 471 472 @staticmethod # known case of __new__ 473 def __new__(S, *more): # real signature unknown; restored from __doc__ 474 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 475 pass 476 477 def __ne__(self, y): # real signature unknown; restored from __doc__ 478 """ x.__ne__(y) <==> x!=y """ 479 pass 480 481 def __repr__(self): # real signature unknown; restored from __doc__ 482 """ x.__repr__() <==> repr(x) """ 483 pass 484 485 def __rmod__(self, y): # real signature unknown; restored from __doc__ 486 """ x.__rmod__(y) <==> y%x """ 487 pass 488 489 def __rmul__(self, n): # real signature unknown; restored from __doc__ 490 """ x.__rmul__(n) <==> n*x """ 491 pass 492 493 def __sizeof__(self): # real signature unknown; restored from __doc__ 494 """ S.__sizeof__() -> size of S in memory, in bytes """ 495 pass 496 497 def __str__(self): # real signature unknown; restored from __doc__ 498 """ x.__str__() <==> str(x) """ 499 pass 500 501 502 bytes = str 503 504 505 class classmethod(object): 506 """ 507 classmethod(function) -> method 508 509 Convert a function to be a class method. 510 511 A class method receives the class as implicit first argument, 512 just like an instance method receives the instance. 513 To declare a class method, use this idiom: 514 515 class C: 516 def f(cls, arg1, arg2, ...): ... 517 f = classmethod(f) 518 519 It can be called either on the class (e.g. C.f()) or on an instance 520 (e.g. C().f()). The instance is ignored except for its class. 521 If a class method is called for a derived class, the derived class 522 object is passed as the implied first argument. 523 524 Class methods are different than C++ or Java static methods. 525 If you want those, see the staticmethod builtin. 526 """ 527 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 528 """ x.__getattribute__(‘name‘) <==> x.name """ 529 pass 530 531 def __get__(self, obj, type=None): # real signature unknown; restored from __doc__ 532 """ descr.__get__(obj[, type]) -> value """ 533 pass 534 535 def __init__(self, function): # real signature unknown; restored from __doc__ 536 pass 537 538 @staticmethod # known case of __new__ 539 def __new__(S, *more): # real signature unknown; restored from __doc__ 540 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 541 pass 542 543 __func__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 544 545 546 547 class complex(object): 548 """ 549 complex(real[, imag]) -> complex number 550 551 Create a complex number from a real part and an optional imaginary part. 552 This is equivalent to (real + imag*1j) where imag defaults to 0. 553 """ 554 def conjugate(self): # real signature unknown; restored from __doc__ 555 """ 556 complex.conjugate() -> complex 557 558 Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j. 559 """ 560 return complex 561 562 def __abs__(self): # real signature unknown; restored from __doc__ 563 """ x.__abs__() <==> abs(x) """ 564 pass 565 566 def __add__(self, y): # real signature unknown; restored from __doc__ 567 """ x.__add__(y) <==> x+y """ 568 pass 569 570 def __coerce__(self, y): # real signature unknown; restored from __doc__ 571 """ x.__coerce__(y) <==> coerce(x, y) """ 572 pass 573 574 def __divmod__(self, y): # real signature unknown; restored from __doc__ 575 """ x.__divmod__(y) <==> divmod(x, y) """ 576 pass 577 578 def __div__(self, y): # real signature unknown; restored from __doc__ 579 """ x.__div__(y) <==> x/y """ 580 pass 581 582 def __eq__(self, y): # real signature unknown; restored from __doc__ 583 """ x.__eq__(y) <==> x==y """ 584 pass 585 586 def __float__(self): # real signature unknown; restored from __doc__ 587 """ x.__float__() <==> float(x) """ 588 pass 589 590 def __floordiv__(self, y): # real signature unknown; restored from __doc__ 591 """ x.__floordiv__(y) <==> x//y """ 592 pass 593 594 def __format__(self): # real signature unknown; restored from __doc__ 595 """ 596 complex.__format__() -> str 597 598 Convert to a string according to format_spec. 599 """ 600 return "" 601 602 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 603 """ x.__getattribute__(‘name‘) <==> x.name """ 604 pass 605 606 def __getnewargs__(self, *args, **kwargs): # real signature unknown 607 pass 608 609 def __ge__(self, y): # real signature unknown; restored from __doc__ 610 """ x.__ge__(y) <==> x>=y """ 611 pass 612 613 def __gt__(self, y): # real signature unknown; restored from __doc__ 614 """ x.__gt__(y) <==> x>y """ 615 pass 616 617 def __hash__(self): # real signature unknown; restored from __doc__ 618 """ x.__hash__() <==> hash(x) """ 619 pass 620 621 def __init__(self, real, imag=None): # real signature unknown; restored from __doc__ 622 pass 623 624 def __int__(self): # real signature unknown; restored from __doc__ 625 """ x.__int__() <==> int(x) """ 626 pass 627 628 def __le__(self, y): # real signature unknown; restored from __doc__ 629 """ x.__le__(y) <==> x<=y """ 630 pass 631 632 def __long__(self): # real signature unknown; restored from __doc__ 633 """ x.__long__() <==> long(x) """ 634 pass 635 636 def __lt__(self, y): # real signature unknown; restored from __doc__ 637 """ x.__lt__(y) <==> x<y """ 638 pass 639 640 def __mod__(self, y): # real signature unknown; restored from __doc__ 641 """ x.__mod__(y) <==> x%y """ 642 pass 643 644 def __mul__(self, y): # real signature unknown; restored from __doc__ 645 """ x.__mul__(y) <==> x*y """ 646 pass 647 648 def __neg__(self): # real signature unknown; restored from __doc__ 649 """ x.__neg__() <==> -x """ 650 pass 651 652 @staticmethod # known case of __new__ 653 def __new__(S, *more): # real signature unknown; restored from __doc__ 654 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 655 pass 656 657 def __ne__(self, y): # real signature unknown; restored from __doc__ 658 """ x.__ne__(y) <==> x!=y """ 659 pass 660 661 def __nonzero__(self): # real signature unknown; restored from __doc__ 662 """ x.__nonzero__() <==> x != 0 """ 663 pass 664 665 def __pos__(self): # real signature unknown; restored from __doc__ 666 """ x.__pos__() <==> +x """ 667 pass 668 669 def __pow__(self, y, z=None): # real signature unknown; restored from __doc__ 670 """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """ 671 pass 672 673 def __radd__(self, y): # real signature unknown; restored from __doc__ 674 """ x.__radd__(y) <==> y+x """ 675 pass 676 677 def __rdivmod__(self, y): # real signature unknown; restored from __doc__ 678 """ x.__rdivmod__(y) <==> divmod(y, x) """ 679 pass 680 681 def __rdiv__(self, y): # real signature unknown; restored from __doc__ 682 """ x.__rdiv__(y) <==> y/x """ 683 pass 684 685 def __repr__(self): # real signature unknown; restored from __doc__ 686 """ x.__repr__() <==> repr(x) """ 687 pass 688 689 def __rfloordiv__(self, y): # real signature unknown; restored from __doc__ 690 """ x.__rfloordiv__(y) <==> y//x """ 691 pass 692 693 def __rmod__(self, y): # real signature unknown; restored from __doc__ 694 """ x.__rmod__(y) <==> y%x """ 695 pass 696 697 def __rmul__(self, y): # real signature unknown; restored from __doc__ 698 """ x.__rmul__(y) <==> y*x """ 699 pass 700 701 def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__ 702 """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """ 703 pass 704 705 def __rsub__(self, y): # real signature unknown; restored from __doc__ 706 """ x.__rsub__(y) <==> y-x """ 707 pass 708 709 def __rtruediv__(self, y): # real signature unknown; restored from __doc__ 710 """ x.__rtruediv__(y) <==> y/x """ 711 pass 712 713 def __str__(self): # real signature unknown; restored from __doc__ 714 """ x.__str__() <==> str(x) """ 715 pass 716 717 def __sub__(self, y): # real signature unknown; restored from __doc__ 718 """ x.__sub__(y) <==> x-y """ 719 pass 720 721 def __truediv__(self, y): # real signature unknown; restored from __doc__ 722 """ x.__truediv__(y) <==> x/y """ 723 pass 724 725 imag = property(lambda self: 0.0) 726 """the imaginary part of a complex number 727 728 :type: float 729 """ 730 731 real = property(lambda self: 0.0) 732 """the real part of a complex number 733 734 :type: float 735 """ 736 737 738 739 class dict(object): 740 """ 741 dict() -> new empty dictionary 742 dict(mapping) -> new dictionary initialized from a mapping object‘s 743 (key, value) pairs 744 dict(iterable) -> new dictionary initialized as if via: 745 d = {} 746 for k, v in iterable: 747 d[k] = v 748 dict(**kwargs) -> new dictionary initialized with the name=value pairs 749 in the keyword argument list. For example: dict(one=1, two=2) 750 """ 751 def clear(self): # real signature unknown; restored from __doc__ 752 """ D.clear() -> None. Remove all items from D. """ 753 pass 754 755 def copy(self): # real signature unknown; restored from __doc__ 756 """ D.copy() -> a shallow copy of D """ 757 pass 758 759 @staticmethod # known case 760 def fromkeys(S, v=None): # real signature unknown; restored from __doc__ 761 """ 762 dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v. 763 v defaults to None. 764 """ 765 pass 766 767 def get(self, k, d=None): # real signature unknown; restored from __doc__ 768 """ D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """ 769 pass 770 771 def has_key(self, k): # real signature unknown; restored from __doc__ 772 """ D.has_key(k) -> True if D has a key k, else False """ 773 return False 774 775 def items(self): # real signature unknown; restored from __doc__ 776 """ D.items() -> list of D‘s (key, value) pairs, as 2-tuples """ 777 return [] 778 779 def iteritems(self): # real signature unknown; restored from __doc__ 780 """ D.iteritems() -> an iterator over the (key, value) items of D """ 781 pass 782 783 def iterkeys(self): # real signature unknown; restored from __doc__ 784 """ D.iterkeys() -> an iterator over the keys of D """ 785 pass 786 787 def itervalues(self): # real signature unknown; restored from __doc__ 788 """ D.itervalues() -> an iterator over the values of D """ 789 pass 790 791 def keys(self): # real signature unknown; restored from __doc__ 792 """ D.keys() -> list of D‘s keys """ 793 return [] 794 795 def pop(self, k, d=None): # real signature unknown; restored from __doc__ 796 """ 797 D.pop(k[,d]) -> v, remove specified key and return the corresponding value. 798 If key is not found, d is returned if given, otherwise KeyError is raised 799 """ 800 pass 801 802 def popitem(self): # real signature unknown; restored from __doc__ 803 """ 804 D.popitem() -> (k, v), remove and return some (key, value) pair as a 805 2-tuple; but raise KeyError if D is empty. 806 """ 807 pass 808 809 def setdefault(self, k, d=None): # real signature unknown; restored from __doc__ 810 """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """ 811 pass 812 813 def update(self, E=None, **F): # known special case of dict.update 814 """ 815 D.update([E, ]**F) -> None. Update D from dict/iterable E and F. 816 If E present and has a .keys() method, does: for k in E: D[k] = E[k] 817 If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v 818 In either case, this is followed by: for k in F: D[k] = F[k] 819 """ 820 pass 821 822 def values(self): # real signature unknown; restored from __doc__ 823 """ D.values() -> list of D‘s values """ 824 return [] 825 826 def viewitems(self): # real signature unknown; restored from __doc__ 827 """ D.viewitems() -> a set-like object providing a view on D‘s items """ 828 pass 829 830 def viewkeys(self): # real signature unknown; restored from __doc__ 831 """ D.viewkeys() -> a set-like object providing a view on D‘s keys """ 832 pass 833 834 def viewvalues(self): # real signature unknown; restored from __doc__ 835 """ D.viewvalues() -> an object providing a view on D‘s values """ 836 pass 837 838 def __cmp__(self, y): # real signature unknown; restored from __doc__ 839 """ x.__cmp__(y) <==> cmp(x,y) """ 840 pass 841 842 def __contains__(self, k): # real signature unknown; restored from __doc__ 843 """ D.__contains__(k) -> True if D has a key k, else False """ 844 return False 845 846 def __delitem__(self, y): # real signature unknown; restored from __doc__ 847 """ x.__delitem__(y) <==> del x[y] """ 848 pass 849 850 def __eq__(self, y): # real signature unknown; restored from __doc__ 851 """ x.__eq__(y) <==> x==y """ 852 pass 853 854 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 855 """ x.__getattribute__(‘name‘) <==> x.name """ 856 pass 857 858 def __getitem__(self, y): # real signature unknown; restored from __doc__ 859 """ x.__getitem__(y) <==> x[y] """ 860 pass 861 862 def __ge__(self, y): # real signature unknown; restored from __doc__ 863 """ x.__ge__(y) <==> x>=y """ 864 pass 865 866 def __gt__(self, y): # real signature unknown; restored from __doc__ 867 """ x.__gt__(y) <==> x>y """ 868 pass 869 870 def __init__(self, seq=None, **kwargs): # known special case of dict.__init__ 871 """ 872 dict() -> new empty dictionary 873 dict(mapping) -> new dictionary initialized from a mapping object‘s 874 (key, value) pairs 875 dict(iterable) -> new dictionary initialized as if via: 876 d = {} 877 for k, v in iterable: 878 d[k] = v 879 dict(**kwargs) -> new dictionary initialized with the name=value pairs 880 in the keyword argument list. For example: dict(one=1, two=2) 881 # (copied from class doc) 882 """ 883 pass 884 885 def __iter__(self): # real signature unknown; restored from __doc__ 886 """ x.__iter__() <==> iter(x) """ 887 pass 888 889 def __len__(self): # real signature unknown; restored from __doc__ 890 """ x.__len__() <==> len(x) """ 891 pass 892 893 def __le__(self, y): # real signature unknown; restored from __doc__ 894 """ x.__le__(y) <==> x<=y """ 895 pass 896 897 def __lt__(self, y): # real signature unknown; restored from __doc__ 898 """ x.__lt__(y) <==> x<y """ 899 pass 900 901 @staticmethod # known case of __new__ 902 def __new__(S, *more): # real signature unknown; restored from __doc__ 903 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 904 pass 905 906 def __ne__(self, y): # real signature unknown; restored from __doc__ 907 """ x.__ne__(y) <==> x!=y """ 908 pass 909 910 def __repr__(self): # real signature unknown; restored from __doc__ 911 """ x.__repr__() <==> repr(x) """ 912 pass 913 914 def __setitem__(self, i, y): # real signature unknown; restored from __doc__ 915 """ x.__setitem__(i, y) <==> x[i]=y """ 916 pass 917 918 def __sizeof__(self): # real signature unknown; restored from __doc__ 919 """ D.__sizeof__() -> size of D in memory, in bytes """ 920 pass 921 922 __hash__ = None 923 924 925 class enumerate(object): 926 """ 927 enumerate(iterable[, start]) -> iterator for index, value of iterable 928 929 Return an enumerate object. iterable must be another object that supports 930 iteration. The enumerate object yields pairs containing a count (from 931 start, which defaults to zero) and a value yielded by the iterable argument. 932 enumerate is useful for obtaining an indexed list: 933 (0, seq[0]), (1, seq[1]), (2, seq[2]), ... 934 """ 935 def next(self): # real signature unknown; restored from __doc__ 936 """ x.next() -> the next value, or raise StopIteration """ 937 pass 938 939 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 940 """ x.__getattribute__(‘name‘) <==> x.name """ 941 pass 942 943 def __init__(self, iterable, start=0): # known special case of enumerate.__init__ 944 """ x.__init__(...) initializes x; see help(type(x)) for signature """ 945 pass 946 947 def __iter__(self): # real signature unknown; restored from __doc__ 948 """ x.__iter__() <==> iter(x) """ 949 pass 950 951 @staticmethod # known case of __new__ 952 def __new__(S, *more): # real signature unknown; restored from __doc__ 953 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 954 pass 955 956 957 class file(object): 958 """ 959 file(name[, mode[, buffering]]) -> file object 960 961 Open a file. The mode can be ‘r‘, ‘w‘ or ‘a‘ for reading (default), 962 writing or appending. The file will be created if it doesn‘t exist 963 when opened for writing or appending; it will be truncated when 964 opened for writing. Add a ‘b‘ to the mode for binary files. 965 Add a ‘+‘ to the mode to allow simultaneous reading and writing. 966 If the buffering argument is given, 0 means unbuffered, 1 means line 967 buffered, and larger numbers specify the buffer size. The preferred way 968 to open a file is with the builtin open() function. 969 Add a ‘U‘ to mode to open the file for input with universal newline 970 support. Any line ending in the input file will be seen as a ‘\n‘ 971 in Python. Also, a file so opened gains the attribute ‘newlines‘; 972 the value for this attribute is one of None (no newline read yet), 973 ‘\r‘, ‘\n‘, ‘\r\n‘ or a tuple containing all the newline types seen. 974 975 ‘U‘ cannot be combined with ‘w‘ or ‘+‘ mode. 976 """ 977 def close(self): # real signature unknown; restored from __doc__ 978 """ 979 close() -> None or (perhaps) an integer. Close the file. 980 981 Sets data attribute .closed to True. A closed file cannot be used for 982 further I/O operations. close() may be called more than once without 983 error. Some kinds of file objects (for example, opened by popen()) 984 may return an exit status upon closing. 985 """ 986 pass 987 988 def fileno(self): # real signature unknown; restored from __doc__ 989 """ 990 fileno() -> integer "file descriptor". 991 992 This is needed for lower-level file interfaces, such os.read(). 993 """ 994 return 0 995 996 def flush(self): # real signature unknown; restored from __doc__ 997 """ flush() -> None. Flush the internal I/O buffer. """ 998 pass 999 1000 def isatty(self): # real signature unknown; restored from __doc__ 1001 """ isatty() -> true or false. True if the file is connected to a tty device. """ 1002 return False 1003 1004 def next(self): # real signature unknown; restored from __doc__ 1005 """ x.next() -> the next value, or raise StopIteration """ 1006 pass 1007 1008 def read(self, size=None): # real signature unknown; restored from __doc__ 1009 """ 1010 read([size]) -> read at most size bytes, returned as a string. 1011 1012 If the size argument is negative or omitted, read until EOF is reached. 1013 Notice that when in non-blocking mode, less data than what was requested 1014 may be returned, even if no size parameter was given. 1015 """ 1016 pass 1017 1018 def readinto(self): # real signature unknown; restored from __doc__ 1019 """ readinto() -> Undocumented. Don‘t use this; it may go away. """ 1020 pass 1021 1022 def readline(self, size=None): # real signature unknown; restored from __doc__ 1023 """ 1024 readline([size]) -> next line from the file, as a string. 1025 1026 Retain newline. A non-negative size argument limits the maximum 1027 number of bytes to return (an incomplete line may be returned then). 1028 Return an empty string at EOF. 1029 """ 1030 pass 1031 1032 def readlines(self, size=None): # real signature unknown; restored from __doc__ 1033 """ 1034 readlines([size]) -> list of strings, each a line from the file. 1035 1036 Call readline() repeatedly and return a list of the lines so read. 1037 The optional size argument, if given, is an approximate bound on the 1038 total number of bytes in the lines returned. 1039 """ 1040 return [] 1041 1042 def seek(self, offset, whence=None): # real signature unknown; restored from __doc__ 1043 """ 1044 seek(offset[, whence]) -> None. Move to new file position. 1045 1046 Argument offset is a byte count. Optional argument whence defaults to 1047 0 (offset from start of file, offset should be >= 0); other values are 1 1048 (move relative to current position, positive or negative), and 2 (move 1049 relative to end of file, usually negative, although many platforms allow 1050 seeking beyond the end of a file). If the file is opened in text mode, 1051 only offsets returned by tell() are legal. Use of other offsets causes 1052 undefined behavior. 1053 Note that not all file objects are seekable. 1054 """ 1055 pass 1056 1057 def tell(self): # real signature unknown; restored from __doc__ 1058 """ tell() -> current file position, an integer (may be a long integer). """ 1059 pass 1060 1061 def truncate(self, size=None): # real signature unknown; restored from __doc__ 1062 """ 1063 truncate([size]) -> None. Truncate the file to at most size bytes. 1064 1065 Size defaults to the current file position, as returned by tell(). 1066 """ 1067 pass 1068 1069 def write(self, p_str): # real signature unknown; restored from __doc__ 1070 """ 1071 write(str) -> None. Write string str to file. 1072 1073 Note that due to buffering, flush() or close() may be needed before 1074 the file on disk reflects the data written. 1075 """ 1076 pass 1077 1078 def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__ 1079 """ 1080 writelines(sequence_of_strings) -> None. Write the strings to the file. 1081 1082 Note that newlines are not added. The sequence can be any iterable object 1083 producing strings. This is equivalent to calling write() for each string. 1084 """ 1085 pass 1086 1087 def xreadlines(self): # real signature unknown; restored from __doc__ 1088 """ 1089 xreadlines() -> returns self. 1090 1091 For backward compatibility. File objects now include the performance 1092 optimizations previously implemented in the xreadlines module. 1093 """ 1094 pass 1095 1096 def __delattr__(self, name): # real signature unknown; restored from __doc__ 1097 """ x.__delattr__(‘name‘) <==> del x.name """ 1098 pass 1099 1100 def __enter__(self): # real signature unknown; restored from __doc__ 1101 """ __enter__() -> self. """ 1102 return self 1103 1104 def __exit__(self, *excinfo): # real signature unknown; restored from __doc__ 1105 """ __exit__(*excinfo) -> None. Closes the file. """ 1106 pass 1107 1108 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 1109 """ x.__getattribute__(‘name‘) <==> x.name """ 1110 pass 1111 1112 def __init__(self, name, mode=None, buffering=None): # real signature unknown; restored from __doc__ 1113 pass 1114 1115 def __iter__(self): # real signature unknown; restored from __doc__ 1116 """ x.__iter__() <==> iter(x) """ 1117 pass 1118 1119 @staticmethod # known case of __new__ 1120 def __new__(S, *more): # real signature unknown; restored from __doc__ 1121 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 1122 pass 1123 1124 def __repr__(self): # real signature unknown; restored from __doc__ 1125 """ x.__repr__() <==> repr(x) """ 1126 pass 1127 1128 def __setattr__(self, name, value): # real signature unknown; restored from __doc__ 1129 """ x.__setattr__(‘name‘, value) <==> x.name = value """ 1130 pass 1131 1132 closed = property(lambda self: True) 1133 """True if the file is closed 1134 1135 :type: bool 1136 """ 1137 1138 encoding = property(lambda self: ‘‘) 1139 """file encoding 1140 1141 :type: string 1142 """ 1143 1144 errors = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 1145 """Unicode error handler""" 1146 1147 mode = property(lambda self: ‘‘) 1148 """file mode (‘r‘, ‘U‘, ‘w‘, ‘a‘, possibly with ‘b‘ or ‘+‘ added) 1149 1150 :type: string 1151 """ 1152 1153 name = property(lambda self: ‘‘) 1154 """file name 1155 1156 :type: string 1157 """ 1158 1159 newlines = property(lambda self: ‘‘) 1160 """end-of-line convention used in this file 1161 1162 :type: string 1163 """ 1164 1165 softspace = property(lambda self: True) 1166 """flag indicating that a space needs to be printed; used by print 1167 1168 :type: bool 1169 """ 1170 1171 1172 1173 class float(object): 1174 """ 1175 float(x) -> floating point number 1176 1177 Convert a string or number to a floating point number, if possible. 1178 """ 1179 def as_integer_ratio(self): # real signature unknown; restored from __doc__ 1180 """ 1181 float.as_integer_ratio() -> (int, int) 1182 1183 Return a pair of integers, whose ratio is exactly equal to the original 1184 float and with a positive denominator. 1185 Raise OverflowError on infinities and a ValueError on NaNs. 1186 1187 >>> (10.0).as_integer_ratio() 1188 (10, 1) 1189 >>> (0.0).as_integer_ratio() 1190 (0, 1) 1191 >>> (-.25).as_integer_ratio() 1192 (-1, 4) 1193 """ 1194 pass 1195 1196 def conjugate(self, *args, **kwargs): # real signature unknown 1197 """ Return self, the complex conjugate of any float. """ 1198 pass 1199 1200 def fromhex(self, string): # real signature unknown; restored from __doc__ 1201 """ 1202 float.fromhex(string) -> float 1203 1204 Create a floating-point number from a hexadecimal string. 1205 >>> float.fromhex(‘0x1.ffffp10‘) 1206 2047.984375 1207 >>> float.fromhex(‘-0x1p-1074‘) 1208 -4.9406564584124654e-324 1209 """ 1210 return 0.0 1211 1212 def hex(self): # real signature unknown; restored from __doc__ 1213 """ 1214 float.hex() -> string 1215 1216 Return a hexadecimal representation of a floating-point number. 1217 >>> (-0.1).hex() 1218 ‘-0x1.999999999999ap-4‘ 1219 >>> 3.14159.hex() 1220 ‘0x1.921f9f01b866ep+1‘ 1221 """ 1222 return "" 1223 1224 def is_integer(self, *args, **kwargs): # real signature unknown 1225 """ Return True if the float is an integer. """ 1226 pass 1227 1228 def __abs__(self): # real signature unknown; restored from __doc__ 1229 """ x.__abs__() <==> abs(x) """ 1230 pass 1231 1232 def __add__(self, y): # real signature unknown; restored from __doc__ 1233 """ x.__add__(y) <==> x+y """ 1234 pass 1235 1236 def __coerce__(self, y): # real signature unknown; restored from __doc__ 1237 """ x.__coerce__(y) <==> coerce(x, y) """ 1238 pass 1239 1240 def __divmod__(self, y): # real signature unknown; restored from __doc__ 1241 """ x.__divmod__(y) <==> divmod(x, y) """ 1242 pass 1243 1244 def __div__(self, y): # real signature unknown; restored from __doc__ 1245 """ x.__div__(y) <==> x/y """ 1246 pass 1247 1248 def __eq__(self, y): # real signature unknown; restored from __doc__ 1249 """ x.__eq__(y) <==> x==y """ 1250 pass 1251 1252 def __float__(self): # real signature unknown; restored from __doc__ 1253 """ x.__float__() <==> float(x) """ 1254 pass 1255 1256 def __floordiv__(self, y): # real signature unknown; restored from __doc__ 1257 """ x.__floordiv__(y) <==> x//y """ 1258 pass 1259 1260 def __format__(self, format_spec): # real signature unknown; restored from __doc__ 1261 """ 1262 float.__format__(format_spec) -> string 1263 1264 Formats the float according to format_spec. 1265 """ 1266 return "" 1267 1268 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 1269 """ x.__getattribute__(‘name‘) <==> x.name """ 1270 pass 1271 1272 def __getformat__(self, typestr): # real signature unknown; restored from __doc__ 1273 """ 1274 float.__getformat__(typestr) -> string 1275 1276 You probably don‘t want to use this function. It exists mainly to be 1277 used in Python‘s test suite. 1278 1279 typestr must be ‘double‘ or ‘float‘. This function returns whichever of 1280 ‘unknown‘, ‘IEEE, big-endian‘ or ‘IEEE, little-endian‘ best describes the 1281 format of floating point numbers used by the C type named by typestr. 1282 """ 1283 return "" 1284 1285 def __getnewargs__(self, *args, **kwargs): # real signature unknown 1286 pass 1287 1288 def __ge__(self, y): # real signature unknown; restored from __doc__ 1289 """ x.__ge__(y) <==> x>=y """ 1290 pass 1291 1292 def __gt__(self, y): # real signature unknown; restored from __doc__ 1293 """ x.__gt__(y) <==> x>y """ 1294 pass 1295 1296 def __hash__(self): # real signature unknown; restored from __doc__ 1297 """ x.__hash__() <==> hash(x) """ 1298 pass 1299 1300 def __init__(self, x): # real signature unknown; restored from __doc__ 1301 pass 1302 1303 def __int__(self): # real signature unknown; restored from __doc__ 1304 """ x.__int__() <==> int(x) """ 1305 pass 1306 1307 def __le__(self, y): # real signature unknown; restored from __doc__ 1308 """ x.__le__(y) <==> x<=y """ 1309 pass 1310 1311 def __long__(self): # real signature unknown; restored from __doc__ 1312 """ x.__long__() <==> long(x) """ 1313 pass 1314 1315 def __lt__(self, y): # real signature unknown; restored from __doc__ 1316 """ x.__lt__(y) <==> x<y """ 1317 pass 1318 1319 def __mod__(self, y): # real signature unknown; restored from __doc__ 1320 """ x.__mod__(y) <==> x%y """ 1321 pass 1322 1323 def __mul__(self, y): # real signature unknown; restored from __doc__ 1324 """ x.__mul__(y) <==> x*y """ 1325 pass 1326 1327 def __neg__(self): # real signature unknown; restored from __doc__ 1328 """ x.__neg__() <==> -x """ 1329 pass 1330 1331 @staticmethod # known case of __new__ 1332 def __new__(S, *more): # real signature unknown; restored from __doc__ 1333 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 1334 pass 1335 1336 def __ne__(self, y): # real signature unknown; restored from __doc__ 1337 """ x.__ne__(y) <==> x!=y """ 1338 pass 1339 1340 def __nonzero__(self): # real signature unknown; restored from __doc__ 1341 """ x.__nonzero__() <==> x != 0 """ 1342 pass 1343 1344 def __pos__(self): # real signature unknown; restored from __doc__ 1345 """ x.__pos__() <==> +x """ 1346 pass 1347 1348 def __pow__(self, y, z=None): # real signature unknown; restored from __doc__ 1349 """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """ 1350 pass 1351 1352 def __radd__(self, y): # real signature unknown; restored from __doc__ 1353 """ x.__radd__(y) <==> y+x """ 1354 pass 1355 1356 def __rdivmod__(self, y): # real signature unknown; restored from __doc__ 1357 """ x.__rdivmod__(y) <==> divmod(y, x) """ 1358 pass 1359 1360 def __rdiv__(self, y): # real signature unknown; restored from __doc__ 1361 """ x.__rdiv__(y) <==> y/x """ 1362 pass 1363 1364 def __repr__(self): # real signature unknown; restored from __doc__ 1365 """ x.__repr__() <==> repr(x) """ 1366 pass 1367 1368 def __rfloordiv__(self, y): # real signature unknown; restored from __doc__ 1369 """ x.__rfloordiv__(y) <==> y//x """ 1370 pass 1371 1372 def __rmod__(self, y): # real signature unknown; restored from __doc__ 1373 """ x.__rmod__(y) <==> y%x """ 1374 pass 1375 1376 def __rmul__(self, y): # real signature unknown; restored from __doc__ 1377 """ x.__rmul__(y) <==> y*x """ 1378 pass 1379 1380 def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__ 1381 """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """ 1382 pass 1383 1384 def __rsub__(self, y): # real signature unknown; restored from __doc__ 1385 """ x.__rsub__(y) <==> y-x """ 1386 pass 1387 1388 def __rtruediv__(self, y): # real signature unknown; restored from __doc__ 1389 """ x.__rtruediv__(y) <==> y/x """ 1390 pass 1391 1392 def __setformat__(self, typestr, fmt): # real signature unknown; restored from __doc__ 1393 """ 1394 float.__setformat__(typestr, fmt) -> None 1395 1396 You probably don‘t want to use this function. It exists mainly to be 1397 used in Python‘s test suite. 1398 1399 typestr must be ‘double‘ or ‘float‘. fmt must be one of ‘unknown‘, 1400 ‘IEEE, big-endian‘ or ‘IEEE, little-endian‘, and in addition can only be 1401 one of the latter two if it appears to match the underlying C reality. 1402 1403 Override the automatic determination of C-level floating point type. 1404 This affects how floats are converted to and from binary strings. 1405 """ 1406 pass 1407 1408 def __str__(self): # real signature unknown; restored from __doc__ 1409 """ x.__str__() <==> str(x) """ 1410 pass 1411 1412 def __sub__(self, y): # real signature unknown; restored from __doc__ 1413 """ x.__sub__(y) <==> x-y """ 1414 pass 1415 1416 def __truediv__(self, y): # real signature unknown; restored from __doc__ 1417 """ x.__truediv__(y) <==> x/y """ 1418 pass 1419 1420 def __trunc__(self, *args, **kwargs): # real signature unknown 1421 """ Return the Integral closest to x between 0 and x. """ 1422 pass 1423 1424 imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 1425 """the imaginary part of a complex number""" 1426 1427 real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 1428 """the real part of a complex number""" 1429 1430 1431 1432 class frozenset(object): 1433 """ 1434 frozenset() -> empty frozenset object 1435 frozenset(iterable) -> frozenset object 1436 1437 Build an immutable unordered collection of unique elements. 1438 """ 1439 def copy(self, *args, **kwargs): # real signature unknown 1440 """ Return a shallow copy of a set. """ 1441 pass 1442 1443 def difference(self, *args, **kwargs): # real signature unknown 1444 """ 1445 Return the difference of two or more sets as a new set. 1446 1447 (i.e. all elements that are in this set but not the others.) 1448 """ 1449 pass 1450 1451 def intersection(self, *args, **kwargs): # real signature unknown 1452 """ 1453 Return the intersection of two or more sets as a new set. 1454 1455 (i.e. elements that are common to all of the sets.) 1456 """ 1457 pass 1458 1459 def isdisjoint(self, *args, **kwargs): # real signature unknown 1460 """ Return True if two sets have a null intersection. """ 1461 pass 1462 1463 def issubset(self, *args, **kwargs): # real signature unknown 1464 """ Report whether another set contains this set. """ 1465 pass 1466 1467 def issuperset(self, *args, **kwargs): # real signature unknown 1468 """ Report whether this set contains another set. """ 1469 pass 1470 1471 def symmetric_difference(self, *args, **kwargs): # real signature unknown 1472 """ 1473 Return the symmetric difference of two sets as a new set. 1474 1475 (i.e. all elements that are in exactly one of the sets.) 1476 """ 1477 pass 1478 1479 def union(self, *args, **kwargs): # real signature unknown 1480 """ 1481 Return the union of sets as a new set. 1482 1483 (i.e. all elements that are in either set.) 1484 """ 1485 pass 1486 1487 def __and__(self, y): # real signature unknown; restored from __doc__ 1488 """ x.__and__(y) <==> x&y """ 1489 pass 1490 1491 def __cmp__(self, y): # real signature unknown; restored from __doc__ 1492 """ x.__cmp__(y) <==> cmp(x,y) """ 1493 pass 1494 1495 def __contains__(self, y): # real signature unknown; restored from __doc__ 1496 """ x.__contains__(y) <==> y in x. """ 1497 pass 1498 1499 def __eq__(self, y): # real signature unknown; restored from __doc__ 1500 """ x.__eq__(y) <==> x==y """ 1501 pass 1502 1503 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 1504 """ x.__getattribute__(‘name‘) <==> x.name """ 1505 pass 1506 1507 def __ge__(self, y): # real signature unknown; restored from __doc__ 1508 """ x.__ge__(y) <==> x>=y """ 1509 pass 1510 1511 def __gt__(self, y): # real signature unknown; restored from __doc__ 1512 """ x.__gt__(y) <==> x>y """ 1513 pass 1514 1515 def __hash__(self): # real signature unknown; restored from __doc__ 1516 """ x.__hash__() <==> hash(x) """ 1517 pass 1518 1519 def __init__(self, seq=()): # known special case of frozenset.__init__ 1520 """ x.__init__(...) initializes x; see help(type(x)) for signature """ 1521 pass 1522 1523 def __iter__(self): # real signature unknown; restored from __doc__ 1524 """ x.__iter__() <==> iter(x) """ 1525 pass 1526 1527 def __len__(self): # real signature unknown; restored from __doc__ 1528 """ x.__len__() <==> len(x) """ 1529 pass 1530 1531 def __le__(self, y): # real signature unknown; restored from __doc__ 1532 """ x.__le__(y) <==> x<=y """ 1533 pass 1534 1535 def __lt__(self, y): # real signature unknown; restored from __doc__ 1536 """ x.__lt__(y) <==> x<y """ 1537 pass 1538 1539 @staticmethod # known case of __new__ 1540 def __new__(S, *more): # real signature unknown; restored from __doc__ 1541 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 1542 pass 1543 1544 def __ne__(self, y): # real signature unknown; restored from __doc__ 1545 """ x.__ne__(y) <==> x!=y """ 1546 pass 1547 1548 def __or__(self, y): # real signature unknown; restored from __doc__ 1549 """ x.__or__(y) <==> x|y """ 1550 pass 1551 1552 def __rand__(self, y): # real signature unknown; restored from __doc__ 1553 """ x.__rand__(y) <==> y&x """ 1554 pass 1555 1556 def __reduce__(self, *args, **kwargs): # real signature unknown 1557 """ Return state information for pickling. """ 1558 pass 1559 1560 def __repr__(self): # real signature unknown; restored from __doc__ 1561 """ x.__repr__() <==> repr(x) """ 1562 pass 1563 1564 def __ror__(self, y): # real signature unknown; restored from __doc__ 1565 """ x.__ror__(y) <==> y|x """ 1566 pass 1567 1568 def __rsub__(self, y): # real signature unknown; restored from __doc__ 1569 """ x.__rsub__(y) <==> y-x """ 1570 pass 1571 1572 def __rxor__(self, y): # real signature unknown; restored from __doc__ 1573 """ x.__rxor__(y) <==> y^x """ 1574 pass 1575 1576 def __sizeof__(self): # real signature unknown; restored from __doc__ 1577 """ S.__sizeof__() -> size of S in memory, in bytes """ 1578 pass 1579 1580 def __sub__(self, y): # real signature unknown; restored from __doc__ 1581 """ x.__sub__(y) <==> x-y """ 1582 pass 1583 1584 def __xor__(self, y): # real signature unknown; restored from __doc__ 1585 """ x.__xor__(y) <==> x^y """ 1586 pass 1587 1588 1589 class list(object): 1590 """ 1591 list() -> new empty list 1592 list(iterable) -> new list initialized from iterable‘s items 1593 """ 1594 def append(self, p_object): # real signature unknown; restored from __doc__ 1595 """ L.append(object) -- append object to end """ 1596 pass 1597 1598 def count(self, value): # real signature unknown; restored from __doc__ 1599 """ L.count(value) -> integer -- return number of occurrences of value """ 1600 return 0 1601 1602 def extend(self, iterable): # real signature unknown; restored from __doc__ 1603 """ L.extend(iterable) -- extend list by appending elements from the iterable """ 1604 pass 1605 1606 def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__ 1607 """ 1608 L.index(value, [start, [stop]]) -> integer -- return first index of value. 1609 Raises ValueError if the value is not present. 1610 """ 1611 return 0 1612 1613 def insert(self, index, p_object): # real signature unknown; restored from __doc__ 1614 """ L.insert(index, object) -- insert object before index """ 1615 pass 1616 1617 def pop(self, index=None): # real signature unknown; restored from __doc__ 1618 """ 1619 L.pop([index]) -> item -- remove and return item at index (default last). 1620 Raises IndexError if list is empty or index is out of range. 1621 """ 1622 pass 1623 1624 def remove(self, value): # real signature unknown; restored from __doc__ 1625 """ 1626 L.remove(value) -- remove first occurrence of value. 1627 Raises ValueError if the value is not present. 1628 """ 1629 pass 1630 1631 def reverse(self): # real signature unknown; restored from __doc__ 1632 """ L.reverse() -- reverse *IN PLACE* """ 1633 pass 1634 1635 def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__ 1636 """ 1637 L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*; 1638 cmp(x, y) -> -1, 0, 1 1639 """ 1640 pass 1641 1642 def __add__(self, y): # real signature unknown; restored from __doc__ 1643 """ x.__add__(y) <==> x+y """ 1644 pass 1645 1646 def __contains__(self, y): # real signature unknown; restored from __doc__ 1647 """ x.__contains__(y) <==> y in x """ 1648 pass 1649 1650 def __delitem__(self, y): # real signature unknown; restored from __doc__ 1651 """ x.__delitem__(y) <==> del x[y] """ 1652 pass 1653 1654 def __delslice__(self, i, j): # real signature unknown; restored from __doc__ 1655 """ 1656 x.__delslice__(i, j) <==> del x[i:j] 1657 1658 Use of negative indices is not supported. 1659 """ 1660 pass 1661 1662 def __eq__(self, y): # real signature unknown; restored from __doc__ 1663 """ x.__eq__(y) <==> x==y """ 1664 pass 1665 1666 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 1667 """ x.__getattribute__(‘name‘) <==> x.name """ 1668 pass 1669 1670 def __getitem__(self, y): # real signature unknown; restored from __doc__ 1671 """ x.__getitem__(y) <==> x[y] """ 1672 pass 1673 1674 def __getslice__(self, i, j): # real signature unknown; restored from __doc__ 1675 """ 1676 x.__getslice__(i, j) <==> x[i:j] 1677 1678 Use of negative indices is not supported. 1679 """ 1680 pass 1681 1682 def __ge__(self, y): # real signature unknown; restored from __doc__ 1683 """ x.__ge__(y) <==> x>=y """ 1684 pass 1685 1686 def __gt__(self, y): # real signature unknown; restored from __doc__ 1687 """ x.__gt__(y) <==> x>y """ 1688 pass 1689 1690 def __iadd__(self, y): # real signature unknown; restored from __doc__ 1691 """ x.__iadd__(y) <==> x+=y """ 1692 pass 1693 1694 def __imul__(self, y): # real signature unknown; restored from __doc__ 1695 """ x.__imul__(y) <==> x*=y """ 1696 pass 1697 1698 def __init__(self, seq=()): # known special case of list.__init__ 1699 """ 1700 list() -> new empty list 1701 list(iterable) -> new list initialized from iterable‘s items 1702 # (copied from class doc) 1703 """ 1704 pass 1705 1706 def __iter__(self): # real signature unknown; restored from __doc__ 1707 """ x.__iter__() <==> iter(x) """ 1708 pass 1709 1710 def __len__(self): # real signature unknown; restored from __doc__ 1711 """ x.__len__() <==> len(x) """ 1712 pass 1713 1714 def __le__(self, y): # real signature unknown; restored from __doc__ 1715 """ x.__le__(y) <==> x<=y """ 1716 pass 1717 1718 def __lt__(self, y): # real signature unknown; restored from __doc__ 1719 """ x.__lt__(y) <==> x<y """ 1720 pass 1721 1722 def __mul__(self, n): # real signature unknown; restored from __doc__ 1723 """ x.__mul__(n) <==> x*n """ 1724 pass 1725 1726 @staticmethod # known case of __new__ 1727 def __new__(S, *more): # real signature unknown; restored from __doc__ 1728 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 1729 pass 1730 1731 def __ne__(self, y): # real signature unknown; restored from __doc__ 1732 """ x.__ne__(y) <==> x!=y """ 1733 pass 1734 1735 def __repr__(self): # real signature unknown; restored from __doc__ 1736 """ x.__repr__() <==> repr(x) """ 1737 pass 1738 1739 def __reversed__(self): # real signature unknown; restored from __doc__ 1740 """ L.__reversed__() -- return a reverse iterator over the list """ 1741 pass 1742 1743 def __rmul__(self, n): # real signature unknown; restored from __doc__ 1744 """ x.__rmul__(n) <==> n*x """ 1745 pass 1746 1747 def __setitem__(self, i, y): # real signature unknown; restored from __doc__ 1748 """ x.__setitem__(i, y) <==> x[i]=y """ 1749 pass 1750 1751 def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__ 1752 """ 1753 x.__setslice__(i, j, y) <==> x[i:j]=y 1754 1755 Use of negative indices is not supported. 1756 """ 1757 pass 1758 1759 def __sizeof__(self): # real signature unknown; restored from __doc__ 1760 """ L.__sizeof__() -- size of L in memory, in bytes """ 1761 pass 1762 1763 __hash__ = None 1764 1765 1766 class long(object): 1767 """ 1768 long(x=0) -> long 1769 long(x, base=10) -> long 1770 1771 Convert a number or string to a long integer, or return 0L if no arguments 1772 are given. If x is floating point, the conversion truncates towards zero. 1773 1774 If x is not a number or if base is given, then x must be a string or 1775 Unicode object representing an integer literal in the given base. The 1776 literal can be preceded by ‘+‘ or ‘-‘ and be surrounded by whitespace. 1777 The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to 1778 interpret the base from the string as an integer literal. 1779 >>> int(‘0b100‘, base=0) 1780 4L 1781 """ 1782 def bit_length(self): # real signature unknown; restored from __doc__ 1783 """ 1784 long.bit_length() -> int or long 1785 1786 Number of bits necessary to represent self in binary. 1787 >>> bin(37L) 1788 ‘0b100101‘ 1789 >>> (37L).bit_length() 1790 6 1791 """ 1792 return 0 1793 1794 def conjugate(self, *args, **kwargs): # real signature unknown 1795 """ Returns self, the complex conjugate of any long. """ 1796 pass 1797 1798 def __abs__(self): # real signature unknown; restored from __doc__ 1799 """ x.__abs__() <==> abs(x) """ 1800 pass 1801 1802 def __add__(self, y): # real signature unknown; restored from __doc__ 1803 """ x.__add__(y) <==> x+y """ 1804 pass 1805 1806 def __and__(self, y): # real signature unknown; restored from __doc__ 1807 """ x.__and__(y) <==> x&y """ 1808 pass 1809 1810 def __cmp__(self, y): # real signature unknown; restored from __doc__ 1811 """ x.__cmp__(y) <==> cmp(x,y) """ 1812 pass 1813 1814 def __coerce__(self, y): # real signature unknown; restored from __doc__ 1815 """ x.__coerce__(y) <==> coerce(x, y) """ 1816 pass 1817 1818 def __divmod__(self, y): # real signature unknown; restored from __doc__ 1819 """ x.__divmod__(y) <==> divmod(x, y) """ 1820 pass 1821 1822 def __div__(self, y): # real signature unknown; restored from __doc__ 1823 """ x.__div__(y) <==> x/y """ 1824 pass 1825 1826 def __float__(self): # real signature unknown; restored from __doc__ 1827 """ x.__float__() <==> float(x) """ 1828 pass 1829 1830 def __floordiv__(self, y): # real signature unknown; restored from __doc__ 1831 """ x.__floordiv__(y) <==> x//y """ 1832 pass 1833 1834 def __format__(self, *args, **kwargs): # real signature unknown 1835 pass 1836 1837 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 1838 """ x.__getattribute__(‘name‘) <==> x.name """ 1839 pass 1840 1841 def __getnewargs__(self, *args, **kwargs): # real signature unknown 1842 pass 1843 1844 def __hash__(self): # real signature unknown; restored from __doc__ 1845 """ x.__hash__() <==> hash(x) """ 1846 pass 1847 1848 def __hex__(self): # real signature unknown; restored from __doc__ 1849 """ x.__hex__() <==> hex(x) """ 1850 pass 1851 1852 def __index__(self): # real signature unknown; restored from __doc__ 1853 """ x[y:z] <==> x[y.__index__():z.__index__()] """ 1854 pass 1855 1856 def __init__(self, x=0): # real signature unknown; restored from __doc__ 1857 pass 1858 1859 def __int__(self): # real signature unknown; restored from __doc__ 1860 """ x.__int__() <==> int(x) """ 1861 pass 1862 1863 def __invert__(self): # real signature unknown; restored from __doc__ 1864 """ x.__invert__() <==> ~x """ 1865 pass 1866 1867 def __long__(self): # real signature unknown; restored from __doc__ 1868 """ x.__long__() <==> long(x) """ 1869 pass 1870 1871 def __lshift__(self, y): # real signature unknown; restored from __doc__ 1872 """ x.__lshift__(y) <==> x<<y """ 1873 pass 1874 1875 def __mod__(self, y): # real signature unknown; restored from __doc__ 1876 """ x.__mod__(y) <==> x%y """ 1877 pass 1878 1879 def __mul__(self, y): # real signature unknown; restored from __doc__ 1880 """ x.__mul__(y) <==> x*y """ 1881 pass 1882 1883 def __neg__(self): # real signature unknown; restored from __doc__ 1884 """ x.__neg__() <==> -x """ 1885 pass 1886 1887 @staticmethod # known case of __new__ 1888 def __new__(S, *more): # real signature unknown; restored from __doc__ 1889 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 1890 pass 1891 1892 def __nonzero__(self): # real signature unknown; restored from __doc__ 1893 """ x.__nonzero__() <==> x != 0 """ 1894 pass 1895 1896 def __oct__(self): # real signature unknown; restored from __doc__ 1897 """ x.__oct__() <==> oct(x) """ 1898 pass 1899 1900 def __or__(self, y): # real signature unknown; restored from __doc__ 1901 """ x.__or__(y) <==> x|y """ 1902 pass 1903 1904 def __pos__(self): # real signature unknown; restored from __doc__ 1905 """ x.__pos__() <==> +x """ 1906 pass 1907 1908 def __pow__(self, y, z=None): # real signature unknown; restored from __doc__ 1909 """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """ 1910 pass 1911 1912 def __radd__(self, y): # real signature unknown; restored from __doc__ 1913 """ x.__radd__(y) <==> y+x """ 1914 pass 1915 1916 def __rand__(self, y): # real signature unknown; restored from __doc__ 1917 """ x.__rand__(y) <==> y&x """ 1918 pass 1919 1920 def __rdivmod__(self, y): # real signature unknown; restored from __doc__ 1921 """ x.__rdivmod__(y) <==> divmod(y, x) """ 1922 pass 1923 1924 def __rdiv__(self, y): # real signature unknown; restored from __doc__ 1925 """ x.__rdiv__(y) <==> y/x """ 1926 pass 1927 1928 def __repr__(self): # real signature unknown; restored from __doc__ 1929 """ x.__repr__() <==> repr(x) """ 1930 pass 1931 1932 def __rfloordiv__(self, y): # real signature unknown; restored from __doc__ 1933 """ x.__rfloordiv__(y) <==> y//x """ 1934 pass 1935 1936 def __rlshift__(self, y): # real signature unknown; restored from __doc__ 1937 """ x.__rlshift__(y) <==> y<<x """ 1938 pass 1939 1940 def __rmod__(self, y): # real signature unknown; restored from __doc__ 1941 """ x.__rmod__(y) <==> y%x """ 1942 pass 1943 1944 def __rmul__(self, y): # real signature unknown; restored from __doc__ 1945 """ x.__rmul__(y) <==> y*x """ 1946 pass 1947 1948 def __ror__(self, y): # real signature unknown; restored from __doc__ 1949 """ x.__ror__(y) <==> y|x """ 1950 pass 1951 1952 def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__ 1953 """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """ 1954 pass 1955 1956 def __rrshift__(self, y): # real signature unknown; restored from __doc__ 1957 """ x.__rrshift__(y) <==> y>>x """ 1958 pass 1959 1960 def __rshift__(self, y): # real signature unknown; restored from __doc__ 1961 """ x.__rshift__(y) <==> x>>y """ 1962 pass 1963 1964 def __rsub__(self, y): # real signature unknown; restored from __doc__ 1965 """ x.__rsub__(y) <==> y-x """ 1966 pass 1967 1968 def __rtruediv__(self, y): # real signature unknown; restored from __doc__ 1969 """ x.__rtruediv__(y) <==> y/x """ 1970 pass 1971 1972 def __rxor__(self, y): # real signature unknown; restored from __doc__ 1973 """ x.__rxor__(y) <==> y^x """ 1974 pass 1975 1976 def __sizeof__(self, *args, **kwargs): # real signature unknown 1977 """ Returns size in memory, in bytes """ 1978 pass 1979 1980 def __str__(self): # real signature unknown; restored from __doc__ 1981 """ x.__str__() <==> str(x) """ 1982 pass 1983 1984 def __sub__(self, y): # real signature unknown; restored from __doc__ 1985 """ x.__sub__(y) <==> x-y """ 1986 pass 1987 1988 def __truediv__(self, y): # real signature unknown; restored from __doc__ 1989 """ x.__truediv__(y) <==> x/y """ 1990 pass 1991 1992 def __trunc__(self, *args, **kwargs): # real signature unknown 1993 """ Truncating an Integral returns itself. """ 1994 pass 1995 1996 def __xor__(self, y): # real signature unknown; restored from __doc__ 1997 """ x.__xor__(y) <==> x^y """ 1998 pass 1999 2000 denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2001 """the denominator of a rational number in lowest terms""" 2002 2003 imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2004 """the imaginary part of a complex number""" 2005 2006 numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2007 """the numerator of a rational number in lowest terms""" 2008 2009 real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2010 """the real part of a complex number""" 2011 2012 2013 2014 class memoryview(object): 2015 """ 2016 memoryview(object) 2017 2018 Create a new memoryview object which references the given object. 2019 """ 2020 def tobytes(self, *args, **kwargs): # real signature unknown 2021 pass 2022 2023 def tolist(self, *args, **kwargs): # real signature unknown 2024 pass 2025 2026 def __delitem__(self, y): # real signature unknown; restored from __doc__ 2027 """ x.__delitem__(y) <==> del x[y] """ 2028 pass 2029 2030 def __eq__(self, y): # real signature unknown; restored from __doc__ 2031 """ x.__eq__(y) <==> x==y """ 2032 pass 2033 2034 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 2035 """ x.__getattribute__(‘name‘) <==> x.name """ 2036 pass 2037 2038 def __getitem__(self, y): # real signature unknown; restored from __doc__ 2039 """ x.__getitem__(y) <==> x[y] """ 2040 pass 2041 2042 def __ge__(self, y): # real signature unknown; restored from __doc__ 2043 """ x.__ge__(y) <==> x>=y """ 2044 pass 2045 2046 def __gt__(self, y): # real signature unknown; restored from __doc__ 2047 """ x.__gt__(y) <==> x>y """ 2048 pass 2049 2050 def __init__(self, p_object): # real signature unknown; restored from __doc__ 2051 pass 2052 2053 def __len__(self): # real signature unknown; restored from __doc__ 2054 """ x.__len__() <==> len(x) """ 2055 pass 2056 2057 def __le__(self, y): # real signature unknown; restored from __doc__ 2058 """ x.__le__(y) <==> x<=y """ 2059 pass 2060 2061 def __lt__(self, y): # real signature unknown; restored from __doc__ 2062 """ x.__lt__(y) <==> x<y """ 2063 pass 2064 2065 @staticmethod # known case of __new__ 2066 def __new__(S, *more): # real signature unknown; restored from __doc__ 2067 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 2068 pass 2069 2070 def __ne__(self, y): # real signature unknown; restored from __doc__ 2071 """ x.__ne__(y) <==> x!=y """ 2072 pass 2073 2074 def __repr__(self): # real signature unknown; restored from __doc__ 2075 """ x.__repr__() <==> repr(x) """ 2076 pass 2077 2078 def __setitem__(self, i, y): # real signature unknown; restored from __doc__ 2079 """ x.__setitem__(i, y) <==> x[i]=y """ 2080 pass 2081 2082 format = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2083 2084 itemsize = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2085 2086 ndim = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2087 2088 readonly = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2089 2090 shape = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2091 2092 strides = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2093 2094 suboffsets = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2095 2096 2097 2098 class property(object): 2099 """ 2100 property(fget=None, fset=None, fdel=None, doc=None) -> property attribute 2101 2102 fget is a function to be used for getting an attribute value, and likewise 2103 fset is a function for setting, and fdel a function for del‘ing, an 2104 attribute. Typical use is to define a managed attribute x: 2105 2106 class C(object): 2107 def getx(self): return self._x 2108 def setx(self, value): self._x = value 2109 def delx(self): del self._x 2110 x = property(getx, setx, delx, "I‘m the ‘x‘ property.") 2111 2112 Decorators make defining new properties or modifying existing ones easy: 2113 2114 class C(object): 2115 @property 2116 def x(self): 2117 "I am the ‘x‘ property." 2118 return self._x 2119 @x.setter 2120 def x(self, value): 2121 self._x = value 2122 @x.deleter 2123 def x(self): 2124 del self._x 2125 """ 2126 def deleter(self, *args, **kwargs): # real signature unknown 2127 """ Descriptor to change the deleter on a property. """ 2128 pass 2129 2130 def getter(self, *args, **kwargs): # real signature unknown 2131 """ Descriptor to change the getter on a property. """ 2132 pass 2133 2134 def setter(self, *args, **kwargs): # real signature unknown 2135 """ Descriptor to change the setter on a property. """ 2136 pass 2137 2138 def __delete__(self, obj): # real signature unknown; restored from __doc__ 2139 """ descr.__delete__(obj) """ 2140 pass 2141 2142 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 2143 """ x.__getattribute__(‘name‘) <==> x.name """ 2144 pass 2145 2146 def __get__(self, obj, type=None): # real signature unknown; restored from __doc__ 2147 """ descr.__get__(obj[, type]) -> value """ 2148 pass 2149 2150 def __init__(self, fget=None, fset=None, fdel=None, doc=None): # known special case of property.__init__ 2151 """ 2152 property(fget=None, fset=None, fdel=None, doc=None) -> property attribute 2153 2154 fget is a function to be used for getting an attribute value, and likewise 2155 fset is a function for setting, and fdel a function for del‘ing, an 2156 attribute. Typical use is to define a managed attribute x: 2157 2158 class C(object): 2159 def getx(self): return self._x 2160 def setx(self, value): self._x = value 2161 def delx(self): del self._x 2162 x = property(getx, setx, delx, "I‘m the ‘x‘ property.") 2163 2164 Decorators make defining new properties or modifying existing ones easy: 2165 2166 class C(object): 2167 @property 2168 def x(self): 2169 "I am the ‘x‘ property." 2170 return self._x 2171 @x.setter 2172 def x(self, value): 2173 self._x = value 2174 @x.deleter 2175 def x(self): 2176 del self._x 2177 2178 # (copied from class doc) 2179 """ 2180 pass 2181 2182 @staticmethod # known case of __new__ 2183 def __new__(S, *more): # real signature unknown; restored from __doc__ 2184 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 2185 pass 2186 2187 def __set__(self, obj, value): # real signature unknown; restored from __doc__ 2188 """ descr.__set__(obj, value) """ 2189 pass 2190 2191 fdel = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2192 2193 fget = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2194 2195 fset = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2196 2197 2198 2199 class reversed(object): 2200 """ 2201 reversed(sequence) -> reverse iterator over values of the sequence 2202 2203 Return a reverse iterator 2204 """ 2205 def next(self): # real signature unknown; restored from __doc__ 2206 """ x.next() -> the next value, or raise StopIteration """ 2207 pass 2208 2209 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 2210 """ x.__getattribute__(‘name‘) <==> x.name """ 2211 pass 2212 2213 def __init__(self, sequence): # real signature unknown; restored from __doc__ 2214 pass 2215 2216 def __iter__(self): # real signature unknown; restored from __doc__ 2217 """ x.__iter__() <==> iter(x) """ 2218 pass 2219 2220 def __length_hint__(self, *args, **kwargs): # real signature unknown 2221 """ Private method returning an estimate of len(list(it)). """ 2222 pass 2223 2224 @staticmethod # known case of __new__ 2225 def __new__(S, *more): # real signature unknown; restored from __doc__ 2226 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 2227 pass 2228 2229 2230 class set(object): 2231 """ 2232 set() -> new empty set object 2233 set(iterable) -> new set object 2234 2235 Build an unordered collection of unique elements. 2236 """ 2237 def add(self, *args, **kwargs): # real signature unknown 2238 """ 2239 Add an element to a set. 2240 2241 This has no effect if the element is already present. 2242 """ 2243 pass 2244 2245 def clear(self, *args, **kwargs): # real signature unknown 2246 """ Remove all elements from this set. """ 2247 pass 2248 2249 def copy(self, *args, **kwargs): # real signature unknown 2250 """ Return a shallow copy of a set. """ 2251 pass 2252 2253 def difference(self, *args, **kwargs): # real signature unknown 2254 """ 2255 Return the difference of two or more sets as a new set. 2256 2257 (i.e. all elements that are in this set but not the others.) 2258 """ 2259 pass 2260 2261 def difference_update(self, *args, **kwargs): # real signature unknown 2262 """ Remove all elements of another set from this set. """ 2263 pass 2264 2265 def discard(self, *args, **kwargs): # real signature unknown 2266 """ 2267 Remove an element from a set if it is a member. 2268 2269 If the element is not a member, do nothing. 2270 """ 2271 pass 2272 2273 def intersection(self, *args, **kwargs): # real signature unknown 2274 """ 2275 Return the intersection of two or more sets as a new set. 2276 2277 (i.e. elements that are common to all of the sets.) 2278 """ 2279 pass 2280 2281 def intersection_update(self, *args, **kwargs): # real signature unknown 2282 """ Update a set with the intersection of itself and another. """ 2283 pass 2284 2285 def isdisjoint(self, *args, **kwargs): # real signature unknown 2286 """ Return True if two sets have a null intersection. """ 2287 pass 2288 2289 def issubset(self, *args, **kwargs): # real signature unknown 2290 """ Report whether another set contains this set. """ 2291 pass 2292 2293 def issuperset(self, *args, **kwargs): # real signature unknown 2294 """ Report whether this set contains another set. """ 2295 pass 2296 2297 def pop(self, *args, **kwargs): # real signature unknown 2298 """ 2299 Remove and return an arbitrary set element. 2300 Raises KeyError if the set is empty. 2301 """ 2302 pass 2303 2304 def remove(self, *args, **kwargs): # real signature unknown 2305 """ 2306 Remove an element from a set; it must be a member. 2307 2308 If the element is not a member, raise a KeyError. 2309 """ 2310 pass 2311 2312 def symmetric_difference(self, *args, **kwargs): # real signature unknown 2313 """ 2314 Return the symmetric difference of two sets as a new set. 2315 2316 (i.e. all elements that are in exactly one of the sets.) 2317 """ 2318 pass 2319 2320 def symmetric_difference_update(self, *args, **kwargs): # real signature unknown 2321 """ Update a set with the symmetric difference of itself and another. """ 2322 pass 2323 2324 def union(self, *args, **kwargs): # real signature unknown 2325 """ 2326 Return the union of sets as a new set. 2327 2328 (i.e. all elements that are in either set.) 2329 """ 2330 pass 2331 2332 def update(self, *args, **kwargs): # real signature unknown 2333 """ Update a set with the union of itself and others. """ 2334 pass 2335 2336 def __and__(self, y): # real signature unknown; restored from __doc__ 2337 """ x.__and__(y) <==> x&y """ 2338 pass 2339 2340 def __cmp__(self, y): # real signature unknown; restored from __doc__ 2341 """ x.__cmp__(y) <==> cmp(x,y) """ 2342 pass 2343 2344 def __contains__(self, y): # real signature unknown; restored from __doc__ 2345 """ x.__contains__(y) <==> y in x. """ 2346 pass 2347 2348 def __eq__(self, y): # real signature unknown; restored from __doc__ 2349 """ x.__eq__(y) <==> x==y """ 2350 pass 2351 2352 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 2353 """ x.__getattribute__(‘name‘) <==> x.name """ 2354 pass 2355 2356 def __ge__(self, y): # real signature unknown; restored from __doc__ 2357 """ x.__ge__(y) <==> x>=y """ 2358 pass 2359 2360 def __gt__(self, y): # real signature unknown; restored from __doc__ 2361 """ x.__gt__(y) <==> x>y """ 2362 pass 2363 2364 def __iand__(self, y): # real signature unknown; restored from __doc__ 2365 """ x.__iand__(y) <==> x&=y """ 2366 pass 2367 2368 def __init__(self, seq=()): # known special case of set.__init__ 2369 """ 2370 set() -> new empty set object 2371 set(iterable) -> new set object 2372 2373 Build an unordered collection of unique elements. 2374 # (copied from class doc) 2375 """ 2376 pass 2377 2378 def __ior__(self, y): # real signature unknown; restored from __doc__ 2379 """ x.__ior__(y) <==> x|=y """ 2380 pass 2381 2382 def __isub__(self, y): # real signature unknown; restored from __doc__ 2383 """ x.__isub__(y) <==> x-=y """ 2384 pass 2385 2386 def __iter__(self): # real signature unknown; restored from __doc__ 2387 """ x.__iter__() <==> iter(x) """ 2388 pass 2389 2390 def __ixor__(self, y): # real signature unknown; restored from __doc__ 2391 """ x.__ixor__(y) <==> x^=y """ 2392 pass 2393 2394 def __len__(self): # real signature unknown; restored from __doc__ 2395 """ x.__len__() <==> len(x) """ 2396 pass 2397 2398 def __le__(self, y): # real signature unknown; restored from __doc__ 2399 """ x.__le__(y) <==> x<=y """ 2400 pass 2401 2402 def __lt__(self, y): # real signature unknown; restored from __doc__ 2403 """ x.__lt__(y) <==> x<y """ 2404 pass 2405 2406 @staticmethod # known case of __new__ 2407 def __new__(S, *more): # real signature unknown; restored from __doc__ 2408 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 2409 pass 2410 2411 def __ne__(self, y): # real signature unknown; restored from __doc__ 2412 """ x.__ne__(y) <==> x!=y """ 2413 pass 2414 2415 def __or__(self, y): # real signature unknown; restored from __doc__ 2416 """ x.__or__(y) <==> x|y """ 2417 pass 2418 2419 def __rand__(self, y): # real signature unknown; restored from __doc__ 2420 """ x.__rand__(y) <==> y&x """ 2421 pass 2422 2423 def __reduce__(self, *args, **kwargs): # real signature unknown 2424 """ Return state information for pickling. """ 2425 pass 2426 2427 def __repr__(self): # real signature unknown; restored from __doc__ 2428 """ x.__repr__() <==> repr(x) """ 2429 pass 2430 2431 def __ror__(self, y): # real signature unknown; restored from __doc__ 2432 """ x.__ror__(y) <==> y|x """ 2433 pass 2434 2435 def __rsub__(self, y): # real signature unknown; restored from __doc__ 2436 """ x.__rsub__(y) <==> y-x """ 2437 pass 2438 2439 def __rxor__(self, y): # real signature unknown; restored from __doc__ 2440 """ x.__rxor__(y) <==> y^x """ 2441 pass 2442 2443 def __sizeof__(self): # real signature unknown; restored from __doc__ 2444 """ S.__sizeof__() -> size of S in memory, in bytes """ 2445 pass 2446 2447 def __sub__(self, y): # real signature unknown; restored from __doc__ 2448 """ x.__sub__(y) <==> x-y """ 2449 pass 2450 2451 def __xor__(self, y): # real signature unknown; restored from __doc__ 2452 """ x.__xor__(y) <==> x^y """ 2453 pass 2454 2455 __hash__ = None 2456 2457 2458 class slice(object): 2459 """ 2460 slice(stop) 2461 slice(start, stop[, step]) 2462 2463 Create a slice object. This is used for extended slicing (e.g. a[0:10:2]). 2464 """ 2465 def indices(self, len): # real signature unknown; restored from __doc__ 2466 """ 2467 S.indices(len) -> (start, stop, stride) 2468 2469 Assuming a sequence of length len, calculate the start and stop 2470 indices, and the stride length of the extended slice described by 2471 S. Out of bounds indices are clipped in a manner consistent with the 2472 handling of normal slices. 2473 """ 2474 pass 2475 2476 def __cmp__(self, y): # real signature unknown; restored from __doc__ 2477 """ x.__cmp__(y) <==> cmp(x,y) """ 2478 pass 2479 2480 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 2481 """ x.__getattribute__(‘name‘) <==> x.name """ 2482 pass 2483 2484 def __hash__(self): # real signature unknown; restored from __doc__ 2485 """ x.__hash__() <==> hash(x) """ 2486 pass 2487 2488 def __init__(self, stop): # real signature unknown; restored from __doc__ 2489 pass 2490 2491 @staticmethod # known case of __new__ 2492 def __new__(S, *more): # real signature unknown; restored from __doc__ 2493 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 2494 pass 2495 2496 def __reduce__(self, *args, **kwargs): # real signature unknown 2497 """ Return state information for pickling. """ 2498 pass 2499 2500 def __repr__(self): # real signature unknown; restored from __doc__ 2501 """ x.__repr__() <==> repr(x) """ 2502 pass 2503 2504 start = property(lambda self: 0) 2505 """:type: int""" 2506 2507 step = property(lambda self: 0) 2508 """:type: int""" 2509 2510 stop = property(lambda self: 0) 2511 """:type: int""" 2512 2513 2514 2515 class staticmethod(object): 2516 """ 2517 staticmethod(function) -> method 2518 2519 Convert a function to be a static method. 2520 2521 A static method does not receive an implicit first argument. 2522 To declare a static method, use this idiom: 2523 2524 class C: 2525 def f(arg1, arg2, ...): ... 2526 f = staticmethod(f) 2527 2528 It can be called either on the class (e.g. C.f()) or on an instance 2529 (e.g. C().f()). The instance is ignored except for its class. 2530 2531 Static methods in Python are similar to those found in Java or C++. 2532 For a more advanced concept, see the classmethod builtin. 2533 """ 2534 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 2535 """ x.__getattribute__(‘name‘) <==> x.name """ 2536 pass 2537 2538 def __get__(self, obj, type=None): # real signature unknown; restored from __doc__ 2539 """ descr.__get__(obj[, type]) -> value """ 2540 pass 2541 2542 def __init__(self, function): # real signature unknown; restored from __doc__ 2543 pass 2544 2545 @staticmethod # known case of __new__ 2546 def __new__(S, *more): # real signature unknown; restored from __doc__ 2547 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 2548 pass 2549 2550 __func__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2551 2552 2553 2554 class super(object): 2555 """ 2556 super(type, obj) -> bound super object; requires isinstance(obj, type) 2557 super(type) -> unbound super object 2558 super(type, type2) -> bound super object; requires issubclass(type2, type) 2559 Typical use to call a cooperative superclass method: 2560 class C(B): 2561 def meth(self, arg): 2562 super(C, self).meth(arg) 2563 """ 2564 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 2565 """ x.__getattribute__(‘name‘) <==> x.name """ 2566 pass 2567 2568 def __get__(self, obj, type=None): # real signature unknown; restored from __doc__ 2569 """ descr.__get__(obj[, type]) -> value """ 2570 pass 2571 2572 def __init__(self, type1, type2=None): # known special case of super.__init__ 2573 """ 2574 super(type, obj) -> bound super object; requires isinstance(obj, type) 2575 super(type) -> unbound super object 2576 super(type, type2) -> bound super object; requires issubclass(type2, type) 2577 Typical use to call a cooperative superclass method: 2578 class C(B): 2579 def meth(self, arg): 2580 super(C, self).meth(arg) 2581 # (copied from class doc) 2582 """ 2583 pass 2584 2585 @staticmethod # known case of __new__ 2586 def __new__(S, *more): # real signature unknown; restored from __doc__ 2587 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 2588 pass 2589 2590 def __repr__(self): # real signature unknown; restored from __doc__ 2591 """ x.__repr__() <==> repr(x) """ 2592 pass 2593 2594 __self_class__ = property(lambda self: type(object)) 2595 """the type of the instance invoking super(); may be None 2596 2597 :type: type 2598 """ 2599 2600 __self__ = property(lambda self: type(object)) 2601 """the instance invoking super(); may be None 2602 2603 :type: type 2604 """ 2605 2606 __thisclass__ = property(lambda self: type(object)) 2607 """the class invoking super() 2608 2609 :type: type 2610 """ 2611 2612 2613 2614 class tuple(object): 2615 """ 2616 tuple() -> empty tuple 2617 tuple(iterable) -> tuple initialized from iterable‘s items 2618 2619 If the argument is a tuple, the return value is the same object. 2620 """ 2621 def count(self, value): # real signature unknown; restored from __doc__ 2622 """ T.count(value) -> integer -- return number of occurrences of value """ 2623 return 0 2624 2625 def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__ 2626 """ 2627 T.index(value, [start, [stop]]) -> integer -- return first index of value. 2628 Raises ValueError if the value is not present. 2629 """ 2630 return 0 2631 2632 def __add__(self, y): # real signature unknown; restored from __doc__ 2633 """ x.__add__(y) <==> x+y """ 2634 pass 2635 2636 def __contains__(self, y): # real signature unknown; restored from __doc__ 2637 """ x.__contains__(y) <==> y in x """ 2638 pass 2639 2640 def __eq__(self, y): # real signature unknown; restored from __doc__ 2641 """ x.__eq__(y) <==> x==y """ 2642 pass 2643 2644 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 2645 """ x.__getattribute__(‘name‘) <==> x.name """ 2646 pass 2647 2648 def __getitem__(self, y): # real signature unknown; restored from __doc__ 2649 """ x.__getitem__(y) <==> x[y] """ 2650 pass 2651 2652 def __getnewargs__(self, *args, **kwargs): # real signature unknown 2653 pass 2654 2655 def __getslice__(self, i, j): # real signature unknown; restored from __doc__ 2656 """ 2657 x.__getslice__(i, j) <==> x[i:j] 2658 2659 Use of negative indices is not supported. 2660 """ 2661 pass 2662 2663 def __ge__(self, y): # real signature unknown; restored from __doc__ 2664 """ x.__ge__(y) <==> x>=y """ 2665 pass 2666 2667 def __gt__(self, y): # real signature unknown; restored from __doc__ 2668 """ x.__gt__(y) <==> x>y """ 2669 pass 2670 2671 def __hash__(self): # real signature unknown; restored from __doc__ 2672 """ x.__hash__() <==> hash(x) """ 2673 pass 2674 2675 def __init__(self, seq=()): # known special case of tuple.__init__ 2676 """ 2677 tuple() -> empty tuple 2678 tuple(iterable) -> tuple initialized from iterable‘s items 2679 2680 If the argument is a tuple, the return value is the same object. 2681 # (copied from class doc) 2682 """ 2683 pass 2684 2685 def __iter__(self): # real signature unknown; restored from __doc__ 2686 """ x.__iter__() <==> iter(x) """ 2687 pass 2688 2689 def __len__(self): # real signature unknown; restored from __doc__ 2690 """ x.__len__() <==> len(x) """ 2691 pass 2692 2693 def __le__(self, y): # real signature unknown; restored from __doc__ 2694 """ x.__le__(y) <==> x<=y """ 2695 pass 2696 2697 def __lt__(self, y): # real signature unknown; restored from __doc__ 2698 """ x.__lt__(y) <==> x<y """ 2699 pass 2700 2701 def __mul__(self, n): # real signature unknown; restored from __doc__ 2702 """ x.__mul__(n) <==> x*n """ 2703 pass 2704 2705 @staticmethod # known case of __new__ 2706 def __new__(S, *more): # real signature unknown; restored from __doc__ 2707 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 2708 pass 2709 2710 def __ne__(self, y): # real signature unknown; restored from __doc__ 2711 """ x.__ne__(y) <==> x!=y """ 2712 pass 2713 2714 def __repr__(self): # real signature unknown; restored from __doc__ 2715 """ x.__repr__() <==> repr(x) """ 2716 pass 2717 2718 def __rmul__(self, n): # real signature unknown; restored from __doc__ 2719 """ x.__rmul__(n) <==> n*x """ 2720 pass 2721 2722 2723 class type(object): 2724 """ 2725 type(object) -> the object‘s type 2726 type(name, bases, dict) -> a new type 2727 """ 2728 def mro(self): # real signature unknown; restored from __doc__ 2729 """ 2730 mro() -> list 2731 return a type‘s method resolution order 2732 """ 2733 return [] 2734 2735 def __call__(self, *more): # real signature unknown; restored from __doc__ 2736 """ x.__call__(...) <==> x(...) """ 2737 pass 2738 2739 def __delattr__(self, name): # real signature unknown; restored from __doc__ 2740 """ x.__delattr__(‘name‘) <==> del x.name """ 2741 pass 2742 2743 def __eq__(self, y): # real signature unknown; restored from __doc__ 2744 """ x.__eq__(y) <==> x==y """ 2745 pass 2746 2747 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 2748 """ x.__getattribute__(‘name‘) <==> x.name """ 2749 pass 2750 2751 def __ge__(self, y): # real signature unknown; restored from __doc__ 2752 """ x.__ge__(y) <==> x>=y """ 2753 pass 2754 2755 def __gt__(self, y): # real signature unknown; restored from __doc__ 2756 """ x.__gt__(y) <==> x>y """ 2757 pass 2758 2759 def __hash__(self): # real signature unknown; restored from __doc__ 2760 """ x.__hash__() <==> hash(x) """ 2761 pass 2762 2763 def __init__(cls, what, bases=None, dict=None): # known special case of type.__init__ 2764 """ 2765 type(object) -> the object‘s type 2766 type(name, bases, dict) -> a new type 2767 # (copied from class doc) 2768 """ 2769 pass 2770 2771 def __instancecheck__(self): # real signature unknown; restored from __doc__ 2772 """ 2773 __instancecheck__() -> bool 2774 check if an object is an instance 2775 """ 2776 return False 2777 2778 def __le__(self, y): # real signature unknown; restored from __doc__ 2779 """ x.__le__(y) <==> x<=y """ 2780 pass 2781 2782 def __lt__(self, y): # real signature unknown; restored from __doc__ 2783 """ x.__lt__(y) <==> x<y """ 2784 pass 2785 2786 @staticmethod # known case of __new__ 2787 def __new__(S, *more): # real signature unknown; restored from __doc__ 2788 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 2789 pass 2790 2791 def __ne__(self, y): # real signature unknown; restored from __doc__ 2792 """ x.__ne__(y) <==> x!=y """ 2793 pass 2794 2795 def __repr__(self): # real signature unknown; restored from __doc__ 2796 """ x.__repr__() <==> repr(x) """ 2797 pass 2798 2799 def __setattr__(self, name, value): # real signature unknown; restored from __doc__ 2800 """ x.__setattr__(‘name‘, value) <==> x.name = value """ 2801 pass 2802 2803 def __subclasscheck__(self): # real signature unknown; restored from __doc__ 2804 """ 2805 __subclasscheck__() -> bool 2806 check if a class is a subclass 2807 """ 2808 return False 2809 2810 def __subclasses__(self): # real signature unknown; restored from __doc__ 2811 """ __subclasses__() -> list of immediate subclasses """ 2812 return [] 2813 2814 __abstractmethods__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 2815 2816 2817 __bases__ = ( 2818 object, 2819 ) 2820 __base__ = object 2821 __basicsize__ = 436 2822 __dictoffset__ = 132 2823 __dict__ = None # (!) real value is ‘‘ 2824 __flags__ = -2146544149 2825 __itemsize__ = 20 2826 __mro__ = ( 2827 None, # (!) forward: type, real value is ‘‘ 2828 object, 2829 ) 2830 __name__ = ‘type‘ 2831 __weakrefoffset__ = 184 2832 2833 2834 class unicode(basestring): 2835 """ 2836 unicode(object=‘‘) -> unicode object 2837 unicode(string[, encoding[, errors]]) -> unicode object 2838 2839 Create a new Unicode object from the given encoded string. 2840 encoding defaults to the current default string encoding. 2841 errors can be ‘strict‘, ‘replace‘ or ‘ignore‘ and defaults to ‘strict‘. 2842 """ 2843 def capitalize(self): # real signature unknown; restored from __doc__ 2844 """ 2845 S.capitalize() -> unicode 2846 2847 Return a capitalized version of S, i.e. make the first character 2848 have upper case and the rest lower case. 2849 """ 2850 return u"" 2851 2852 def center(self, width, fillchar=None): # real signature unknown; restored from __doc__ 2853 """ 2854 S.center(width[, fillchar]) -> unicode 2855 2856 Return S centered in a Unicode string of length width. Padding is 2857 done using the specified fill character (default is a space) 2858 """ 2859 return u"" 2860 2861 def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 2862 """ 2863 S.count(sub[, start[, end]]) -> int 2864 2865 Return the number of non-overlapping occurrences of substring sub in 2866 Unicode string S[start:end]. Optional arguments start and end are 2867 interpreted as in slice notation. 2868 """ 2869 return 0 2870 2871 def decode(self, encoding=None, errors=None): # real signature unknown; restored from __doc__ 2872 """ 2873 S.decode([encoding[,errors]]) -> string or unicode 2874 2875 Decodes S using the codec registered for encoding. encoding defaults 2876 to the default encoding. errors may be given to set a different error 2877 handling scheme. Default is ‘strict‘ meaning that encoding errors raise 2878 a UnicodeDecodeError. Other possible values are ‘ignore‘ and ‘replace‘ 2879 as well as any other name registered with codecs.register_error that is 2880 able to handle UnicodeDecodeErrors. 2881 """ 2882 return "" 2883 2884 def encode(self, encoding=None, errors=None): # real signature unknown; restored from __doc__ 2885 """ 2886 S.encode([encoding[,errors]]) -> string or unicode 2887 2888 Encodes S using the codec registered for encoding. encoding defaults 2889 to the default encoding. errors may be given to set a different error 2890 handling scheme. Default is ‘strict‘ meaning that encoding errors raise 2891 a UnicodeEncodeError. Other possible values are ‘ignore‘, ‘replace‘ and 2892 ‘xmlcharrefreplace‘ as well as any other name registered with 2893 codecs.register_error that can handle UnicodeEncodeErrors. 2894 """ 2895 return "" 2896 2897 def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__ 2898 """ 2899 S.endswith(suffix[, start[, end]]) -> bool 2900 2901 Return True if S ends with the specified suffix, False otherwise. 2902 With optional start, test S beginning at that position. 2903 With optional end, stop comparing S at that position. 2904 suffix can also be a tuple of strings to try. 2905 """ 2906 return False 2907 2908 def expandtabs(self, tabsize=None): # real signature unknown; restored from __doc__ 2909 """ 2910 S.expandtabs([tabsize]) -> unicode 2911 2912 Return a copy of S where all tab characters are expanded using spaces. 2913 If tabsize is not given, a tab size of 8 characters is assumed. 2914 """ 2915 return u"" 2916 2917 def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 2918 """ 2919 S.find(sub [,start [,end]]) -> int 2920 2921 Return the lowest index in S where substring sub is found, 2922 such that sub is contained within S[start:end]. Optional 2923 arguments start and end are interpreted as in slice notation. 2924 2925 Return -1 on failure. 2926 """ 2927 return 0 2928 2929 def format(*args, **kwargs): # known special case of unicode.format 2930 """ 2931 S.format(*args, **kwargs) -> unicode 2932 2933 Return a formatted version of S, using substitutions from args and kwargs. 2934 The substitutions are identified by braces (‘{‘ and ‘}‘). 2935 """ 2936 pass 2937 2938 def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 2939 """ 2940 S.index(sub [,start [,end]]) -> int 2941 2942 Like S.find() but raise ValueError when the substring is not found. 2943 """ 2944 return 0 2945 2946 def isalnum(self): # real signature unknown; restored from __doc__ 2947 """ 2948 S.isalnum() -> bool 2949 2950 Return True if all characters in S are alphanumeric 2951 and there is at least one character in S, False otherwise. 2952 """ 2953 return False 2954 2955 def isalpha(self): # real signature unknown; restored from __doc__ 2956 """ 2957 S.isalpha() -> bool 2958 2959 Return True if all characters in S are alphabetic 2960 and there is at least one character in S, False otherwise. 2961 """ 2962 return False 2963 2964 def isdecimal(self): # real signature unknown; restored from __doc__ 2965 """ 2966 S.isdecimal() -> bool 2967 2968 Return True if there are only decimal characters in S, 2969 False otherwise. 2970 """ 2971 return False 2972 2973 def isdigit(self): # real signature unknown; restored from __doc__ 2974 """ 2975 S.isdigit() -> bool 2976 2977 Return True if all characters in S are digits 2978 and there is at least one character in S, False otherwise. 2979 """ 2980 return False 2981 2982 def islower(self): # real signature unknown; restored from __doc__ 2983 """ 2984 S.islower() -> bool 2985 2986 Return True if all cased characters in S are lowercase and there is 2987 at least one cased character in S, False otherwise. 2988 """ 2989 return False 2990 2991 def isnumeric(self): # real signature unknown; restored from __doc__ 2992 """ 2993 S.isnumeric() -> bool 2994 2995 Return True if there are only numeric characters in S, 2996 False otherwise. 2997 """ 2998 return False 2999 3000 def isspace(self): # real signature unknown; restored from __doc__ 3001 """ 3002 S.isspace() -> bool 3003 3004 Return True if all characters in S are whitespace 3005 and there is at least one character in S, False otherwise. 3006 """ 3007 return False 3008 3009 def istitle(self): # real signature unknown; restored from __doc__ 3010 """ 3011 S.istitle() -> bool 3012 3013 Return True if S is a titlecased string and there is at least one 3014 character in S, i.e. upper- and titlecase characters may only 3015 follow uncased characters and lowercase characters only cased ones. 3016 Return False otherwise. 3017 """ 3018 return False 3019 3020 def isupper(self): # real signature unknown; restored from __doc__ 3021 """ 3022 S.isupper() -> bool 3023 3024 Return True if all cased characters in S are uppercase and there is 3025 at least one cased character in S, False otherwise. 3026 """ 3027 return False 3028 3029 def join(self, iterable): # real signature unknown; restored from __doc__ 3030 """ 3031 S.join(iterable) -> unicode 3032 3033 Return a string which is the concatenation of the strings in the 3034 iterable. The separator between elements is S. 3035 """ 3036 return u"" 3037 3038 def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__ 3039 """ 3040 S.ljust(width[, fillchar]) -> int 3041 3042 Return S left-justified in a Unicode string of length width. Padding is 3043 done using the specified fill character (default is a space). 3044 """ 3045 return 0 3046 3047 def lower(self): # real signature unknown; restored from __doc__ 3048 """ 3049 S.lower() -> unicode 3050 3051 Return a copy of the string S converted to lowercase. 3052 """ 3053 return u"" 3054 3055 def lstrip(self, chars=None): # real signature unknown; restored from __doc__ 3056 """ 3057 S.lstrip([chars]) -> unicode 3058 3059 Return a copy of the string S with leading whitespace removed. 3060 If chars is given and not None, remove characters in chars instead. 3061 If chars is a str, it will be converted to unicode before stripping 3062 """ 3063 return u"" 3064 3065 def partition(self, sep): # real signature unknown; restored from __doc__ 3066 """ 3067 S.partition(sep) -> (head, sep, tail) 3068 3069 Search for the separator sep in S, and return the part before it, 3070 the separator itself, and the part after it. If the separator is not 3071 found, return S and two empty strings. 3072 """ 3073 pass 3074 3075 def replace(self, old, new, count=None): # real signature unknown; restored from __doc__ 3076 """ 3077 S.replace(old, new[, count]) -> unicode 3078 3079 Return a copy of S with all occurrences of substring 3080 old replaced by new. If the optional argument count is 3081 given, only the first count occurrences are replaced. 3082 """ 3083 return u"" 3084 3085 def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 3086 """ 3087 S.rfind(sub [,start [,end]]) -> int 3088 3089 Return the highest index in S where substring sub is found, 3090 such that sub is contained within S[start:end]. Optional 3091 arguments start and end are interpreted as in slice notation. 3092 3093 Return -1 on failure. 3094 """ 3095 return 0 3096 3097 def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 3098 """ 3099 S.rindex(sub [,start [,end]]) -> int 3100 3101 Like S.rfind() but raise ValueError when the substring is not found. 3102 """ 3103 return 0 3104 3105 def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__ 3106 """ 3107 S.rjust(width[, fillchar]) -> unicode 3108 3109 Return S right-justified in a Unicode string of length width. Padding is 3110 done using the specified fill character (default is a space). 3111 """ 3112 return u"" 3113 3114 def rpartition(self, sep): # real signature unknown; restored from __doc__ 3115 """ 3116 S.rpartition(sep) -> (head, sep, tail) 3117 3118 Search for the separator sep in S, starting at the end of S, and return 3119 the part before it, the separator itself, and the part after it. If the 3120 separator is not found, return two empty strings and S. 3121 """ 3122 pass 3123 3124 def rsplit(self, sep=None, maxsplit=None): # real signature unknown; restored from __doc__ 3125 """ 3126 S.rsplit([sep [,maxsplit]]) -> list of strings 3127 3128 Return a list of the words in S, using sep as the 3129 delimiter string, starting at the end of the string and 3130 working to the front. If maxsplit is given, at most maxsplit 3131 splits are done. If sep is not specified, any whitespace string 3132 is a separator. 3133 """ 3134 return [] 3135 3136 def rstrip(self, chars=None): # real signature unknown; restored from __doc__ 3137 """ 3138 S.rstrip([chars]) -> unicode 3139 3140 Return a copy of the string S with trailing whitespace removed. 3141 If chars is given and not None, remove characters in chars instead. 3142 If chars is a str, it will be converted to unicode before stripping 3143 """ 3144 return u"" 3145 3146 def split(self, sep=None, maxsplit=None): # real signature unknown; restored from __doc__ 3147 """ 3148 S.split([sep [,maxsplit]]) -> list of strings 3149 3150 Return a list of the words in S, using sep as the 3151 delimiter string. If maxsplit is given, at most maxsplit 3152 splits are done. If sep is not specified or is None, any 3153 whitespace string is a separator and empty strings are 3154 removed from the result. 3155 """ 3156 return [] 3157 3158 def splitlines(self, keepends=False): # real signature unknown; restored from __doc__ 3159 """ 3160 S.splitlines(keepends=False) -> list of strings 3161 3162 Return a list of the lines in S, breaking at line boundaries. 3163 Line breaks are not included in the resulting list unless keepends 3164 is given and true. 3165 """ 3166 return [] 3167 3168 def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__ 3169 """ 3170 S.startswith(prefix[, start[, end]]) -> bool 3171 3172 Return True if S starts with the specified prefix, False otherwise. 3173 With optional start, test S beginning at that position. 3174 With optional end, stop comparing S at that position. 3175 prefix can also be a tuple of strings to try. 3176 """ 3177 return False 3178 3179 def strip(self, chars=None): # real signature unknown; restored from __doc__ 3180 """ 3181 S.strip([chars]) -> unicode 3182 3183 Return a copy of the string S with leading and trailing 3184 whitespace removed. 3185 If chars is given and not None, remove characters in chars instead. 3186 If chars is a str, it will be converted to unicode before stripping 3187 """ 3188 return u"" 3189 3190 def swapcase(self): # real signature unknown; restored from __doc__ 3191 """ 3192 S.swapcase() -> unicode 3193 3194 Return a copy of S with uppercase characters converted to lowercase 3195 and vice versa. 3196 """ 3197 return u"" 3198 3199 def title(self): # real signature unknown; restored from __doc__ 3200 """ 3201 S.title() -> unicode 3202 3203 Return a titlecased version of S, i.e. words start with title case 3204 characters, all remaining cased characters have lower case. 3205 """ 3206 return u"" 3207 3208 def translate(self, table): # real signature unknown; restored from __doc__ 3209 """ 3210 S.translate(table) -> unicode 3211 3212 Return a copy of the string S, where all characters have been mapped 3213 through the given translation table, which must be a mapping of 3214 Unicode ordinals to Unicode ordinals, Unicode strings or None. 3215 Unmapped characters are left untouched. Characters mapped to None 3216 are deleted. 3217 """ 3218 return u"" 3219 3220 def upper(self): # real signature unknown; restored from __doc__ 3221 """ 3222 S.upper() -> unicode 3223 3224 Return a copy of S converted to uppercase. 3225 """ 3226 return u"" 3227 3228 def zfill(self, width): # real signature unknown; restored from __doc__ 3229 """ 3230 S.zfill(width) -> unicode 3231 3232 Pad a numeric string S with zeros on the left, to fill a field 3233 of the specified width. The string S is never truncated. 3234 """ 3235 return u"" 3236 3237 def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown 3238 pass 3239 3240 def _formatter_parser(self, *args, **kwargs): # real signature unknown 3241 pass 3242 3243 def __add__(self, y): # real signature unknown; restored from __doc__ 3244 """ x.__add__(y) <==> x+y """ 3245 pass 3246 3247 def __contains__(self, y): # real signature unknown; restored from __doc__ 3248 """ x.__contains__(y) <==> y in x """ 3249 pass 3250 3251 def __eq__(self, y): # real signature unknown; restored from __doc__ 3252 """ x.__eq__(y) <==> x==y """ 3253 pass 3254 3255 def __format__(self, format_spec): # real signature unknown; restored from __doc__ 3256 """ 3257 S.__format__(format_spec) -> unicode 3258 3259 Return a formatted version of S as described by format_spec. 3260 """ 3261 return u"" 3262 3263 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 3264 """ x.__getattribute__(‘name‘) <==> x.name """ 3265 pass 3266 3267 def __getitem__(self, y): # real signature unknown; restored from __doc__ 3268 """ x.__getitem__(y) <==> x[y] """ 3269 pass 3270 3271 def __getnewargs__(self, *args, **kwargs): # real signature unknown 3272 pass 3273 3274 def __getslice__(self, i, j): # real signature unknown; restored from __doc__ 3275 """ 3276 x.__getslice__(i, j) <==> x[i:j] 3277 3278 Use of negative indices is not supported. 3279 """ 3280 pass 3281 3282 def __ge__(self, y): # real signature unknown; restored from __doc__ 3283 """ x.__ge__(y) <==> x>=y """ 3284 pass 3285 3286 def __gt__(self, y): # real signature unknown; restored from __doc__ 3287 """ x.__gt__(y) <==> x>y """ 3288 pass 3289 3290 def __hash__(self): # real signature unknown; restored from __doc__ 3291 """ x.__hash__() <==> hash(x) """ 3292 pass 3293 3294 def __init__(self, string=u‘‘, encoding=None, errors=‘strict‘): # known special case of unicode.__init__ 3295 """ 3296 unicode(object=‘‘) -> unicode object 3297 unicode(string[, encoding[, errors]]) -> unicode object 3298 3299 Create a new Unicode object from the given encoded string. 3300 encoding defaults to the current default string encoding. 3301 errors can be ‘strict‘, ‘replace‘ or ‘ignore‘ and defaults to ‘strict‘. 3302 # (copied from class doc) 3303 """ 3304 pass 3305 3306 def __len__(self): # real signature unknown; restored from __doc__ 3307 """ x.__len__() <==> len(x) """ 3308 pass 3309 3310 def __le__(self, y): # real signature unknown; restored from __doc__ 3311 """ x.__le__(y) <==> x<=y """ 3312 pass 3313 3314 def __lt__(self, y): # real signature unknown; restored from __doc__ 3315 """ x.__lt__(y) <==> x<y """ 3316 pass 3317 3318 def __mod__(self, y): # real signature unknown; restored from __doc__ 3319 """ x.__mod__(y) <==> x%y """ 3320 pass 3321 3322 def __mul__(self, n): # real signature unknown; restored from __doc__ 3323 """ x.__mul__(n) <==> x*n """ 3324 pass 3325 3326 @staticmethod # known case of __new__ 3327 def __new__(S, *more): # real signature unknown; restored from __doc__ 3328 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 3329 pass 3330 3331 def __ne__(self, y): # real signature unknown; restored from __doc__ 3332 """ x.__ne__(y) <==> x!=y """ 3333 pass 3334 3335 def __repr__(self): # real signature unknown; restored from __doc__ 3336 """ x.__repr__() <==> repr(x) """ 3337 pass 3338 3339 def __rmod__(self, y): # real signature unknown; restored from __doc__ 3340 """ x.__rmod__(y) <==> y%x """ 3341 pass 3342 3343 def __rmul__(self, n): # real signature unknown; restored from __doc__ 3344 """ x.__rmul__(n) <==> n*x """ 3345 pass 3346 3347 def __sizeof__(self): # real signature unknown; restored from __doc__ 3348 """ S.__sizeof__() -> size of S in memory, in bytes """ 3349 pass 3350 3351 def __str__(self): # real signature unknown; restored from __doc__ 3352 """ x.__str__() <==> str(x) """ 3353 pass 3354 3355 3356 class xrange(object): 3357 """ 3358 xrange(stop) -> xrange object 3359 xrange(start, stop[, step]) -> xrange object 3360 3361 Like range(), but instead of returning a list, returns an object that 3362 generates the numbers in the range on demand. For looping, this is 3363 slightly faster than range() and more memory efficient. 3364 """ 3365 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 3366 """ x.__getattribute__(‘name‘) <==> x.name """ 3367 pass 3368 3369 def __getitem__(self, y): # real signature unknown; restored from __doc__ 3370 """ x.__getitem__(y) <==> x[y] """ 3371 pass 3372 3373 def __init__(self, stop): # real signature unknown; restored from __doc__ 3374 pass 3375 3376 def __iter__(self): # real signature unknown; restored from __doc__ 3377 """ x.__iter__() <==> iter(x) """ 3378 pass 3379 3380 def __len__(self): # real signature unknown; restored from __doc__ 3381 """ x.__len__() <==> len(x) """ 3382 pass 3383 3384 @staticmethod # known case of __new__ 3385 def __new__(S, *more): # real signature unknown; restored from __doc__ 3386 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 3387 pass 3388 3389 def __reduce__(self, *args, **kwargs): # real signature unknown 3390 pass 3391 3392 def __repr__(self): # real signature unknown; restored from __doc__ 3393 """ x.__repr__() <==> repr(x) """ 3394 pass 3395 3396 def __reversed__(self, *args, **kwargs): # real signature unknown 3397 """ Returns a reverse iterator. """ 3398 pass 3399 3400 3401 # variables with complex values 3402 3403 Ellipsis = None # (!) real value is ‘‘ 3404 3405 NotImplemented = None # (!) real value is ‘‘
常用方法以具体实例给出
标签：
原文地址：http://www.cnblogs.com/Dicky-Zhang/p/5901802.html
