概述
自己通过百度翻译，整理的python数据类型
bool
class bool(int):
def __init__(self, x):
"""
bool(x) -> bool
当参数x为True时返回True，否则返回False。
内置的True和False是bool类的仅有两个实例。
类bool是int类的子类，不能被子类化。
>>> bool(True)
True
"""
pass
@staticmethod
def __new__(*args, **kwargs):
"""
创建并返回实例化对象
"""
pass
def __repr__(self, *args, **kwargs):
"""
返回字符串。repr(self)
"""
pass
def __and__(self, *args, **kwargs):
"""
按位与。self&value.
>>> True.__and__(True)
True
>>> True.__and__(False)
False
"""
pass
def __rand__(self, *args, **kwargs):
"""
按位与。value&self
>>> True.__rand__(False)
False
>>> True.__rand__(True)
True
"""
pass
def __or__(self, *args, **kwargs):
"""
按位或。self|value.
>>> True.__or__(False)
True
>>> False.__or__(False)
False
"""
pass
def __ror__(self, *args, **kwargs):
"""
按位或。value|self.
>>> True.__ror__(False)
True
"""
pass
def __xor__(self, *args, **kwargs):
"""
异或。self^value
相同为True,不同为False
>>> True.__xor__(False)
True
"""
pass
def __rxor__(self, *args, **kwargs):
"""
异或。value^self
相同为True,不同为False
>>> True.__rxor__(False)
True
"""
pass
dict
class dict(object):
def __init__(self, seq=None, **kwargs):
"""
dict() -> 新空字典
dict(mapping) -> 从映射对象的(key, value)初始化新字典
dict(iterable) -> 新字典初始化为 via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> 使用关键字参数列表中的name=value初始化新字典。
For example: dict(one=1, two=2)
>>> dict()
{}
>>> dict({'a': 1, 'b': 2})
{'a': 1, 'b': 2}
>>> dict(a=1, b=2)
{'a': 1, 'b': 2}
"""
pass
@staticmethod
def __new__(*args, **kwargs):
"""
创建并返回实例化对象
"""
pass
def __iter__(self, *args, **kwargs):
"""
迭代器协议。iter(self)
"""
pass
def __repr__(self, *args, **kwargs):
"""
返回字符串。repr(self)
"""
pass
def __class_getitem__(self, *args, **kwargs):
"""
//TODO 干什么用的？
See PEP 585
"""
pass
def __getattribute__(self, *args, **kwargs):
"""
获取对象方法名。getattr(self, name).
"""
pass
def __sizeof__(self):
"""
返回对象在内存中的大小（以字节为单位）
>>> {}.__sizeof__()
48
>>> {'a': 1}.__sizeof__()
216
>>> {'a': 1, 'b': 2}.__sizeof__()
216
"""
pass
def __reversed__(self, *args, **kwargs):
"""
返回dict键上的反向迭代器。
"""
pass
__hash__ = None
@staticmethod
def fromkeys(*args, **kwargs):
"""
使用iterable中的键和设置为value的值创建一个新字典。
>>> dict.fromkeys([1, 2, 3], 'a')
{1: 'a', 2: 'a', 3: 'a'}
"""
pass
def items(self):
"""
D.items() -> 提供D项视图的集合状对象
>>> {'a': 1, 'b': 2}.items()
dict_items([('a', 1), ('b', 2)])
"""
pass
def keys(self):
"""
D.keys() -> 在D键上提供视图的类似集合的对象
>>> {'a': 1, 'b': 2}.keys()
dict_keys(['a', 'b'])
"""
pass
def values(self):
"""
D.values() -> 提供D值视图的对象
>>> {'a': 1, 'b': 2}.values()
dict_values([1, 2])
"""
pass
def clear(self):
"""
清空
>>> d = {'a': 1, 'b': 2}
>>> d.clear()
{}
"""
pass
def copy(self):
"""
浅复制
>>> {'a': 1, 'b': 2}.copy()
{'a': 1, 'b': 2}
"""
pass
def get(self, *args, **kwargs):
"""
如果键在字典中，则返回键的值，否则为默认值。
>>> {'a': 1, 'b': 2}.get('a')
1
"""
pass
def pop(self, k, d=None):
"""
D.pop(k[,d]) -> v,删除指定的键并返回相应的值。
若找不到键，则返回默认值（若给定），否则将引发KeyError
>>> {'a': 1, 'b': 2}.pop('a')
1
>>> {'a': 1, 'b': 2}.pop('c', 3)
3
"""
pass
def popitem(self, *args, **kwargs):
"""
移除(key, value)对并将其作为2元组返回。
按后进先出的顺序返回。
如果dict为空，则引发KeyError。
>>> {'a': 1, 'b': 2}.popitem()
('b', 2)
"""
pass
def setdefault(self, *args, **kwargs):
"""
如果关键字不在字典中，则插入默认值为的关键字。
如果键在字典中，则返回键的值，否则为默认值。
>>> {'a': 1, 'b': 2}.setdefault('a', 3)
1
>>> {'a': 1, 'b': 2}.setdefault('c', 3)
{'a': 1, 'b': 2, 'c': 3}
"""
pass
def update(self, E=None, **F):
"""
D.update([E, ]**F) -> None. 从dict/iterable E和F更新D。
如果E存在并且有一个.keys（）方法，则对E中的k执行：D[k]=E[k]
如果E存在并且缺少.keys（）方法，则会：对于k，E中的v:D[k]=v
在这两种情况下，后面都是：对于F中的k:D[k]=F[k]
>>> d = {'a': 1, 'b': 2}
>>> d.update({'a': 3, 'b': 4})
{'a': 3, 'b': 4}
"""
pass
def __eq__(self, *args, **kwargs):
"""
相等运算。self==value.
>>> {'a': 1, 'b': 2}.__eq__({'a': 1, 'b': 2})
True
"""
pass
def __ne__(self, *args, **kwargs):
"""
不相等。self!=value
按ASCII表从前往后对比
>>> {'a': 1, 'b': 2}.__ne__({'a': 1})
True
"""
pass
def __ge__(self, *args, **kwargs):
"""
大于等于。self>=value.
字典不能直接比较
要将键提取出来进行比较
>>> {'a': 1, 'b': 2}.keys().__ge__(set('ab'))
True
>>> {'a': 1, 'b': 2}.keys().__ge__(set('abc'))
False
"""
pass
def __gt__(self, *args, **kwargs):
"""
大于。self>value.
字典不能直接比较
要将键提取出来进行比较
>>> {'a': 1, 'b': 2}.keys().__gt__(set('ab'))
False
>>> {'a': 1, 'b': 2}.keys().__gt__(set('a'))
True
"""
pass
def __le__(self, *args, **kwargs):
"""
小于等于。self<=value.
字典不能直接比较
要将键提取出来进行比较
>>> {'a': 1, 'b': 2}.keys().__le__(set('ab'))
True
>>> {'a': 1, 'b': 2}.keys().__le__(set('a'))
False
"""
pass
def __lt__(self, *args, **kwargs):
"""
小于。self<value.
字典不能直接比较
要将键提取出来进行比较
>>> {'a': 1, 'b': 2}.keys().__lt__(set('ab'))
False
>>> {'a': 1, 'b': 2}.keys().__lt__(set('abc'))
True
"""
pass
def __ror__(self, *args, **kwargs):
"""
或运算。value|self.
要将键提取出来进行运算
>>> {'a': 1, 'b': 2}.keys().__ror__(set('ac'))
{'a', 'b', 'c'}
"""
pass
def __or__(self, *args, **kwargs):
"""
或运算。value|self.
要将键提取出来进行运算
>>> {'a': 1, 'b': 2}.keys().__or__(set('ac'))
{'a', 'b', 'c'}
"""
pass
def __ior__(self, *args, **kwargs):
"""
//TODO 目前不知道怎么用
或运算。value|self.
"""
pass
def __setitem__(self, *args, **kwargs):
"""
通过建设定值
>>> d = {'a': 1, 'b': 2}
>>> d.__setitem__('a', 2)
{'a': 2, 'b': 2}
>>> d = {'a': 1, 'b': 2}
>>> d.__setitem__('c', 2)
{'a': 1, 'b': 2, 'c': 2}
"""
pass
def __delitem__(self, *args, **kwargs):
"""
通过键删除
>>> d = {'a': 1, 'b': 2}
>>> d.__delitem__('a')
{'b': 2}
"""
pass
def __getitem__(self, y):
"""
通过键获取值
>>> {'a': 1, 'b': 2}.__getitem__('a')
1
"""
pass
def __len__(self, *args, **kwargs):
"""
字典长度。len(self).
>>> {'a': 1, 'b': 2}.__len__()
2
"""
pass
def __contains__(self, *args, **kwargs):
"""
如果字典具有指定的键，则为True，否则为False。
>>> {'a': 1, 'b': 2}.__contains__('a')
True
"""
pass
float
class float(object):
imag = property(lambda self: object(), lambda self, v: None, lambda self: None)
"""
复数的虚部
>>> (2.2).imag
0.0
>>> (2.2+2.3j).imag
2.3
"""
real = property(lambda self: object(), lambda self, v: None, lambda self: None)
"""
复数的实部
>>> (2+2j).real
2.0
>>> 2.2.real
2.2
"""
def __init__(self, *args, **kwargs):
"""
将一个字符串或者整数转换为浮点数
>>> float('2')
2.0
>>> float(2)
2.0
"""
pass
@staticmethod
def __new__(*args, **kwargs):
"""
创建并返回实例化对象
"""
pass
def __repr__(self, *args, **kwargs):
"""
返回字符串。repr(self)
"""
pass
def __format__(self, *args, **kwargs):
"""
格式化输出,用空格填充
"""
pass
def __getattribute__(self, *args, **kwargs):
"""
获取属性。getattr(self, name)
"""
pass
def __getnewargs__(self, *args, **kwargs):
"""
序列化为元组
"""
pass
def __hash__(self, *args, **kwargs):
"""
哈希值。hash(self)
"""
pass
def __pos__(self, *args, **kwargs):
"""
//TODO 目前不知道有什么用
在原数的基础上加上＋
+self
>>> -1.1.__pos__()
-1.1
>>> 1.1.__pos__()
1.1
"""
pass
def __set_format__(self, *args, **kwargs):
"""
//TODO 目前尚不明白怎么用
您可能不想使用此功能。
typestr/字符串类型
必须为“double”或“float”。
fmt
必须是“unknown”、“IEEE，big-endian”或“IEEE，little-endian”中的一个，
此外，如果它看起来与底层C现实相匹配，则只能是后两个中的一个。
它主要用于Python的测试套件中。
重写C级浮点类型的自动确定。
这会影响浮动与二进制字符串之间的转换方式。
"""
pass
def __getformat__(self, *args, **kwargs):
"""
//TODO 目前尚不知道不知道怎么用
您可能不想使用此功能。
typestr
必须为“double”或“float”。
它主要用于Python的测试套件中。
此函数返回“unknown”、“IEEE,big-endian”或“IEEE,little-endian”中
最能描述由typestr命名的C类型使用的浮点数格式的一个。
"""
pass
def as_integer_ratio(self):
"""
最小整数比
若传入整数,返回格式为(self,1)
若传入浮点数,格式为(分子,分母)
注意由于计算机中以2进制存储,所以不是所有的小数都可以精确表达
2的次数 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10
值 0.5 0.25 0.125 0.0625 0.03125 0.015625 0.0078125 0.00390625 0.001953125 0.0009765625
由上面的部分表格可以看出来,0.1不能精确表达,所以当想返回0.1的整数比时,会返回奇奇怪怪的值
最有由上面表格中的任意组合的小数才能精确表达
当为无穷大时引发 OverflowError错误
当为NaN时引发 ValueError。
>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)
>>> 0.5009765625.as_integer_ratio()
(513, 1024)
>>> 0.1.as_integer_ratio()
(3602879701896397, 36028797018963968)
"""
pass
def conjugate(self, *args, **kwargs):
"""
复共轭
>>> 3.1-9.1j.conjugate()
(3.1+9.1j)
"""
pass
@staticmethod
def fromhex(*args, **kwargs):
"""
从十六进制字符串创建一个浮点数。
p10:表示乘以2的10次幂
p-1074：表示乘以2的-1074次幂
>>> float.fromhex('0x1.ffffp10')
2047.984375
>>> float.fromhex('-0x1p-1074')
-5e-324
"""
pass
def hex(self):
"""
返回浮点数的十六进制表示。
注意：由于大多数小数并不能精确表示,所以会得出很奇怪的数
>>> (-0.1).hex()
'-0x1.999999999999ap-4'
>>> 3.14159.hex()
'0x1.921f9f01b866ep+1'
>>> (0.5).hex()
0x1.0000000000000p-1
"""
pass
def is_integer(self, *args, **kwargs):
"""
如果浮点数是整数，则返回 True。
>>> 5.1.is_integer()
False
>>> 5.0.is_integer()
True
"""
pass
def __add__(self, *args, **kwargs):
"""
求两数和。self+value
>>> 8.2.__add__(9.3)
17.5
"""
pass
def __radd__(self, *args, **kwargs):
"""
两数和。value+self
>>> 2.2.__radd__(3.3)
5.5
"""
pass
def __sub__(self, *args, **kwargs):
"""
减法。self-value.
>>> 2.3.__sub__(2.1)
0.19999999999999973
"""
pass
def __rsub__(self, *args, **kwargs):
"""
减法。value-self.
>>> 1.1.__rsub__(2)
0.8999999999999999
"""
pass
def __mul__(self, *args, **kwargs):
"""
两数相乘。self*value
>>> 2.1.__mul__(3.1)
6.510000000000001
"""
pass
def __rmul__(self, *args, **kwargs):
"""
两数相乘。value*self
>>> 2.1.__mul__(5.1)
10.709999999999999
"""
pass
def __divmod__(self, *args, **kwargs):
"""
两数相除,返回(商,余数)。divmod(self, value)
>>> 5.2.__divmod__(3.1)
(1.0, 2.1)
"""
pass
def __rdivmod__(self, *args, **kwargs):
"""
两数相除,返回(商,余数)。divmod(value,self)
>>> 5.2.__rdivmod__(3.3)
(0.0, 3.3)
"""
pass
def __mod__(self, *args, **kwargs):
"""
取余。self%value
>>> 2.1.__mod__(4.2)
2.1
"""
pass
def __rmod__(self, *args, **kwargs):
"""
取余。value%self.
>>> 2.1.__rmod__(5.3)
1.0999999999999996
"""
pass
def __floordiv__(self, *args, **kwargs):
"""
取商。self//value
>>> 100.1.__floordiv__(9.2)
10.0
"""
pass
def __rfloordiv__(self, *args, **kwargs):
"""
取商。value//self
>>> 3.1.__rfloordiv__(9.2)
2.0
"""
pass
def __truediv__(self, *args, **kwargs):
"""
真除，返回的数据类型为float。self/value.
>>> 2.33.__truediv__(2.2)
1.059090909090909
"""
pass
def __rtruediv__(self, *args, **kwargs):
"""
真除，返回的数据类型为float。value/self.
>>> 2.5.__rtruediv__(4.2)
1.6800000000000002
"""
pass
def __eq__(self, *args, **kwargs):
"""
判断两数是否相等,self==value
>>> 3.2.__eq__(3.2)
True
>>> 2.2.__eq__(3.2)
False
"""
pass
def __ne__(self, *args, **kwargs):
"""
不相等,self>value
>>> 2.2.__ne__(2.2)
False
>>> 2.2.__ne__(3.2)
True
"""
pass
def __gt__(self, *args, **kwargs):
"""
大于,self>value
>>> 1.2.__gt__(1.2)
False
>>> 1.2.__gt__(1.3)
False
>>> 1.2.__gt__(1.1)
True
"""
pass
def __ge__(self, *args, **kwargs):
"""
大于等于,self>=value
>>> 1.1.__ge__(1.1)
True
>>> 1.2.__ge__(1.1)
True
>>> 1.1.__ge__(1.2)
False
"""
pass
def __lt__(self, *args, **kwargs):
"""
小于,self<value
>>> 1.1.__lt__(1.1)
False
>>> 1.2.__lt__(1.1)
False
>>> 1.1.__lt__(1.2)
True
"""
pass
def __le__(self, *args, **kwargs):
"""
小于等于,self<=value
>>> 1.1.__le__(1.1)
True
>>> 1.2.__le__(1.1)
False
>>> 1.1.__le__(1.2)
True
"""
pass
def __pow__(self, *args, **kwargs):
"""
幂运算。pow(self, value, mod)
当传入前两个参数时,返回幂值
当传入三个参数时,返回前两个数对第三个参数的余数
注意：只有三个参数都是整数是才可以使用三个参数的调用
>>> pow(2.2, 3.3)
13.489468760533386
>>> pow(2, 3, 6)
2
"""
pass
def __rpow__(self, *args, **kwargs):
"""
运算。pow(value, self, mod)
当传入前两个参数时,返回幂值
当传入三个参数时,返回前两个数对第三个参数的余数
注意：只有三个参数都是整数是才可以使用三个参数的调用
>>> 2.2.__rpow__(3.3)
13.827086118044146
>>> (2).__rpow__(3,8)
1
"""
pass
def __abs__(self, *args, **kwargs):
"""
绝对值。abs(self)
>>> 8.2.__abs__()
8.2
>>> -8.2.__abs__()
8.2
>>> 0.0.__abs__()
0.0
"""
pass
def __bool__(self, *args, **kwargs):
"""
bool值
0.0的bool值为False
正值bool值为True
负值bool值为-1
>>> -1.1.__bool__()
-1
>>> 1.1.__bool__()
True
>>> 0.0.__bool__()
False
"""
pass
def __neg__(self, *args, **kwargs):
"""
相反数。-self
>>> 2.2.__neg__()
-2.2
>>> -2.2.__neg__()
2.2
"""
pass
def __ceil__(self, *args, **kwargs):
"""
向上取整
>>> 0.0.__ceil__()
0
>>> -1.1.__ceil__()
-1
>>> 1.1.__ceil__()
2
"""
pass
def __floor__(self, *args, **kwargs):
"""
向下取整
>>> (0).__floor__()
0
>>> -1.1.__floor__()
-2
>>> 1.1.__floor__()
1
"""
pass
def __round__(self, *args, **kwargs):
"""
四舍五入。round(self, ndigits)
传入一个参数时,默认向整数转换
传入两个参数时,第二个参数为保留的小数位数
ndigits 参数可以是负数,此时,该运算会作用在十位、百位、千位等上面
当一个值刚好在两个边界的中间的时候,返回离它最近的偶数
>>> 2.3.__round__()
2
>>> 2.3.__round__(1)
2.3
>>> 2.5.__round__()
2
>>> 3.5.__round__()
4
>>> (222).__round__(-1)
220
"""
pass
def __trunc__(self, *args, **kwargs):
"""
截断
>>> 1.1.__trunc__()
1
"""
pass
def __float__(self, *args, **kwargs):
"""
转换为浮点数。float(self)
>>> 3.3.__float__()
3.3
"""
pass
def __int__(self, *args, **kwargs):
"""
转换为整数。int(self)
>>> 1.1.__int__()
1
"""
pass
int
class int(object):
denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)
"""
有理数的分母,约分之后的最小值
>>> (2).denominator
1
"""
numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)
"""
有理数的分子,约分之后的最小值
>>> (2).numerator
2
"""
real = property(lambda self: object(), lambda self, v: None, lambda self: None)
"""
复数的实部
>>> (2+2j).real
2.0
>>> (2).real
2
"""
imag = property(lambda self: object(), lambda self, v: None, lambda self: None)
"""
复数的虚部
>>> (2).imag
0
>>> (2+2j).imag
2.0
"""
def __init__(self, x, base=10):
"""
int([x]) -> integer
int(x, base=10) -> integer
[x]表示可选值.
base表示进制,默认为10进制.
没有给定参数时返回0。
x是一个数字时，返回x.__int__(),当x为浮点数时，向下取整。
x不是数字时,必须是表示整数文本的字符串、字节或字节数组的实例
x中允许包含'+'、'-'号，两边可出现空格。
base取值范围为0和2-36。
base=0表示将任意进制下的的字符串解释为整型文本。
浮点数的字符串形式不能直接转换为整数
>>> int()
0
>>> int(1.11)
1
>>> int('0b100',0)
4
>>> int(' +9 ')
9
"""
pass
@staticmethod
def __new__(*args, **kwargs):
"""
创建并返回实例化对象
"""
pass
def __repr__(self, *args, **kwargs):
"""
返回字符串。repr(self)
"""
pass
def __format__(self, *args, **kwargs):
"""
格式化输出,用空格填充
"""
pass
def __getattribute__(self, *args, **kwargs):
"""
获取属性。getattr(self, name)
"""
pass
def __getnewargs__(self, *args, **kwargs):
"""
序列化为元组
"""
pass
def __hash__(self, *args, **kwargs):
"""
哈希值。hash(self)
"""
pass
def __index__(self, *args, **kwargs):
"""
如果self适合用作列表的索引，则返回self转换为的整数。
"""
pass
def __sizeof__(self, *args, **kwargs):
"""
返回对象在内存中的大小（以字节为单位）
>>> (2).__sizeof__()
28
>>> (110000000000).__sizeof__()
32
>>> (1011111111).__sizeof__()
28
"""
pass
def __pos__(self, *args, **kwargs):
"""
//TODO 目前不知道有什么用
在原数的基础上加上＋
+self
>>> (-1).__pos__()
-1
>>> (1).__pos__()
1
"""
pass
@classmethod
def from_bytes(cls, *args, **kwargs):
"""
返回由给定字节数组表示的整数。
bytes/字节数组
存放要转换的字节数组。
参数必须支持缓冲区协议，或者是生成字节的可迭代的对象。
字节和字节数组是支持缓冲区协议的内置对象的示例。
byteorder/字节序,取值为（'big'或'little'或'sys.byteorder')
用于表示整数的字节顺序。
如果字节顺序为“大端”，则最高有效字节位于字节数组的开头.
如果字节顺序为“小端”，则最高有效字节位于字节数组的末尾.
要请求主机系统的本机字节顺序，请使用'sys.byteorder'作为字节顺序值.
signed/符号,取值为(True或False)
指示是否使用2进制补码表示整数。
>>> int.from_bytes(bytes=b'\xff', byteorder='big', signed=False)
255
"""
pass
def to_bytes(self, *args, **kwargs):
"""
返回表示整数的字节数组。
length
要使用的字节对象的长度。如果整数不能用给定的字节数表示，则会引发溢出错误。
byteorder/字节序,取值为（'big'或'little'或'sys.byteorder')
用于表示整数的字节顺序。
如果字节顺序为“大端”，则最高有效字节位于字节数组的开头.
如果字节顺序为“小端”，则最高有效字节位于字节数组的末尾.
要请求主机系统的本机字节顺序，请使用'sys.byteorder'作为字节顺序值.
signed/符号,取值为(True或False)
确定是否使用2进制补码表示整数。
如果signed值为False，并且给出了一个负整数，则会引发溢出错误。
>>> (2).to_bytes(4, 'big', signed=True)
b'\x00\x00\x00\x02'
>>> (2).to_bytes(4, 'little', signed=True)
b'\x02\x00\x00\x00'
"""
pass
def as_integer_ratio(self):
"""
最小整数比
>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)
"""
pass
def bit_length(self):
"""
用二进制表示所需的位数.
>>> bin(37)
'0b100101'
>>> (37).bit_length()
6
"""
pass
def conjugate(self, *args, **kwargs):
"""
复共轭
>>> 3-9j.conjugate()
(3+9j)
"""
pass
def __add__(self, *args, **kwargs):
"""
求两数和。self+value
>>> (8).__add__(9)
17
"""
pass
def __radd__(self, *args, **kwargs):
"""
两数和。value+self
>>> (2).__radd__(3)
5
"""
pass
def __sub__(self, *args, **kwargs):
"""
减法。self-value.
>>> (1).__sub__(2)
-1
"""
pass
def __rsub__(self, *args, **kwargs):
"""
减法。value-self.
>>> (1).__rsub__(4)
3
"""
pass
def __mul__(self, *args, **kwargs):
"""
两数相乘。self*value
>>> (2).__mul__(3)
6
"""
pass
def __rmul__(self, *args, **kwargs):
"""
两数相乘。value*self
>>> (2).__mul__(5)
10
"""
pass
def __divmod__(self, *args, **kwargs):
"""
两数相除,返回(商,余数)。divmod(self, value)
>>> (5).__divmod__(3)
(1, 2)
"""
pass
def __rdivmod__(self, *args, **kwargs):
"""
两数相除,返回(商,余数)。divmod(value,self)
>>> (5).__rdivmod__(3)
(0, 3)
"""
pass
def __mod__(self, *args, **kwargs):
"""
取余。self%value
>>> (2).__mod__(4)
2
"""
pass
def __rmod__(self, *args, **kwargs):
"""
取余。value%self.
>>> (2).__rmod__(5)
1
"""
pass
def __floordiv__(self, *args, **kwargs):
"""
取商。self//value
>>> (100).__floordiv__(9)
11
"""
pass
def __rfloordiv__(self, *args, **kwargs):
"""
取商。value//self
>>> (3).__rfloordiv__(9)
3
"""
pass
def __truediv__(self, *args, **kwargs):
"""
真除，返回的数据类型为float。self/value.
>>> (4).__truediv__(2)
2.0
"""
pass
def __rtruediv__(self, *args, **kwargs):
"""
真除，返回的数据类型为float。value/self.
>>> (2).__rtruediv__(4)
2.0
"""
pass
def __and__(self, *args, **kwargs):
"""
按位与：同时为1才为1，其他为0。self&value
8： 0 0 0 0 1 0 0 0
7： 0 0 0 0 0 1 1 1
0： 0 0 0 0 0 0 0 0
>>> (8).__and__(7)
0
"""
pass
def __rand__(self, *args, **kwargs):
"""
按位与：同时为1才为1，其他为0。value&self
7： 0 0 0 0 0 1 1 1
8： 0 0 0 0 1 0 0 0
0： 0 0 0 0 0 0 0 0
>>> (8).__rand__(7)
0
"""
pass
def __or__(self, *args, **kwargs):
"""
按位或。self|value
0000 0010 2
0000 0011 3
0000 0011 3
>>> (2).__or__(3)
3
"""
pass
def __ror__(self, *args, **kwargs):
"""
按位或。value|self.
0000 0010 2
0000 0011 3
0000 0011 3
>>> (3).__ror__(2)
3
"""
pass
def __xor__(self, *args, **kwargs):
"""
按位异或操作,相同为0不同为1。self^value.
2与4按位异或得6
0000 0100
0000 0010
0000 0110
>>> (2).__rxor__(2)
0
>>> (4).__rxor__(2)
6
"""
pass
def __rxor__(self, *args, **kwargs):
"""
按位异或操作,相同为0不同为1。value^self.
2与4按位异或得6
0000 0010
0000 0100
0000 0110
>>> (2).__rxor__(2)
0
>>> (2).__rxor__(4)
6
"""
pass
def __lshift__(self, *args, **kwargs):
"""
按位左移。self<<value
将2左移两位
0000 0010 2
0000 1000 8
>>> (2).__lshift__(2)
8
"""
pass
def __rlshift__(self, *args, **kwargs):
"""
按位左移。value<<self
将1左移两位
0000 0001
0000 0100
>>> (2).__rlshift__(1)
4
"""
pass
def __rshift__(self, *args, **kwargs):
"""
右移。self>>value.
将4右移1位
0000 0100
0000 0010
>>> (4).__rshift__(1)
2
"""
pass
def __rrshift__(self, *args, **kwargs):
"""
右移。value>>self.
将4右移1位
0000 0100
0000 0010
>>> (1).__rrshift__(4)
2
"""
pass
def __invert__(self, *args, **kwargs):
"""
按位取反
注意：计算机中整数以补码存放
负数转原码简便计算：如10010110是补码，符号位与最后一个1之间的所有数字按位取反，得11101010
0000 0011 3
1111 1100 是负数,要转为原码 1000 0100 -4
>>> (3).__invert__()
-4
"""
pass
def __gt__(self, *args, **kwargs):
"""
大于,self>value
>>> (1).__gt__(0)
True
>>> (1).__gt__(1)
False
>>> (1).__gt__(2)
False
"""
pass
def __ge__(self, *args, **kwargs):
"""
大于等于,self>=value
>>> (1).__ge__(0)
True
>>> (1).__ge__(1)
True
>>> (1).__ge__(2)
False
"""
pass
def __lt__(self, *args, **kwargs):
"""
小于,self<value
>>> (1).__lt__(0)
False
>>> (1).__lt__(1)
False
>>> (1).__lt__(2)
True
"""
pass
def __le__(self, *args, **kwargs):
"""
小于等于,self<=value
>>> (1).__le__(0)
False
>>> (1).__le__(1)
True
>>> (1).__le__(2)
True
"""
pass
def __eq__(self, *args, **kwargs):
"""
判断两数是否相等,self==value
>>> (3).__eq__(3)
True
>>> (2).__eq__(3)
False
"""
pass
def __ne__(self, *args, **kwargs):
"""
不相等,self!=value
>>> (2).__ne__(2)
False
>>> (2).__ne__(3)
True
"""
pass
def __pow__(self, *args, **kwargs):
"""
幂运算。pow(self, value, mod)
当传入前两个参数时,返回幂值
当传入三个参数时,返回前两个数对第三个参数的余数
>>> pow(2, 3)
8
>>> pow(2, 3, 6)
2
"""
pass
def __rpow__(self, *args, **kwargs):
"""
运算。pow(value, self, mod)
当传入前两个参数时,返回幂值
当传入三个参数时,返回前两个数对第三个参数的余数
>>> (2).__rpow__(3)
9
>>> (2).__rpow__(3,8)
1
"""
pass
def __abs__(self, *args, **kwargs):
"""
绝对值。abs(self)
>>> (8).__abs__()
8
>>> (-8).__abs__()
8
>>> (0).__abs__()
0
"""
pass
def __bool__(self, *args, **kwargs):
"""
bool值
0的bool值为False
其他bool值为True
>>> (-1).__bool__()
True
>>> (1).__bool__()
True
>>> (0).__bool__()
False
"""
pass
def __neg__(self, *args, **kwargs):
"""
相反数。-self
>>> (2).__neg__()
-2
>>> (-2).__neg__()
2
"""
pass
def __ceil__(self, *args, **kwargs):
"""
向上取整
>>> (0).__ceil__()
0
>>> (-1).__ceil__()
-1
>>> (1).__ceil__()
1
"""
pass
def __floor__(self, *args, **kwargs):
"""
向下取整
>>> (0).__floor__()
0
>>> (-1).__floor__()
-1
>>> (1).__floor__()
1
"""
pass
def __round__(self, *args, **kwargs):
"""
四舍五入。round(self, ndigits)
传入一个参数时,默认向整数转换
传入两个参数时,第二个参数为保留的位数
ndigits 参数可以是负数,此时,该运算会作用在十位、百位、千位等上面
>>> (2).__round__()
2
>>> (222).__round__(-1)
220
"""
pass
def __trunc__(self, *args, **kwargs):
"""
截断
>>> (10).__trunc__()
10
"""
pass
def __float__(self, *args, **kwargs):
"""
转换为浮点数。float(self)
>>> (3).__float__()
3.0
"""
pass
def __int__(self, *args, **kwargs):
"""
转换为整数。int(self)
>>> (1).__int__()
1
"""
pass
list
class list(object):
def __init__(self, seq=()):
"""
内置可变序列。
如果没有给出参数，构造函数将创建一个新的空列表。
如果指定，则参数必须是iterable。
>>> list()
[]
>>> list((1, 2, 3))
[1, 2, 3]
"""
pass
@staticmethod
def __new__(*args, **kwargs):
"""
创建并返回实例化对象
"""
pass
def __repr__(self, *args, **kwargs):
"""
返回字符串。repr(self)
"""
pass
def __iter__(self, *args, **kwargs):
"""
迭代器协议。iter(self)
"""
pass
def __getattribute__(self, *args, **kwargs):
"""
获取对象方法名
"""
pass
def __class_getitem__(self, *args, **kwargs):
"""
//TODO 干什么用的？
See PEP 585
"""
pass
def __sizeof__(self, *args, **kwargs):
"""
返回内存中列表的大小（以字节为单位）。
>>> [].__sizeof__()
40
>>> [1].__sizeof__()
48
"""
pass
def __reversed__(self, *args, **kwargs):
"""
返回列表上的反向迭代器。
"""
pass
__hash__ = None
def append(self, *args, **kwargs):
"""
将对象追加到列表的末尾。
>>> [1, 2].append(3)
[1, 2, 3]
"""
pass
def clear(self, *args, **kwargs):
"""
从列表中删除所有项目。
>>> [1, 2].clear()
[]
"""
pass
def copy(self, *args, **kwargs):
"""
返回列表的浅表副本。
>>> [1, 2].copy()
[1, 2]
"""
pass
def count(self, *args, **kwargs):
"""
返回值的出现次数。
>>> [1, 2].count(1)
1
"""
pass
def extend(self, *args, **kwargs):
"""
通过从iterable中添加元素来扩展列表。
>>> [1, 2].extend([3, 4])
[1, 2, 3, 4]
"""
pass
def index(self, *args, **kwargs):
"""
返回值的第一个索引。
使用可选开始，测试从该位置开始。
使用可选结束，停止在该位置比较S。
如果值不存在，则引发ValueError。
>>> [1,2].index(2)
1
>>> [1,2].index(1,0,1)
0
"""
pass
def insert(self, *args, **kwargs):
"""
在索引之前插入对象。
>>> [1, 2].insert(1, 'a')
[1, 'a', 2]
"""
pass
def pop(self, *args, **kwargs):
"""
删除并返回索引处的项目（默认为最后一个）。
如果列表为空或索引超出范围，则引发索引器错误。
>>> [1, 2].pop()
2
>>> [1, 2].pop(0)
1
"""
pass
def remove(self, *args, **kwargs):
"""
删除第一次出现的值。
如果值不存在，则引发ValueError。
>>> [1, 2].remove(1)
[2]
"""
pass
def reverse(self, *args, **kwargs):
"""
反转
>>> [1, 2].reverse()
[2, 1]
"""
pass
def sort(self, *args, **kwargs):
"""
按升序对列表进行排序并返回None。
排序且稳定（即保持两个相等元素的顺序）。
如果给定了键函数，请将其应用于每个列表项一次，并根据它们的函数值对它们进行升序或降序排序。
反向标志可以设置为按降序排序。
>>> [1, 2].sort(reverse=True)
[2, 1]
"""
pass
def __eq__(self, *args, **kwargs):
"""
相等。self==value.
整形比较真实大小,其他的按照ASCII表比较
>>> [1, 2].__eq__([2, 1])
False
>>> [1, 2].__eq__([1, 2])
True
"""
pass
def __ne__(self, *args, **kwargs):
"""
不相等。self!=value.
整形比较真实大小,其他的按照ASCII表比较
>>> [1, 2].__ne__([2, 1])
True
>>> [1, 2].__ne__([1, 2])
False
"""
pass
def __ge__(self, *args, **kwargs):
"""
大于等于。self>=value.
整形比较真实大小,其他的按照ASCII表比较
>>> [1, 2].__ge__([1, 2])
True
>>> [1].__ge__([1, 2])
False
"""
pass
def __gt__(self, *args, **kwargs):
"""
大于。self>value.
整形比较真实大小,其他的按照ASCII表比较
>>> [1, 2].__gt__([1, 2])
False
>>> [2].__gt__([1, 2])
True
"""
pass
def __le__(self, *args, **kwargs):
"""
小于等于。self<=value.
整形比较真实大小,其他的按照ASCII表比较
>>> [1, 2].__le__([1, 2])
True
>>> [1].__le__([1, 2])
True
"""
pass
def __lt__(self, *args, **kwargs):
"""
小于。self<value.
整形比较真实大小,其他的按照ASCII表比较
>>> [1, 2].__lt__([1, 2])
False
>>> [1].__lt__([1, 2])
True
"""
pass
def __delitem__(self, *args, **kwargs):
"""
按给定键删除。self[key]
>>> a = [1,2]
>>> a.__delitem__(0)
[2]
"""
pass
def __getitem__(self, y):
"""
根据键取值。x[y]
>>> [1, 2].__getitem__(0)
1
"""
pass
def __setitem__(self, *args, **kwargs):
"""
通过键设置值。self[key]=value
>>> a = [1, 2]
>>> a.__setitem__(0, 3)
[3, 2]
"""
pass
def __add__(self, *args, **kwargs):
"""
加法。self+value.
>>> [1, 2].__add__([3, 4])
[1, 2, 3, 4]
"""
pass
def __iadd__(self, *args, **kwargs):
"""
加法。self+=value.
>>> a = [1, 2]
>>> a.__iadd__([3])
[1, 2, 3]
"""
pass
def __contains__(self, *args, **kwargs):
"""
包含
>>> [1, 2].__contains__(1)
True
"""
pass
def __imul__(self, *args, **kwargs):
"""
乘法。self*=value.
>>> [1, 2].__imul__(2)
[1, 2, 1, 2]
"""
pass
def __mul__(self, *args, **kwargs):
"""
乘法。self*value.
>>> [1, 2].__mul__(2)
[1, 2, 1, 2]
"""
pass
def __rmul__(self, *args, **kwargs):
"""
乘法。value*self.
>>> [1, 2].__rmul__(2)
[1, 2, 1, 2]
"""
pass
def __len__(self, *args, **kwargs):
"""
列表的长度。len(self).
>>> list.__len__([1, 2])
2
"""
pass
set
class set(object):
def __init__(self, seq=()):
"""
set() -> 新的空集对象
set(iterable) -> 新集合对象
构建独特元素的无序集合。
>>> set()
set()
>>> set([1, 2, 3])
{1, 2, 3}
"""
pass
@staticmethod
def __new__(*args, **kwargs):
"""
创建并返回实例化对象
"""
pass
def __repr__(self, *args, **kwargs):
"""
返回字符串。repr(self)
"""
pass
def __iter__(self, *args, **kwargs):
"""
迭代器协议。iter(self)
"""
pass
def __getattribute__(self, *args, **kwargs):
"""
获取对象方法名。getattr(self, name).
"""
pass
def __class_getitem__(self, *args, **kwargs):
"""
//TODO 干什么用的？
See PEP 585
"""
pass
def __reduce__(self, *args, **kwargs):
"""
返回pickle的状态信息。
"""
pass
def __sizeof__(self):
"""
返回对象在内存中的大小（以字节为单位）
>>> {1}.__sizeof__()
200
>>> {1, 2, 3, 4, 5}.__sizeof__()
456
"""
pass
__hash__ = None
def difference(self, *args, **kwargs):
"""
将两个或多个集合的差值作为新集合返回。
(i.e.此集合中的所有元素，但不包括其他元素。)
>>> {1, 2, 3, 4}.difference({1, 2, 5, 6})
{3, 4}
"""
pass
def difference_update(self, *args, **kwargs):
"""
从此集合中删除另一集合的所有元素。
>>> a = {1, 2, 3, 4}
>>> a.difference_update({1, 2, 5, 6})
{3, 4}
"""
pass
def intersection(self, *args, **kwargs):
"""
将两个集合的交集作为新集合返回。
(i.e. 两个集合中的所有元素。)
>>> {1, 2, 3, 4}.intersection({1, 2, 5, 6})
{1, 2}
"""
pass
def intersection_update(self, *args, **kwargs):
"""
使用集合自身和另一集合的交点更新集合。
>>> a = {1, 2, 3, 4}
>>> a.intersection_update({1, 2, 5, 6})
{1, 2}
"""
pass
def symmetric_difference(self, *args, **kwargs):
"""
将两个集合的对称差作为新集合返回。
(i.e. 恰好位于其中一个集合中的所有元素。)
>>> {1, 2, 3, 4}.symmetric_difference({1, 5, 6})
{2, 3, 4, 5, 6}
"""
pass
def symmetric_difference_update(self, *args, **kwargs):
"""
使用自身和另一个集合的对称差异更新集合。
>>> a = {1, 2, 3, 4}
>>> a.symmetric_difference_update({1, 5, 6})
{2, 3, 4, 5, 6}
"""
pass
def union(self, *args, **kwargs):
"""
将集合的并集作为新集合返回。
(i.e. 任一集合中的所有元素。)
>>> {1, 2, 3, 4}.union({5, 6})
{1, 2, 3, 4, 5, 6}
"""
pass
def update(self, *args, **kwargs):
"""
使用集合自身和其他集合的并集更新集合。
>>> a = {1, 2, 3, 4}
>>> a.update({5, 6})
{1, 2, 3, 4, 5, 6}
"""
pass
def issubset(self, *args, **kwargs):
"""
报告另一个集合是否包含此集合。
>>> {1, 2, 3, 4}.issubset({1, 2, 3, 4, 5})
True
"""
pass
def issuperset(self, *args, **kwargs):
"""
报告此集合是否包含其他集合。
>>> {1, 2, 3, 4}.issuperset({1, 2})
True
"""
pass
def isdisjoint(self, *args, **kwargs):
"""
如果两个集合有空交集，则返回True。
>>> {1, 2, 3, 4}.isdisjoint({5, 6}
True
"""
pass
def add(self, *args, **kwargs):
"""
向集合中添加元素。
如果元素已存在，则此操作无效。
>>> a = set()
>>> a.add(1)
{1}
"""
pass
def clear(self, *args, **kwargs):
"""
从该集中删除所有元素。
>>> b = {1, 2, 3, 4}
>>> b.clear()
set()
"""
pass
def discard(self, *args, **kwargs):
"""
如果元素是成员，则从集合中删除该元素。
如果元素不是成员，则不执行任何操作。
>>> a = {1, 2, 3, 4}
>>> a.discard(1)
{2, 3, 4}
"""
pass
def pop(self, *args, **kwargs):
"""
删除并返回任意集合元素。
如果集合为空，则引发KeyError。
>>> {1, 2, 3, 4}.pop()
1
"""
pass
def remove(self, *args, **kwargs):
"""
从集合中删除一个元素；它必须是一个成员。
如果元素不是成员，则引发KeyError。
>>> {1, 2, 3, 4}.remove(1)
{2, 3, 4}
"""
pass
def copy(self, *args, **kwargs):
"""
返回集合的浅副本。
>>> {1, 2, 3, 4}.copy()
{1, 2, 3, 4}
"""
pass
def __eq__(self, *args, **kwargs):
"""
相等运算。self==value.
>>> {1, 2}.__eq__({1, 2})
True
"""
pass
def __ne__(self, *args, **kwargs):
"""
不相等。self!=value
按ASCII表从前往后对比
>>> {1, 2}.__ne__({1})
True
"""
pass
def __ge__(self, *args, **kwargs):
"""
大于等于。self>=value.
按照ASCII值从前往后比
>>> {1, 2}.__ge__({1, 2})
True
>>> {1, 2}.__ge__({1, 2, 3})
True
"""
pass
def __gt__(self, *args, **kwargs):
"""
大于。self>value.
按照ASCII值从前往后比
>>> {1, 2}.__gt__({1})
True
"""
pass
def __le__(self, *args, **kwargs):
"""
小于等于。self<=value.
按照ASCII值从前往后比
>>> {1, 2}.__le__({1, 2})
True
>>> {1, 2}.__le__({1, 2, 3})
True
"""
pass
def __lt__(self, *args, **kwargs):
"""
小于。self<value.
按照ASCII值从前往后比
>>> {1, 2}.__lt__({1, 2, 3})
True
"""
pass
def __and__(self, *args, **kwargs):
"""
与--交。self&value.
>>> {1, 2, 4}.__and__({1, 2, 3})
{1, 2}
"""
pass
def __iand__(self, *args, **kwargs):
"""
与--交。self&=value.
>>> {1, 2, 4}.__iand__({1, 2, 3})
{1, 2}
"""
pass
def __rand__(self, *args, **kwargs):
"""
与--交。value&self.
>>> {1, 2, 4}.__rand__({1, 2, 3})
{1, 2}
"""
pass
def __sub__(self, *args, **kwargs):
"""
差。self-value.
>>> {1, 2, 4}.__sub__({1, 2, 3})
{4}
"""
pass
def __isub__(self, *args, **kwargs):
"""
差。self-=value.
>>> {1, 2, 4}.__isub__({1, 2, 3})
{4}
"""
pass
def __rsub__(self, *args, **kwargs):
"""
差。value-self.
>>> {1, 2, 4}.__rsub__({1, 2, 3})
{3}
"""
pass
def __or__(self, *args, **kwargs):
"""
或--并。self|value.
>>> {1, 2, 4}.__or__({1, 2, 3})
{1, 2, 3, 4}
"""
pass
def __ior__(self, *args, **kwargs):
"""
或--并。self|=value.
>>> {1, 2, 4}.__ior__({1, 2, 3})
{1, 2, 3, 4}
"""
pass
def __ror__(self, *args, **kwargs):
"""
或--并。value|self.
>>> {1, 2, 4}.__ror__({1, 2, 3})
{1, 2, 3, 4}
"""
pass
def __ixor__(self, *args, **kwargs):
"""
异或--对称差。self^=value.
>>> {1, 2, 4}.__ixor__({1, 2, 3})
{3, 4}
"""
pass
def __rxor__(self, *args, **kwargs):
"""
异或--对称差。value^self.
>>> {1, 2, 4}.__rxor__({1, 2, 3})
{3, 4}
"""
pass
def __xor__(self, *args, **kwargs):
"""
异或--对称差。self^value.
>>> {1, 2, 4}.__xor__({1, 2, 3})
{3, 4}
"""
pass
def __len__(self, *args, **kwargs):
"""
集合的长度。len(self).
>>> {1, 2, 3, 4, 1}.__len__()
4
"""
pass
def __contains__(self, y):
"""
包含。y in x.
>>> {1, 2, 3, 4}.__contains__(1)
True
"""
pass
str
class str(object):
def __init__(self, value='', encoding=None, errors='strict'):
"""
str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str
从给定对象创建新字符串对象。
如果指定了编码或错误级别，则对象必须暴露一个数据缓冲区,该缓冲区将使用给定的编码和错误处理程序进行解码。
否则，返回object.__str__()(如果已定义)或repr(object)。
编码默认为sys.getdefaultencoding()。
错误默认为“strict”。
>>> str('a')
a
"""
pass
@staticmethod
def __new__(*args, **kwargs):
"""
创建并返回实例化对象
"""
pass
def __str__(self, *args, **kwargs):
"""
返回字符串。str(self)
"""
pass
def __repr__(self, *args, **kwargs):
"""
返回字符串。repr(self)
"""
pass
def __iter__(self, *args, **kwargs):
"""
迭代器协议。iter(self)
"""
pass
def __format__(self, *args, **kwargs):
"""
返回字符串的格式化版本，如format_spec所述。
由于format_spec内容较多,所以这里不展开。
"""
pass
def __getattribute__(self, *args, **kwargs):
"""
获取对象方法名。getattr(self, name).
"""
pass
def __getnewargs__(self, *args, **kwargs):
"""
序列化为元组
"""
pass
def __hash__(self, *args, **kwargs):
"""
哈希值。hash(self)
"""
pass
def __sizeof__(self, *args, **kwargs):
"""
返回对象在内存中的大小（以字节为单位）
>>> 'a'.__sizeof__()
50
>>> 'hello'.__sizeof__()
54
"""
pass
def isalnum(self, *args, **kwargs):
"""
如果字符串是字母数字字符串，则返回True，否则返回False。
如果字符串中的所有字符都是字母数字，且字符串中至少有一个字符，则该字符串为字母数字。
>>> str.isalnum('hello')
True
>>> str.isalnum('12345')
True
>>> str.isalnum('hello12345')
True
"""
pass
def isalpha(self, *args, **kwargs):
"""
如果字符串是字母字符串,则返回True,否则返回False。
如果字符串中的所有字符都是字母,且字符串中至少有一个字符,则该字符串为字母。
>>> str.isalpha('hello')
True
>>> str.isalpha('hello12345')
False
"""
pass
def isascii(self, *args, **kwargs):
"""
如果字符串中的所有字符都是ASCII,则返回True,否则返回False。
ASCII字符的代码点范围为U+0000-U+007F。
空字符串也是ASCII码。
>>> str.isascii('Hello')
True
>>> str.isascii('侯茜')
False
"""
pass
def isdecimal(self, *args, **kwargs):
"""
如果字符串是十进制字符串，则返回True，否则返回False。
如果字符串中的所有字符都是十进制的，并且字符串中至少有一个字符，则该字符串为十进制字符串。
>>> str.isdecimal('0123456789')
True
>>> str.isdecimal('Hello')
False
"""
pass
def isdigit(self, *args, **kwargs):
"""
如果字符串是数字字符串，则返回True，否则返回False。
如果字符串中的所有字符都是数字，且字符串中至少有一个字符，则该字符串为数字字符串。
>>> str.isdigit('Hello')
False
>>> str.isdigit('0123456789')
True
"""
pass
def isidentifier(self, *args, **kwargs):
"""
如果字符串是有效的Python标识符，则返回True，否则返回False。
调用keyword.iskeyword(s)测试字符串s是否是保留标识符，例如“def”或“class”。
>>> str.isidentifier('1Hello')
False
>>> str.isidentifier('Hello')
True
"""
pass
def isnumeric(self, *args, **kwargs):
"""
如果字符串是数字字符串，则返回True，否则返回False。
如果字符串中的所有字符都是数字且字符串中至少有一个字符，则该字符串为数字字符串。
>>> str.isnumeric('123')
True
>>> str.isnumeric('Hello')
Flase
"""
pass
def isprintable(self, *args, **kwargs):
"""
如果字符串可打印，则返回True，否则返回False。
如果字符串的所有字符在repr()中都被认为是可打印的,或者字符串为空,则该字符串是可打印的。
>>> str.isprintable('')
True
>>> str.isprintable(' ')
True
>>> str.isprintable('\t')
False
>>> str.isprintable('Hello')
True
"""
pass
def isspace(self, *args, **kwargs):
"""
如果字符串是空白字符串,则返回True,否则返回False。
如果字符串中的所有字符都是空白，并且字符串中至少有一个字符，则该字符串为空白。
>>> str.isspace('')
False
>>> str.isspace(' ')
True
"""
pass
def upper(self, *args, **kwargs):
"""
返回转换为大写的字符串的副本。
>>> str.upper('hello')
HELLO
"""
pass
def isupper(self, *args, **kwargs):
"""
如果字符串为大写字符串，则返回True，否则返回False。
如果字符串中的所有大小写字符均为大写,且字符串中至少有一个大小写字符,则该字符串为大写。
>>> str.isupper('Hello')
False
>>> str.isupper('HELLO')
True
"""
pass
def lower(self, *args, **kwargs):
"""
返回转换为小写的字符串的副本。
>>> str.lower('HELLO')
hello
"""
pass
def islower(self, *args, **kwargs):
"""
如果字符串是小写字符串，则返回True，否则返回False。
如果字符串中的所有大小写字符都是小写，并且字符串中至少有一个大小写字符，则该字符串为小写。
>>> str.islower('str')
True
>>> str.islower('Str')
False
>>> str.islower('')
False
>>> str.islower('123')
False
"""
pass
def title(self, *args, **kwargs):
"""
返回每个单词都有标题的字符串版本。
更具体地说，单词以大写字母开头，所有剩余的大小写字符都以小写字母开头。
>>> str.title('HELLO WORLD')
Hello World
"""
pass
def istitle(self, *args, **kwargs):
"""
如果字符串是以标题为大小写的字符串,则返回True,否则返回False。
在按标题大小写的字符串中,大写和小写字符只能跟在未按大小写的字符后面,而小写字符只能跟在按大小写的字符后面。
>>> str.istitle('hello world')
False
>>> str.istitle('Hello World')
True
"""
pass
def capitalize(self, *args, **kwargs):
"""
返回字符串的首字母大写版本。
更具体地说,使第一个字符具有大写字母,其余字符具有小写字母。
>>> str.capitalize("hello world")
Hello world
"""
pass
def casefold(self, *args, **kwargs):
"""
返回适合无大小写比较的字符串版本。
>>> str.casefold("HELLO")
hello
>>> str.casefold("hello")
hello
"""
pass
def swapcase(self, *args, **kwargs):
"""
将大写字符转换为小写，将小写字符转换为大写。
>>> str.swapcase('HELLO')
hello
>>> str.swapcase('hello')
HELLO
"""
pass
def endswith(self, suffix, start=None, end=None):
"""
S.endswith(suffix[, start[, end]]) -> bool
如果S以指定的后缀结尾，则返回True，否则返回False。
使用可选开始，测试从该位置开始。
使用可选结束，停止在该位置比较S。
后缀也可以是要尝试的字符串元组。
>>> 'Hello'.endswith('lo')
True
>>> 'Hello'.endswith('lo', 3)
True
>>> 'Hello'.endswith('lo', 3, 5)
True
>>> 'Hello'.endswith(('l','o',), 3, 5)
True
"""
return False
def startswith(self, prefix, start=None, end=None):
"""
S.startswith(prefix[, start[, end]]) -> bool
如果S以指定的前缀开头，则返回True，否则返回False。
使用可选开始，测试从该位置开始。
使用可选结束，停止在该位置比较S。
前缀也可以是要尝试的字符串元组。
>>> 'Hello'.endswith('lo')
True
>>> 'Hello'.endswith('lo', 3)
True
>>> 'Hello'.endswith('lo', 3, 5)
True
>>> 'Hello'.endswith(('l', 'o',), 3, 5)
True
"""
return False
def ljust(self, *args, **kwargs):
"""
返回长度和宽度为左对齐的字符串。
填充使用指定的填充字符完成（默认为空格）。
>>> str.ljust('hello', 20, '*')
hello***************
"""
pass
def rjust(self, *args, **kwargs):
"""
返回一个长度和宽度右对齐的字符串。
填充使用指定的填充字符完成（默认为空格）。
>>> str.rjust('hello', 20, '*')
str.rjust('hello', 20, '*')
>>> str.rjust('hello', 20)
hello
"""
pass
def zfill(self, *args, **kwargs):
"""
在左边用零填充数字字符串,以填充给定宽度的字段。
字符串永远不会被截断。
>>> str.zfill('hello', 20)
000000000000000hello
"""
pass
def center(self, *args, **kwargs):
"""
返回一个长宽居中的字符串。
填充使用指定的填充字符完成（默认为空格）。
>>> str.center('Hello', 20)
Hello
>>> str.center('Hello', 20, '*')
*******Hello********
"""
pass
def expandtabs(self, *args, **kwargs):
"""
返回使用空格展开所有制表符的副本。
如果未指定选项卡大小，则假定为8个字符。
>>> 'Hel\tlo'.expandtabs(8)
Hel lo
"""
pass
def rsplit(self, *args, **kwargs):
"""
使用sep作为分隔符字符串，返回字符串中的单词列表。
sep
用于拆分字符串的分隔符。
None (默认值) 表示根据任何空格进行拆分,并从结果中丢弃空字符串。
maxsplit
要执行的最大拆分数。
-1 (默认值) 意味着没有限制。
拆分从字符串的末尾开始，一直到前面。
>>> str.rsplit('hello world hello world')
['hello', 'world', 'hello', 'world']
>>> str.rsplit('hello world hello world', ' ')
['hello', 'world', 'hello', 'world']
>>> str.rsplit('hello world hello world', ' ', 2)
['hello world', 'hello', 'world']
"""
pass
def split(self, *args, **kwargs):
"""
使用sep作为分隔符字符串，返回字符串中的单词列表。
sep
用于拆分字符串的分隔符。
None (默认值) 表示根据任何空格进行拆分,并从结果中丢弃空字符串。
maxsplit
要执行的最大拆分数。
-1 (默认值) 意味着没有限制。
>>> str.split('hello world hello world')
['hello', 'world', 'hello', 'world']
>>> str.split('hello world hello world', ' ')
['hello', 'world', 'hello', 'world']
>>> str.split('hello world hello world', ' ', 2)
['hello', 'world', 'hello world']
"""
pass
def splitlines(self, *args, **kwargs):
"""
返回字符串中的行列表，在行边界处断开。
除非给定了keepends且为true，否则换行符不包括在结果列表中。
>>> str.splitlines('hello world\\nhello world')
['hello', 'world', 'hello', 'world']
>>> str.splitlines('hello world\\nhello world',keepends=True)
['hello world\n', 'hello world']
"""
pass
def rpartition(self, *args, **kwargs):
"""
使用给定的分隔符将字符串分成三部分。
这将在字符串中搜索分隔符，从末尾开始。
如果找到分隔符，则返回一个3元组，其中包含分隔符前的部分、分隔符本身以及分隔符后的部分。
如果未找到分隔符，则返回包含两个空字符串和原始字符串的3元组。
>>> str.rpartition('hello world', ' ')
('hello', ' ', 'world')
>>> str.rpartition('hello world', '*')
('', '', 'hello world')
"""
pass
def partition(self, *args, **kwargs):
"""
使用给定的分隔符将字符串分成三部分。
这将在字符串中搜索分隔符。
如果找到分隔符，则返回一个3元组，其中包含分隔符前的部分、分隔符本身以及分隔符后的部分。
如果未找到分隔符，则返回一个包含原始字符串和两个空字符串的3元组。
>>> str.partition('hello world', ' ')
('hello', ' ', 'world')
>>> str.partition('hello world', '*')
('hello world', '', '')
"""
pass
def maketrans(self, *args, **kwargs):
"""
返回可用于str.translate（）的转换表。
如果只有一个参数,则必须是将Unicode序号（整数）或字符,映射到Unicode序号、字符串或无的字典。
然后，字符键将转换为序数。
如果有两个参数,它们必须是长度相等的字符串,并且在生成的字典中,x中的每个字符都将映射到y中相同位置的字符。
如果有第三个参数,则必须是字符串,其字符将在结果中映射为“无”。
>>> str.maketrans({1: 2})
{1: 2}
>>> str.maketrans('1', '2')
{49: 50}
>>> str.maketrans('1', '2', '3')
{49: 50, 51: None}
"""
pass
def translate(self, *args, **kwargs):
"""
使用给定的翻译表替换字符串中的每个字符。
table
转换表，它必须是Unicode序数到Unicode序数、字符串或无的映射。
该表必须通过_getitem __实现查找/索引，例如字典或列表。
如果此操作引发LookupError，则该字符保持不变。
将删除映射到“无”的字符。
>>> str.translate('hello', str.maketrans({'h': 'hq'}))
hqello
"""
pass
def removeprefix(self, *args, **kwargs):
"""
返回一个删除了给定前缀字符串（如果存在）的str。
如果字符串以前缀字符串开头，则返回字符串[len（前缀）：]。
否则，返回原始字符串的副本。
>>> str.removeprefix('hello world', 'ld')
hello world
>>> str.removeprefix('hello world', 'he')
llo world
"""
pass
def removesuffix(self, *args, **kwargs):
"""
返回一个删除了给定后缀字符串（如果存在）的str。
如果字符串以后缀字符串结尾且该后缀不是空的，则返回字符串[：-len（后缀）]。
否则，返回原始字符串的副本。
>>> str.removesuffix('hello world', 'ld')
hello wor
>>> str.removesuffix('hello world', 'he')
hello world
"""
pass
def replace(self, *args, **kwargs):
"""
传入三个参数,返回一个其中所有出现的子字符串old均替换为new的副本。
传入四个参数,返回一个替换指定次数的子串的副本。-1 (默认值) 表示替换所有。
>>> str.replace('hello hello hello', 'll', 'jj')
hejjo hejjo hejjo
>>> str.replace('hello hello hello', 'll', 'jj', 2)
hejjo hejjo hello
"""
pass
def format(self, *args, **kwargs):
"""
S.format(*args, **kwargs) -> str
使用args和kwargs中的替换返回S的格式化版本。
替换由大括号（“{”和“}”）标识。
>>> 'H{}e{}llo'.format('hq', 'zy')
Hhqezyllo
"""
pass
def format_map(self, mapping):
"""
S.format_map(mapping) -> str
使用映射(mapping)中的代换(substitutions)返回S的格式化版本。
代换substitutions)由大括号（“{”和“}”）标识。
>>> '{H}ello'.format_map({'H': 'hq'})
hqello
"""
return ""
def lstrip(self, *args, **kwargs):
"""
返回删除前导空格的字符串副本
如果给定了字符而不是无，则删除字符中的字符。
>>> str.lstrip(' HELLO')
HELLO
"""
pass
def rstrip(self, *args, **kwargs):
"""
返回已删除尾随空格的字符串副本。
如果给定了字符而不是无,则删除字符中的字符。
>>> str.rstrip('hello ')
hello
"""
pass
def strip(self, *args, **kwargs):
"""
返回删除前导和尾随空格的字符串副本。
如果给定了字符而不是无，则删除字符中的字符。
>>> str.strip(' hello ')
hello
"""
pass
def find(self, sub, start=None, end=None):
"""
S.find(sub[, start[, end]]) -> int
返回在S中找到子字符串sub的最低索引,以便sub包含在S[start:end]中。
失败时返回-1。
>>> 'Hello'.find('ll')
2
>>> 'Hello'.find('ll', 1)
2
>>> 'Hello'.find('ll', 1, 5)
2
"""
return 0
def rfind(self, sub, start=None, end=None):
"""
S.rfind(sub[, start[, end]]) -> int
返回在S中找到子字符串sub的最高索引，以便sub包含在S[start:end]中。
可选参数start和end解释为切片表示法。
失败时返回-1。
>>> str.rfind('hello hello hello', 'll')
14
>>> str.rfind('hello hello hello', 'll', 2)
14
>>>str.rfind('hello hello hello', 'll', 2, 8)
2
"""
return 0
def index(self, sub, start=None, end=None):
"""
S.index(sub[, start[, end]]) -> int
返回在S中找到子字符串sub的最低索引，以便sub包含在S[start:end]中。
可选参数start和end解释为切片表示法。
未找到子字符串时引发ValueError。
>>> 'HelloHello'.index('el')
1
>>> 'HelloHello'.index('el', 3)
6
>>> 'HelloHello'.index('el', 5, 9)
6
"""
return 0
def rindex(self, sub, start=None, end=None):
"""
S.rindex(sub[, start[, end]]) -> int
返回在S中找到子字符串sub的最高索引，以便sub包含在S[start:end]中。
可选参数start和end解释为切片表示法。
未找到子字符串时引发ValueError。
>>> str.rindex('hello hello hello', 'll')
14
>>> str.rindex('hello hello hello', 'll', 2)
14
str.rindex('hello hello hello', 'll', 2, 8)
2
"""
return 0
def count(self, sub, start=None, end=None):
"""
S.count(sub[, start[, end]]) -> int
返回子字符串sub在字符串S[start:end]中不重叠的出现次数。
可选参数start和end解释为切片表示法。
>>> 'HelloHelloHelloHelloHello'.count('Hello')
5
>>> 'HelloHelloHelloHelloHello'.count('Hello', 10)
3
>>> 'HelloHelloHelloHelloHello'.count('Hello', 10, 15)
1
"""
return 0
def encode(self, *args, **kwargs):
"""
使用注册用于编码的编解码器对字符串进行编码。
encoding
用于对字符串进行编码的编码。
errors
用于编码错误的错误处理方案。
默认值为“strict”，这意味着编码错误会引发UnicodeEncodeError。
其他可能的值包括“ignore”、“replace”和“xmlcharrefreplace”,
以及在编解码器中注册的任何其他名称。
可处理UnicodeErrors的寄存器错误。
>>> 'Hello'.encode(encoding='utf-8', errors='strict')
b'Hello'
"""
pass
def join(self, ab=None, pq=None, rs=None):
"""
连接任意数量的字符串。
调用其方法的字符串将插入到每个给定字符串之间。
结果将作为新字符串返回。
>>> str.join('-', ['hello', 'world'])
hello-world
"""
pass
def __add__(self, *args, **kwargs):
"""
加法。self+value.
>>> 'hello '.__add__('world')
hello world
"""
pass
def __mod__(self, *args, **kwargs):
"""
//TODO 目前不知道怎么用
除法。self%value.
"""
pass
def __rmod__(self, *args, **kwargs):
"""
//TODO 目前不知道怎么用
除法。value%self.
"""
pass
def __mul__(self, *args, **kwargs):
"""
重复。self*value.
>>> 'hello'.__mul__(2)
hellohello
"""
pass
def __rmul__(self, *args, **kwargs):
"""
重复。value*self.
>>> str.__rmul__('hello', 2)
hellohello
"""
pass
def __eq__(self, *args, **kwargs):
"""
相等运算。self==value.
>>> 'hello'.__eq__('hello')
True
"""
pass
def __ne__(self, *args, **kwargs):
"""
不相等。self!=value
按ASCII表从前往后对比
>>> 'a'.__ne__('b')
True
"""
pass
def __ge__(self, *args, **kwargs):
"""
大于等于。self>=value.
按照ASCII值从前往后比
>>> 'a'.__ge__('a')
True
>>> 'b'.__ge__('a')
True
"""
pass
def __gt__(self, *args, **kwargs):
"""
大于。self>value.
按照ASCII值从前往后比
>>> 'b'.__gt__('a')
True
"""
pass
def __le__(self, *args, **kwargs):
"""
小于等于。self<=value.
按照ASCII值从前往后比
>>> 'a'.__ge__('a')
True
>>> 'a'.__ge__('b')
True
"""
pass
def __lt__(self, *args, **kwargs):
"""
小于。self<value.
按照ASCII值从前往后比
>>> 'a'.__gt__('b')
True
"""
pass
def __contains__(self, *args, **kwargs):
"""
包含
>>> 'hello '.__contains__('ll')
True
"""
pass
def __getitem__(self, *args, **kwargs):
"""
根据位序获取值。self[key].
>>> 'hello'.__getitem__(2)
l
"""
pass
def __len__(self, *args, **kwargs):
"""
字符串长度。len(self)
>>> 'hello'.__len__()
5
"""
pass
tuple
class tuple(object):
def __init__(self, seq=()):
"""
内置的不可变序列。
如果没有给出参数，构造函数将返回一个空元组。
如果指定了iterable，则元组将从iterable的项初始化。
如果参数是元组，则返回值是同一个对象。
>>> tuple()
()
>>> tuple([1, 2, 3])
(1, 2, 3)
"""
pass
@staticmethod
def __new__(*args, **kwargs):
"""
创建并返回实例化对象
"""
pass
def __repr__(self, *args, **kwargs):
"""
返回字符串。repr(self)
"""
pass
def __iter__(self, *args, **kwargs):
"""
迭代器协议。iter(self)
"""
pass
def __hash__(self, *args, **kwargs):
"""
哈希值。hash(self)
"""
pass
def __getnewargs__(self, *args, **kwargs):
"""
序列化为元组
"""
pass
def __getattribute__(self, *args, **kwargs):
"""
获取对象方法名。getattr(self, name).
"""
pass
def __class_getitem__(self, *args, **kwargs):
"""
//TODO 干什么用的？
See PEP 585
"""
pass
def count(self, *args, **kwargs):
"""
返回值的出现次数。
>>> a = (1, 2, 3, 4, 5, 6)
>>> a.count(1)
1
"""
pass
def index(self, *args, **kwargs):
"""
返回值的第一个索引。
如果值不存在，则引发ValueError。
>>> (1, 2, 3, 4, 5, 6).index(6)
5
"""
pass
def __eq__(self, *args, **kwargs):
"""
相等。self==value.
整形比较真实大小,其他的按照ASCII表比较
>>> (1, 2).__eq__((2, 1))
False
>>> (1, 2).__eq__((1, 2))
True
"""
pass
def __ne__(self, *args, **kwargs):
"""
不相等。self!=value.
整形比较真实大小,其他的按照ASCII表比较
>>> (1, 2).__ne__((2, 1))
True
>>> (1, 2).__ne__((1, 2))
False
"""
pass
def __ge__(self, *args, **kwargs):
"""
大于等于。self>=value.
整形比较真实大小,其他的按照ASCII表比较
>>> (1, 2).__ge__((1, 2))
True
>>> (1, 2, 3).__ge__((1, 2, 4))
False
"""
pass
def __gt__(self, *args, **kwargs):
"""
大于。self>value.
整形比较真实大小,其他的按照ASCII表比较
>>> (1, 2).__gt__((1, 2))
False
>>> (2, 2).__gt__((1, 2))
True
"""
pass
def __le__(self, *args, **kwargs):
"""
小于等于。self<=value.
整形比较真实大小,其他的按照ASCII表比较
>>> (1, 2).__le__((1, 2))
True
>>> (2, 1).__le__((1, 2))
False
"""
pass
def __lt__(self, *args, **kwargs):
"""
小于。self<value.
整形比较真实大小,其他的按照ASCII表比较
>>> (1, 2).__lt__((1, 2))
False
>>> (1, 1).__lt__((1, 2))
True
"""
pass
def __mul__(self, *args, **kwargs):
"""
乘法。self*value.
>>> (1, 2).__mul__(2)
(1, 2, 1, 2)
"""
pass
def __rmul__(self, *args, **kwargs):
"""
乘法。value*self.
>>> (1, 2).__rmul__(2)
(1, 2, 1, 2)
"""
pass
def __add__(self, *args, **kwargs):
"""
加法。self+value.
>>> (1, 2).__add__((3, 4))
(1, 2, 3, 4)
"""
pass
def __contains__(self, *args, **kwargs):
"""
包含
>>> (1, 2).__contains__((1,))
True
"""
pass
def __len__(self, *args, **kwargs):
"""
元组长度。len(self).
>>> (1, 2).__len__()
2
"""
pass
def __getitem__(self, *args, **kwargs):
"""
返回键值对应的值。self[key].
>>> (1, 2).__getitem__(1)
2
"""
pass
range
class range(object):
start = property(lambda self: object(), lambda self, v: None,
lambda self: None)
step = property(lambda self: object(), lambda self, v: None,
lambda self: None)
stop = property(lambda self: object(), lambda self, v: None,
lambda self: None)
def __init__(self, stop):
"""
range(stop) -> range object
range(start, stop[, step]) -> range object
返回一个对象,该对象逐步生成从start(inclusive（包含))到stop(exclusive（不包含
))的整数序列.range(i, j)产生i, i+1, i+2, ..., j-1.
开始默认为0,stop被忽略！ range(4)产生0, 1, 2, 3.这些正是4个元素的列表的有效索
引.当给定step时,它指定增量(或减量).
>>> list(range(0, 100, 10))
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
"""
pass
@staticmethod
def __new__(*args, **kwargs):
"""
创建并返回实例化对象
"""
pass
def __reduce__(self, *args, **kwargs):
"""
返回pickling的状态信息。
"""
pass
def __repr__(self, *args, **kwargs):
"""
返回字符串。repr(self)
"""
pass
def __hash__(self, *args, **kwargs):
"""
哈希值。hash(self)
"""
pass
def __iter__(self, *args, **kwargs):
"""
迭代器协议。iter(self)
"""
pass
def __getattribute__(self, *args, **kwargs):
"""
获取对象方法名。getattr(self, name).
"""
pass
def count(self, value):
"""
rangeobject.count(value) -> integer -- 返回value的出现次数
>>> range(0, 100, 10).count(10)
1
"""
return 0
def index(self, value):
"""
rangeobject.index(value) -> integer -- 返回value的索引.
如果value不存在,则引发ValueError.
>>> range(0, 100, 10).index(50)
5
"""
return 0
def __eq__(self, *args, **kwargs):
"""
相等运算。self==value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __ne__(self, *args, **kwargs):
"""
不相等。self!=value
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __ge__(self, *args, **kwargs):
"""
大于等于。self>=value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __gt__(self, *args, **kwargs):
"""
大于。self>value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __le__(self, *args, **kwargs):
"""
小于等于。self<=value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __lt__(self, *args, **kwargs):
"""
小于。self<value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __len__(self, *args, **kwargs):
"""
range的长度。len(self).
>>> range(0, 100, 10).__len__()
10
"""
pass
def __bool__(self, *args, **kwargs):
"""
bool值:self != 0
>>> range(0, 100, 10).__bool__()
True
>>> range(0).__bool__()
False
"""
pass
def __contains__(self, *args, **kwargs):
"""
包含:Return key in self.
>>> range(0, 100, 10).__contains__(10)
True
"""
pass
def __getitem__(self, *args, **kwargs):
"""
通过序号获取值:Return self[key].
>>> range(0, 100, 10).__getitem__(2)
20
"""
pass
def __reversed__(self, *args, **kwargs):
"""
反转:Return a reverse iterator.
>>> list(range(0, 100, 10).__reversed__())
[90, 80, 70, 60, 50, 40, 30, 20, 10, 0]
"""
pass
bytes
class bytes(object):
def __init__(self, value=b'', encoding=None, errors='strict'):
"""
bytes(iterable_of_ints) -> bytes
bytes(string, encoding[, errors]) -> bytes
bytes(bytes_or_buffer) -> bytes_or_buffer的不可变副本
bytes(int) -> bytes对象,其大小由初始化为空字节的参数给定
bytes() -> 空字节对象
从以下内容构造不可变的字节数组:
-一个可生成range(256)内整数的迭代器
-使用指定编码进行编码的文本字符串
-实现缓冲区API的任何对象.
-整数
>>> bytes(range(1))
b'\x00'
>>> bytes("魏振", encoding="utf8")
b'\xe9\xad\x8f\xe6\x8c\xaf'
>>> bytes(2)
b'\x00\x00'
>>> bytes()
b''
"""
pass
@staticmethod
def __new__(*args, **kwargs):
"""
创建并返回实例化对象
"""
pass
def __repr__(self, *args, **kwargs):
"""
返回字符串。repr(self)
"""
pass
def __str__(self, *args, **kwargs):
"""
返回字符串。str(self)
"""
pass
def __hash__(self, *args, **kwargs):
"""
哈希值。hash(self)
"""
pass
def __iter__(self, *args, **kwargs):
"""
迭代器协议。iter(self)
"""
pass
def __getnewargs__(self, *args, **kwargs):
"""
序列化为元组
"""
pass
def __getattribute__(self, *args, **kwargs):
"""
获取对象方法名。getattr(self, name).
"""
pass
def capitalize(self):
"""
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, *args, **kwargs):
"""
Return a centered string of length width.
Padding is done using the specified fill character.
"""
pass
def count(self, sub, start=None,
end=None):
"""
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, *args, **kwargs):
"""
Decode the bytes using the codec registered for encoding.
encoding
The encoding with which to decode the bytes.
errors
The error handling scheme to use for the handling of decoding errors.
The default is 'strict' meaning that decoding errors raise a
UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that
can handle UnicodeDecodeErrors.
"""
pass
def endswith(self, suffix, start=None,
end=None):
"""
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 bytes to try.
"""
return False
def expandtabs(self, *args, **kwargs):
"""
Return a copy where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
"""
pass
def find(self, sub, start=None,
end=None):
"""
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
def fromhex(cls, *args,
**kwargs):
"""
Create a bytes object from a string of hexadecimal numbers.
Spaces between two numbers are accepted.
Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'.
"""
pass
def hex(self):
"""
Create a str of hexadecimal numbers from a bytes object.
sep
An optional single character or byte to separate hex bytes.
bytes_per_sep
How many bytes between separators. Positive values count from the
right, negative values count from the left.
Example:
>>> value = b'\xb9\x01\xef'
>>> value.hex()
'b901ef'
>>> value.hex(':')
'b9:01:ef'
>>> value.hex(':', 2)
'b9:01ef'
>>> value.hex(':', -2)
'b901:ef'
"""
pass
def index(self, sub, start=None,
end=None):
"""
B.index(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.
Raises ValueError when the subsection is not found.
"""
return 0
def isalnum(self):
"""
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):
"""
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 isascii(self):
"""
B.isascii() -> bool
Return True if B is empty or all characters in B are ASCII,
False otherwise.
"""
return False
def isdigit(self):
"""
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):
"""
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):
"""
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):
"""
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):
"""
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, *args,
**kwargs):
"""
Concatenate any number of bytes objects.
The bytes whose method is called is inserted in between each pair.
The result is returned as a new bytes object.
Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.
"""
pass
def ljust(self, *args, **kwargs):
"""
Return a left-justified string of length width.
Padding is done using the specified fill character.
"""
pass
def lower(self):
"""
B.lower() -> copy of B
Return a copy of B with all ASCII characters converted to lowercase.
"""
pass
def lstrip(self, *args, **kwargs):
"""
Strip leading bytes contained in the argument.
If the argument is omitted or None, strip leading ASCII whitespace.
"""
pass
@staticmethod
def maketrans(*args, **kwargs):
"""
Return a translation table useable for the bytes or bytearray translate method.
The returned table will be one where each byte in frm is mapped to the byte at
the same position in to.
The bytes objects frm and to must be of the same length.
"""
pass
def partition(self, *args, **kwargs):
"""
Partition the bytes into three parts using the given separator.
This will search for the separator sep in the bytes. If the separator is found,
returns a 3-tuple containing the part before the separator, the separator
itself, and the part after it.
If the separator is not found, returns a 3-tuple containing the original bytes
object and two empty bytes objects.
"""
pass
def removeprefix(self, *args, **kwargs):
"""
Return a bytes object with the given prefix string removed if present.
If the bytes starts with the prefix string, return bytes[len(prefix):].
Otherwise, return a copy of the original bytes.
"""
pass
def removesuffix(self, *args, **kwargs):
"""
Return a bytes object with the given suffix string removed if present.
If the bytes ends with the suffix string and that suffix is not empty,
return bytes[:-len(prefix)]. Otherwise, return a copy of the original
bytes.
"""
pass
def replace(self, *args, **kwargs):
"""
Return a copy with all occurrences of substring old replaced by new.
count
Maximum number of occurrences to replace.
-1 (the default value) means replace all occurrences.
If the optional argument count is given, only the first count occurrences are
replaced.
"""
pass
def rfind(self, sub, start=None,
end=None):
"""
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):
"""
B.rindex(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.
Raise ValueError when the subsection is not found.
"""
return 0
def rjust(self, *args, **kwargs):
"""
Return a right-justified string of length width.
Padding is done using the specified fill character.
"""
pass
def rpartition(self, *args, **kwargs):
"""
Partition the bytes into three parts using the given separator.
This will search for the separator sep in the bytes, starting at the end. If
the separator is found, returns a 3-tuple containing the part before the
separator, the separator itself, and the part after it.
If the separator is not found, returns a 3-tuple containing two empty bytes
objects and the original bytes object.
"""
pass
def rsplit(self, *args, **kwargs):
"""
Return a list of the sections in the bytes, using sep as the delimiter.
sep
The delimiter according which to split the bytes.
None (the default value) means split on ASCII whitespace characters
(space, tab, return, newline, formfeed, vertical tab).
maxsplit
Maximum number of splits to do.
-1 (the default value) means no limit.
Splitting is done starting at the end of the bytes and working to the front.
"""
pass
def rstrip(self, *args, **kwargs):
"""
Strip trailing bytes contained in the argument.
If the argument is omitted or None, strip trailing ASCII whitespace.
"""
pass
def split(self, *args, **kwargs):
"""
Return a list of the sections in the bytes, using sep as the delimiter.
sep
The delimiter according which to split the bytes.
None (the default value) means split on ASCII whitespace characters
(space, tab, return, newline, formfeed, vertical tab).
maxsplit
Maximum number of splits to do.
-1 (the default value) means no limit.
"""
pass
def splitlines(self, *args, **kwargs):
"""
Return a list of the lines in the bytes, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends is given and
true.
"""
pass
def startswith(self, prefix, start=None,
end=None):
"""
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 bytes to try.
"""
return False
def strip(self, *args, **kwargs):
"""
Strip leading and trailing bytes contained in the argument.
If the argument is omitted or None, strip leading and trailing ASCII whitespace.
"""
pass
def swapcase(self):
"""
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):
"""
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, *args, **kwargs):
"""
Return a copy with each character mapped by the given translation table.
table
Translation table, which must be a bytes object of length 256.
All characters occurring in the optional argument delete are removed.
The remaining characters are mapped through the given translation table.
"""
pass
def upper(self):
"""
B.upper() -> copy of B
Return a copy of B with all ASCII characters converted to uppercase.
"""
pass
def zfill(self, *args, **kwargs):
"""
Pad a numeric string with zeros on the left, to fill a field of the given width.
The original string is never truncated.
"""
pass
def __contains__(self, *args, **kwargs):
"""
包含:Return key in self.
"""
pass
def __getitem__(self, *args, **kwargs):
"""
返回键值对应的值。self[key].
"""
pass
def __len__(self, *args, **kwargs):
"""
bytes的长度。len(self).
"""
pass
def __eq__(self, *args, **kwargs):
"""
相等运算。self==value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __ne__(self, *args, **kwargs):
"""
不相等。self!=value
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __ge__(self, *args, **kwargs):
"""
大于等于。self>=value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __gt__(self, *args, **kwargs):
"""
大于。self>value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __le__(self, *args, **kwargs):
"""
小于等于。self<=value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __lt__(self, *args, **kwargs):
"""
小于。self<value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __mod__(self, *args, **kwargs):
""" Return self%value. """
pass
def __rmod__(self, *args, **kwargs):
""" Return value%self. """
pass
def __mul__(self, *args, **kwargs):
""" Return self*value. """
pass
def __rmul__(self, *args, **kwargs):
""" Return value*self. """
pass
def __add__(self, *args, **kwargs):
""" Return self+value. """
pass
bytearray
class bytearray(object):
def __init__(self, source=None, encoding=None, errors='strict'):
"""
bytearray(iterable_of_ints) -> bytearray
bytearray(string, encoding[, errors]) -> bytearray
bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
bytearray() -> empty bytes array
Construct a mutable bytearray object from:
- an iterable yielding integers in range(256)
- a text string encoded using the specified encoding
- a bytes or a buffer object
- any object implementing the buffer API.
- an integer
"""
pass
@staticmethod
def __new__(*args, **kwargs):
"""
创建并返回实例化对象
"""
pass
def __sizeof__(self, *args, **kwargs):
"""
返回对象在内存中的大小（以字节为单位）
"""
pass
def __str__(self, *args, **kwargs):
"""
返回字符串。str(self)
"""
pass
__hash__ = None
def __reduce_ex__(self, *args, **kwargs):
"""
返回pickling的状态信息。
"""
pass
def __reduce__(self, *args, **kwargs):
"""
返回pickling的状态信息。
"""
pass
def __repr__(self, *args, **kwargs):
"""
返回字符串。repr(self)
"""
pass
def __getattribute__(self, *args, **kwargs):
"""
获取对象方法名。getattr(self, name).
"""
pass
def __iter__(self, *args, **kwargs):
"""
迭代器协议。iter(self)
"""
pass
def append(self, *args, **kwargs):
"""
Append a single item to the end of the bytearray.
item
The item to be appended.
"""
pass
def capitalize(self):
"""
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, *args, **kwargs):
"""
Return a centered string of length width.
Padding is done using the specified fill character.
"""
pass
def clear(self, *args, **kwargs):
""" Remove all items from the bytearray. """
pass
def copy(self, *args, **kwargs):
""" Return a copy of B. """
pass
def count(self, sub, start=None,
end=None):
"""
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, *args, **kwargs):
"""
Decode the bytearray using the codec registered for encoding.
encoding
The encoding with which to decode the bytearray.
errors
The error handling scheme to use for the handling of decoding errors.
The default is 'strict' meaning that decoding errors raise a
UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that
can handle UnicodeDecodeErrors.
"""
pass
def endswith(self, suffix, start=None, end=None):
"""
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 bytes to try.
"""
return False
def expandtabs(self, *args, **kwargs):
"""
Return a copy 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, *args, **kwargs):
"""
Append all the items from the iterator or sequence to the end of the bytearray.
iterable_of_ints
The iterable of items to append.
"""
pass
def find(self, sub, start=None,
end=None):
"""
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
def fromhex(cls, *args,
**kwargs):
"""
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')
"""
pass
def hex(self):
"""
Create a str of hexadecimal numbers from a bytearray object.
sep
An optional single character or byte to separate hex bytes.
bytes_per_sep
How many bytes between separators. Positive values count from the
right, negative values count from the left.
Example:
>>> value = bytearray([0xb9, 0x01, 0xef])
>>> value.hex()
'b901ef'
>>> value.hex(':')
'b9:01:ef'
>>> value.hex(':', 2)
'b9:01ef'
>>> value.hex(':', -2)
'b901:ef'
"""
pass
def index(self, sub, start=None, end=None):
"""
B.index(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.
Raises ValueError when the subsection is not found.
"""
return 0
def insert(self, *args, **kwargs):
"""
Insert a single item into the bytearray before the given index.
index
The index where the value is to be inserted.
item
The item to be inserted.
"""
pass
def isalnum(self):
"""
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):
"""
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 isascii(self):
"""
B.isascii() -> bool
Return True if B is empty or all characters in B are ASCII,
False otherwise.
"""
return False
def isdigit(self):
"""
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):
"""
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):
"""
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):
"""
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):
"""
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, *args, **kwargs):
"""
Concatenate any number of bytes/bytearray objects.
The bytearray whose method is called is inserted in between each pair.
The result is returned as a new bytearray object.
"""
pass
def ljust(self, *args, **kwargs):
"""
Return a left-justified string of length width.
Padding is done using the specified fill character.
"""
pass
def lower(self):
"""
B.lower() -> copy of B
Return a copy of B with all ASCII characters converted to lowercase.
"""
pass
def lstrip(self, *args, **kwargs):
"""
Strip leading bytes contained in the argument.
If the argument is omitted or None, strip leading ASCII whitespace.
"""
pass
@staticmethod
def maketrans(*args, **kwargs):
"""
Return a translation table useable for the bytes or bytearray translate method.
The returned table will be one where each byte in frm is mapped to the byte at
the same position in to.
The bytes objects frm and to must be of the same length.
"""
pass
def partition(self, *args, **kwargs):
"""
Partition the bytearray into three parts using the given separator.
This will search for the separator sep in the bytearray. If the separator is
found, returns a 3-tuple containing the part before the separator, the
separator itself, and the part after it as new bytearray objects.
If the separator is not found, returns a 3-tuple containing the copy of the
original bytearray object and two empty bytearray objects.
"""
pass
def pop(self, *args, **kwargs):
"""
Remove and return a single item from B.
index
The index from where to remove the item.
-1 (the default value) means remove the last item.
If no index argument is given, will pop the last item.
"""
pass
def remove(self, *args, **kwargs):
"""
Remove the first occurrence of a value in the bytearray.
value
The value to remove.
"""
pass
def removeprefix(self, *args, **kwargs):
"""
Return a bytearray with the given prefix string removed if present.
If the bytearray starts with the prefix string, return
bytearray[len(prefix):]. Otherwise, return a copy of the original
bytearray.
"""
pass
def removesuffix(self, *args, **kwargs):
"""
Return a bytearray with the given suffix string removed if present.
If the bytearray ends with the suffix string and that suffix is not
empty, return bytearray[:-len(suffix)]. Otherwise, return a copy of
the original bytearray.
"""
pass
def replace(self, *args, **kwargs):
"""
Return a copy with all occurrences of substring old replaced by new.
count
Maximum number of occurrences to replace.
-1 (the default value) means replace all occurrences.
If the optional argument count is given, only the first count occurrences are
replaced.
"""
pass
def reverse(self, *args, **kwargs):
""" Reverse the order of the values in B in place. """
pass
def rfind(self, sub, start=None,
end=None):
"""
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):
"""
B.rindex(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.
Raise ValueError when the subsection is not found.
"""
return 0
def rjust(self, *args, **kwargs):
"""
Return a right-justified string of length width.
Padding is done using the specified fill character.
"""
pass
def rpartition(self, *args, **kwargs):
"""
Partition the bytearray into three parts using the given separator.
This will search for the separator sep in the bytearray, starting at the end.
If the separator is found, returns a 3-tuple containing the part before the
separator, the separator itself, and the part after it as new bytearray
objects.
If the separator is not found, returns a 3-tuple containing two empty bytearray
objects and the copy of the original bytearray object.
"""
pass
def rsplit(self, *args, **kwargs):
"""
Return a list of the sections in the bytearray, using sep as the delimiter.
sep
The delimiter according which to split the bytearray.
None (the default value) means split on ASCII whitespace characters
(space, tab, return, newline, formfeed, vertical tab).
maxsplit
Maximum number of splits to do.
-1 (the default value) means no limit.
Splitting is done starting at the end of the bytearray and working to the front.
"""
pass
def rstrip(self, *args, **kwargs):
"""
Strip trailing bytes contained in the argument.
If the argument is omitted or None, strip trailing ASCII whitespace.
"""
pass
def split(self, *args, **kwargs):
"""
Return a list of the sections in the bytearray, using sep as the delimiter.
sep
The delimiter according which to split the bytearray.
None (the default value) means split on ASCII whitespace characters
(space, tab, return, newline, formfeed, vertical tab).
maxsplit
Maximum number of splits to do.
-1 (the default value) means no limit.
"""
pass
def splitlines(self, *args, **kwargs):
"""
Return a list of the lines in the bytearray, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends is given and
true.
"""
pass
def startswith(self, prefix, start=None,
end=None):
"""
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 bytes to try.
"""
return False
def strip(self, *args, **kwargs):
"""
Strip leading and trailing bytes contained in the argument.
If the argument is omitted or None, strip leading and trailing ASCII whitespace.
"""
pass
def swapcase(self):
"""
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):
"""
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, *args, **kwargs):
"""
Return a copy with each character mapped by the given translation table.
table
Translation table, which must be a bytes object of length 256.
All characters occurring in the optional argument delete are removed.
The remaining characters are mapped through the given translation table.
"""
pass
def upper(self):
"""
B.upper() -> copy of B
Return a copy of B with all ASCII characters converted to uppercase.
"""
pass
def zfill(self, *args, **kwargs):
"""
Pad a numeric string with zeros on the left, to fill a field of the given width.
The original string is never truncated.
"""
pass
def __alloc__(self):
"""
B.__alloc__() -> int
Return the number of bytes actually allocated.
"""
return 0
def __delitem__(self, *args, **kwargs):
""" Delete self[key]. """
pass
def __setitem__(self, *args, **kwargs):
""" Set self[key] to value. """
pass
def __getitem__(self, *args, **kwargs):
"""
返回键值对应的值。self[key].
"""
pass
def __contains__(self, *args, **kwargs):
""" Return key in self. """
pass
def __eq__(self, *args, **kwargs):
"""
相等运算。self==value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __ne__(self, *args, **kwargs):
"""
不相等。self!=value
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __ge__(self, *args, **kwargs):
"""
大于等于。self>=value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __gt__(self, *args, **kwargs):
"""
大于。self>value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __le__(self, *args, **kwargs):
"""
小于等于。self<=value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __lt__(self, *args, **kwargs):
"""
小于。self<value.
整形比较真实大小,其他的按照ASCII表比较
"""
pass
def __len__(self, *args, **kwargs):
"""
列表的长度。len(self).
>>> list.__len__([1, 2])
2
"""
pass
def __iadd__(self, *args, **kwargs):
""" Implement self+=value. """
pass
def __add__(self, *args, **kwargs):
""" Return self+value. """
pass
def __mod__(self, *args, **kwargs):
""" Return self%value. """
pass
def __rmod__(self, *args, **kwargs):
""" Return value%self. """
pass
def __imul__(self, *args, **kwargs):
""" Implement self*=value. """
pass
def __mul__(self, *args, **kwargs):
""" Return self*value. """
pass
def __rmul__(self, *args, **kwargs):
"""
Return value*self.
"""
pass
参考文档：python文档
981
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
