/int整数/

如： 18、73、84

每一个整数都具备如下功能：

  1. class int(object):
  2.     """
  3.     int(x=0) -> int or long
  4.     int(x, base=10) -> int or long
  5.  
  6.     Convert a number or string to an integer, or return 0 if no arguments
  7.     are given.  If x is floating point, the conversion truncates towards zero.
  8.     If x is outside the integer range, the function returns a long instead.
  9.  
  10.     If x is not a number or if base is given, then x must be a string or
  11.     Unicode object representing an integer literal in the given base.  The
  12.     literal can be preceded by '+' or '-' and be surrounded by whitespace.
  13.     The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
  14.     interpret the base from the string as an integer literal.
  15.     >>> int('0b100', base=0)
  16.     """
  17.     def bit_length(self):
  18.         """ 返回表示该数字的时占用的最少位数 """
  19.         """
  20.         int.bit_length() -> int
  21.  
  22.         Number of bits necessary to represent self in binary.
  23.         >>> bin(37)
  24.         '0b100101'
  25.         >>> (37).bit_length()
  26.         """
  27.         return 0
  28.  
  29.     def conjugate(self, *args, **kwargs): # real signature unknown
  30.         """ 返回该复数的共轭复数 """
  31.         """ Returns self, the complex conjugate of any int. """
  32.         pass
  33.  
  34.     def __abs__(self):
  35.         """ 返回绝对值 """
  36.         """ x.__abs__() <==> abs(x) """
  37.         pass
  38.  
  39.     def __add__(self, y):
  40.         """ x.__add__(y) <==> x+y """
  41.         pass
  42.  
  43.     def __and__(self, y):
  44.         """ x.__and__(y) <==> x&y """
  45.         pass
  46.  
  47.     def __cmp__(self, y):
  48.         """ 比较两个数大小 """
  49.         """ x.__cmp__(y) <==> cmp(x,y) """
  50.         pass
  51.  
  52.     def __coerce__(self, y):
  53.         """ 强制生成一个元组 """
  54.         """ x.__coerce__(y) <==> coerce(x, y) """
  55.         pass
  56.  
  57.     def __divmod__(self, y):
  58.         """ 相除，得到商和余数组成的元组 """
  59.         """ x.__divmod__(y) <==> divmod(x, y) """
  60.         pass
  61.  
  62.     def __div__(self, y):
  63.         """ x.__div__(y) <==> x/y """
  64.         pass
  65.  
  66.     def __float__(self):
  67.         """ 转换为浮点类型 """
  68.         """ x.__float__() <==> float(x) """
  69.         pass
  70.  
  71.     def __floordiv__(self, y):
  72.         """ x.__floordiv__(y) <==> x//y """
  73.         pass
  74.  
  75.     def __format__(self, *args, **kwargs): # real signature unknown
  76.         pass
  77.  
  78.     def __getattribute__(self, name):
  79.         """ x.__getattribute__('name') <==> x.name """
  80.         pass
  81.  
  82.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  83.         """ 内部调用 __new__方法或创建对象时传入参数使用 """
  84.         pass
  85.  
  86.     def __hash__(self):
  87.         """如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等。"""
  88.         """ x.__hash__() <==> hash(x) """
  89.         pass
  90.  
  91.     def __hex__(self):
  92.         """ 返回当前数的 十六进制 表示 """
  93.         """ x.__hex__() <==> hex(x) """
  94.         pass
  95.  
  96.     def __index__(self):
  97.         """ 用于切片，数字无意义 """
  98.         """ x[y:z] <==> x[y.__index__():z.__index__()] """
  99.         pass
  100.  
  101.     def __init__(self, x, base=10): # known special case of int.__init__
  102.         """ 构造方法，执行 x = 123 或 x = int(10) 时，自动调用，暂时忽略 """
  103.         """
  104.         int(x=0) -> int or long
  105.         int(x, base=10) -> int or long
  106.  
  107.         Convert a number or string to an integer, or return 0 if no arguments
  108.         are given.  If x is floating point, the conversion truncates towards zero.
  109.         If x is outside the integer range, the function returns a long instead.
  110.  
  111.         If x is not a number or if base is given, then x must be a string or
  112.         Unicode object representing an integer literal in the given base.  The
  113.         literal can be preceded by '+' or '-' and be surrounded by whitespace.
  114.         The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
  115.         interpret the base from the string as an integer literal.
  116.         >>> int('0b100', base=0)
  117.         # (copied from class doc)
  118.         """
  119.         pass
  120.  
  121.     def __int__(self):
  122.         """ 转换为整数 """
  123.         """ x.__int__() <==> int(x) """
  124.         pass
  125.  
  126.     def __invert__(self):
  127.         """ x.__invert__() <==> ~x """
  128.         pass
  129.  
  130.     def __long__(self):
  131.         """ 转换为长整数 """
  132.         """ x.__long__() <==> long(x) """
  133.         pass
  134.  
  135.     def __lshift__(self, y):
  136.         """ x.__lshift__(y) <==> x<<y """
  137.         pass
  138.  
  139.     def __mod__(self, y):
  140.         """ x.__mod__(y) <==> x%y """
  141.         pass
  142.  
  143.     def __mul__(self, y):
  144.         """ x.__mul__(y) <==> x*y """
  145.         pass
  146.  
  147.     def __neg__(self):
  148.         """ x.__neg__() <==> -x """
  149.         pass
  150.  
  151.     @staticmethod # known case of __new__
  152.     def __new__(S, *more):
  153.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  154.         pass
  155.  
  156.     def __nonzero__(self):
  157.         """ x.__nonzero__() <==> x != 0 """
  158.         pass
  159.  
  160.     def __oct__(self):
  161.         """ 返回改值的 八进制 表示 """
  162.         """ x.__oct__() <==> oct(x) """
  163.         pass
  164.  
  165.     def __or__(self, y):
  166.         """ x.__or__(y) <==> x|y """
  167.         pass
  168.  
  169.     def __pos__(self):
  170.         """ x.__pos__() <==> +x """
  171.         pass
  172.  
  173.     def __pow__(self, y, z=None):
  174.         """ 幂，次方 """
  175.         """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
  176.         pass
  177.  
  178.     def __radd__(self, y):
  179.         """ x.__radd__(y) <==> y+x """
  180.         pass
  181.  
  182.     def __rand__(self, y):
  183.         """ x.__rand__(y) <==> y&x """
  184.         pass
  185.  
  186.     def __rdivmod__(self, y):
  187.         """ x.__rdivmod__(y) <==> divmod(y, x) """
  188.         pass
  189.  
  190.     def __rdiv__(self, y):
  191.         """ x.__rdiv__(y) <==> y/x """
  192.         pass
  193.  
  194.     def __repr__(self):
  195.         """转化为解释器可读取的形式 """
  196.         """ x.__repr__() <==> repr(x) """
  197.         pass
  198.  
  199.     def __str__(self):
  200.         """转换为人阅读的形式，如果没有适于人阅读的解释形式的话，则返回解释器课阅读的形式"""
  201.         """ x.__str__() <==> str(x) """
  202.         pass
  203.  
  204.     def __rfloordiv__(self, y):
  205.         """ x.__rfloordiv__(y) <==> y//x """
  206.         pass
  207.  
  208.     def __rlshift__(self, y):
  209.         """ x.__rlshift__(y) <==> y<<x """
  210.         pass
  211.  
  212.     def __rmod__(self, y):
  213.         """ x.__rmod__(y) <==> y%x """
  214.         pass
  215.  
  216.     def __rmul__(self, y):
  217.         """ x.__rmul__(y) <==> y*x """
  218.         pass
  219.  
  220.     def __ror__(self, y):
  221.         """ x.__ror__(y) <==> y|x """
  222.         pass
  223.  
  224.     def __rpow__(self, x, z=None):
  225.         """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
  226.         pass
  227.  
  228.     def __rrshift__(self, y):
  229.         """ x.__rrshift__(y) <==> y>>x """
  230.         pass
  231.  
  232.     def __rshift__(self, y):
  233.         """ x.__rshift__(y) <==> x>>y """
  234.         pass
  235.  
  236.     def __rsub__(self, y):
  237.         """ x.__rsub__(y) <==> y-x """
  238.         pass
  239.  
  240.     def __rtruediv__(self, y):
  241.         """ x.__rtruediv__(y) <==> y/x """
  242.         pass
  243.  
  244.     def __rxor__(self, y):
  245.         """ x.__rxor__(y) <==> y^x """
  246.         pass
  247.  
  248.     def __sub__(self, y):
  249.         """ x.__sub__(y) <==> x-y """
  250.         pass
  251.  
  252.     def __truediv__(self, y):
  253.         """ x.__truediv__(y) <==> x/y """
  254.         pass
  255.  
  256.     def __trunc__(self, *args, **kwargs):
  257.         """ 返回数值被截取为整形的值，在整形中无意义 """
  258.         pass
  259.  
  260.     def __xor__(self, y):
  261.         """ x.__xor__(y) <==> x^y """
  262.         pass
  263.  
  264.     denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  265.     """ 分母 = 1 """
  266.     """the denominator of a rational number in lowest terms"""
  267.  
  268.     imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  269.     """ 虚数，无意义 """
  270.     """the imaginary part of a complex number"""
  271.  
  272.     numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  273.     """ 分子 = 数字大小 """
  274.     """the numerator of a rational number in lowest terms"""
  275.  
  276.     real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  277.     """ 实属，无意义 """
  278.     """the real part of a complex number"""
  279.  
  280. int

int

/long长整型/

可能如：2147483649、9223372036854775807

每个长整型都具备如下功能：

  1. class long(object):
  2.     """
  3.     long(x=0) -> long
  4.     long(x, base=10) -> long
  5.  
  6.     Convert a number or string to a long integer, or return 0L if no arguments
  7.     are given.  If x is floating point, the conversion truncates towards zero.
  8.  
  9.     If x is not a number or if base is given, then x must be a string or
  10.     Unicode object representing an integer literal in the given base.  The
  11.     literal can be preceded by '+' or '-' and be surrounded by whitespace.
  12.     The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
  13.     interpret the base from the string as an integer literal.
  14.     >>> int('0b100', base=0)
  15.     4L
  16.     """
  17.     def bit_length(self): # real signature unknown; restored from __doc__
  18.         """
  19.         long.bit_length() -> int or long
  20.  
  21.         Number of bits necessary to represent self in binary.
  22.         >>> bin(37L)
  23.         '0b100101'
  24.         >>> (37L).bit_length()
  25.         """
  26.         return 0
  27.  
  28.     def conjugate(self, *args, **kwargs): # real signature unknown
  29.         """ Returns self, the complex conjugate of any long. """
  30.         pass
  31.  
  32.     def __abs__(self): # real signature unknown; restored from __doc__
  33.         """ x.__abs__() <==> abs(x) """
  34.         pass
  35.  
  36.     def __add__(self, y): # real signature unknown; restored from __doc__
  37.         """ x.__add__(y) <==> x+y """
  38.         pass
  39.  
  40.     def __and__(self, y): # real signature unknown; restored from __doc__
  41.         """ x.__and__(y) <==> x&y """
  42.         pass
  43.  
  44.     def __cmp__(self, y): # real signature unknown; restored from __doc__
  45.         """ x.__cmp__(y) <==> cmp(x,y) """
  46.         pass
  47.  
  48.     def __coerce__(self, y): # real signature unknown; restored from __doc__
  49.         """ x.__coerce__(y) <==> coerce(x, y) """
  50.         pass
  51.  
  52.     def __divmod__(self, y): # real signature unknown; restored from __doc__
  53.         """ x.__divmod__(y) <==> divmod(x, y) """
  54.         pass
  55.  
  56.     def __div__(self, y): # real signature unknown; restored from __doc__
  57.         """ x.__div__(y) <==> x/y """
  58.         pass
  59.  
  60.     def __float__(self): # real signature unknown; restored from __doc__
  61.         """ x.__float__() <==> float(x) """
  62.         pass
  63.  
  64.     def __floordiv__(self, y): # real signature unknown; restored from __doc__
  65.         """ x.__floordiv__(y) <==> x//y """
  66.         pass
  67.  
  68.     def __format__(self, *args, **kwargs): # real signature unknown
  69.         pass
  70.  
  71.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  72.         """ x.__getattribute__('name') <==> x.name """
  73.         pass
  74.  
  75.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  76.         pass
  77.  
  78.     def __hash__(self): # real signature unknown; restored from __doc__
  79.         """ x.__hash__() <==> hash(x) """
  80.         pass
  81.  
  82.     def __hex__(self): # real signature unknown; restored from __doc__
  83.         """ x.__hex__() <==> hex(x) """
  84.         pass
  85.  
  86.     def __index__(self): # real signature unknown; restored from __doc__
  87.         """ x[y:z] <==> x[y.__index__():z.__index__()] """
  88.         pass
  89.  
  90.     def __init__(self, x=0): # real signature unknown; restored from __doc__
  91.         pass
  92.  
  93.     def __int__(self): # real signature unknown; restored from __doc__
  94.         """ x.__int__() <==> int(x) """
  95.         pass
  96.  
  97.     def __invert__(self): # real signature unknown; restored from __doc__
  98.         """ x.__invert__() <==> ~x """
  99.         pass
  100.  
  101.     def __long__(self): # real signature unknown; restored from __doc__
  102.         """ x.__long__() <==> long(x) """
  103.         pass
  104.  
  105.     def __lshift__(self, y): # real signature unknown; restored from __doc__
  106.         """ x.__lshift__(y) <==> x<<y """
  107.         pass
  108.  
  109.     def __mod__(self, y): # real signature unknown; restored from __doc__
  110.         """ x.__mod__(y) <==> x%y """
  111.         pass
  112.  
  113.     def __mul__(self, y): # real signature unknown; restored from __doc__
  114.         """ x.__mul__(y) <==> x*y """
  115.         pass
  116.  
  117.     def __neg__(self): # real signature unknown; restored from __doc__
  118.         """ x.__neg__() <==> -x """
  119.         pass
  120.  
  121.     @staticmethod # known case of __new__
  122.     def __new__(S, *more): # real signature unknown; restored from __doc__
  123.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  124.         pass
  125.  
  126.     def __nonzero__(self): # real signature unknown; restored from __doc__
  127.         """ x.__nonzero__() <==> x != 0 """
  128.         pass
  129.  
  130.     def __oct__(self): # real signature unknown; restored from __doc__
  131.         """ x.__oct__() <==> oct(x) """
  132.         pass
  133.  
  134.     def __or__(self, y): # real signature unknown; restored from __doc__
  135.         """ x.__or__(y) <==> x|y """
  136.         pass
  137.  
  138.     def __pos__(self): # real signature unknown; restored from __doc__
  139.         """ x.__pos__() <==> +x """
  140.         pass
  141.  
  142.     def __pow__(self, y, z=None): # real signature unknown; restored from __doc__
  143.         """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
  144.         pass
  145.  
  146.     def __radd__(self, y): # real signature unknown; restored from __doc__
  147.         """ x.__radd__(y) <==> y+x """
  148.         pass
  149.  
  150.     def __rand__(self, y): # real signature unknown; restored from __doc__
  151.         """ x.__rand__(y) <==> y&x """
  152.         pass
  153.  
  154.     def __rdivmod__(self, y): # real signature unknown; restored from __doc__
  155.         """ x.__rdivmod__(y) <==> divmod(y, x) """
  156.         pass
  157.  
  158.     def __rdiv__(self, y): # real signature unknown; restored from __doc__
  159.         """ x.__rdiv__(y) <==> y/x """
  160.         pass
  161.  
  162.     def __repr__(self): # real signature unknown; restored from __doc__
  163.         """ x.__repr__() <==> repr(x) """
  164.         pass
  165.  
  166.     def __rfloordiv__(self, y): # real signature unknown; restored from __doc__
  167.         """ x.__rfloordiv__(y) <==> y//x """
  168.         pass
  169.  
  170.     def __rlshift__(self, y): # real signature unknown; restored from __doc__
  171.         """ x.__rlshift__(y) <==> y<<x """
  172.         pass
  173.  
  174.     def __rmod__(self, y): # real signature unknown; restored from __doc__
  175.         """ x.__rmod__(y) <==> y%x """
  176.         pass
  177.  
  178.     def __rmul__(self, y): # real signature unknown; restored from __doc__
  179.         """ x.__rmul__(y) <==> y*x """
  180.         pass
  181.  
  182.     def __ror__(self, y): # real signature unknown; restored from __doc__
  183.         """ x.__ror__(y) <==> y|x """
  184.         pass
  185.  
  186.     def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__
  187.         """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
  188.         pass
  189.  
  190.     def __rrshift__(self, y): # real signature unknown; restored from __doc__
  191.         """ x.__rrshift__(y) <==> y>>x """
  192.         pass
  193.  
  194.     def __rshift__(self, y): # real signature unknown; restored from __doc__
  195.         """ x.__rshift__(y) <==> x>>y """
  196.         pass
  197.  
  198.     def __rsub__(self, y): # real signature unknown; restored from __doc__
  199.         """ x.__rsub__(y) <==> y-x """
  200.         pass
  201.  
  202.     def __rtruediv__(self, y): # real signature unknown; restored from __doc__
  203.         """ x.__rtruediv__(y) <==> y/x """
  204.         pass
  205.  
  206.     def __rxor__(self, y): # real signature unknown; restored from __doc__
  207.         """ x.__rxor__(y) <==> y^x """
  208.         pass
  209.  
  210.     def __sizeof__(self, *args, **kwargs): # real signature unknown
  211.         """ Returns size in memory, in bytes """
  212.         pass
  213.  
  214.     def __str__(self): # real signature unknown; restored from __doc__
  215.         """ x.__str__() <==> str(x) """
  216.         pass
  217.  
  218.     def __sub__(self, y): # real signature unknown; restored from __doc__
  219.         """ x.__sub__(y) <==> x-y """
  220.         pass
  221.  
  222.     def __truediv__(self, y): # real signature unknown; restored from __doc__
  223.         """ x.__truediv__(y) <==> x/y """
  224.         pass
  225.  
  226.     def __trunc__(self, *args, **kwargs): # real signature unknown
  227.         """ Truncating an Integral returns itself. """
  228.         pass
  229.  
  230.     def __xor__(self, y): # real signature unknown; restored from __doc__
  231.         """ x.__xor__(y) <==> x^y """
  232.         pass
  233.  
  234.     denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  235.     """the denominator of a rational number in lowest terms"""
  236.  
  237.     imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  238.     """the imaginary part of a complex number"""
  239.  
  240.     numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  241.     """the numerator of a rational number in lowest terms"""
  242.  
  243.     real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  244.     """the real part of a complex number"""
  245.  
  246. long

long

/布尔值/

真或假
1 或 0

/float浮点型/

如：3.14、2.88

每个浮点型都具备如下功能：

  1. class float(object):
  2.     """
  3.     float(x) -> floating point number
  4.  
  5.     Convert a string or number to a floating point number, if possible.
  6.     """
  7.     def as_integer_ratio(self):
  8.         """ 获取改值的最简比 """
  9.         """
  10.         float.as_integer_ratio() -> (int, int)
  11.  
  12.         Return a pair of integers, whose ratio is exactly equal to the original
  13.         float and with a positive denominator.
  14.         Raise OverflowError on infinities and a ValueError on NaNs.
  15.  
  16.         >>> (10.0).as_integer_ratio()
  17.         (10, 1)
  18.         >>> (0.0).as_integer_ratio()
  19.         (0, 1)
  20.         >>> (-.25).as_integer_ratio()
  21.         (-1, 4)
  22.         """
  23.         pass
  24.  
  25.     def conjugate(self, *args, **kwargs): # real signature unknown
  26.         """ Return self, the complex conjugate of any float. """
  27.         pass
  28.  
  29.     def fromhex(self, string):
  30.         """ 将十六进制字符串转换成浮点型 """
  31.         """
  32.         float.fromhex(string) -> float
  33.  
  34.         Create a floating-point number from a hexadecimal string.
  35.         >>> float.fromhex('0x1.ffffp10')
  36.         2047.984375
  37.         >>> float.fromhex('-0x1p-1074')
  38.         -4.9406564584124654e-324
  39.         """
  40.         return 0.0
  41.  
  42.     def hex(self):
  43.         """ 返回当前值的 16 进制表示 """
  44.         """
  45.         float.hex() -> string
  46.  
  47.         Return a hexadecimal representation of a floating-point number.
  48.         >>> (-0.1).hex()
  49.         '-0x1.999999999999ap-4'
  50.         >>> 3.14159.hex()
  51.         '0x1.921f9f01b866ep+1'
  52.         """
  53.         return ""
  54.  
  55.     def is_integer(self, *args, **kwargs): # real signature unknown
  56.         """ Return True if the float is an integer. """
  57.         pass
  58.  
  59.     def __abs__(self):
  60.         """ x.__abs__() <==> abs(x) """
  61.         pass
  62.  
  63.     def __add__(self, y):
  64.         """ x.__add__(y) <==> x+y """
  65.         pass
  66.  
  67.     def __coerce__(self, y):
  68.         """ x.__coerce__(y) <==> coerce(x, y) """
  69.         pass
  70.  
  71.     def __divmod__(self, y):
  72.         """ x.__divmod__(y) <==> divmod(x, y) """
  73.         pass
  74.  
  75.     def __div__(self, y):
  76.         """ x.__div__(y) <==> x/y """
  77.         pass
  78.  
  79.     def __eq__(self, y):
  80.         """ x.__eq__(y) <==> x==y """
  81.         pass
  82.  
  83.     def __float__(self):
  84.         """ x.__float__() <==> float(x) """
  85.         pass
  86.  
  87.     def __floordiv__(self, y):
  88.         """ x.__floordiv__(y) <==> x//y """
  89.         pass
  90.  
  91.     def __format__(self, format_spec):
  92.         """
  93.         float.__format__(format_spec) -> string
  94.  
  95.         Formats the float according to format_spec.
  96.         """
  97.         return ""
  98.  
  99.     def __getattribute__(self, name):
  100.         """ x.__getattribute__('name') <==> x.name """
  101.         pass
  102.  
  103.     def __getformat__(self, typestr):
  104.         """
  105.         float.__getformat__(typestr) -> string
  106.  
  107.         You probably don't want to use this function.  It exists mainly to be
  108.         used in Python's test suite.
  109.  
  110.         typestr must be 'double' or 'float'.  This function returns whichever of
  111.         'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
  112.         format of floating point numbers used by the C type named by typestr.
  113.         """
  114.         return ""
  115.  
  116.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  117.         pass
  118.  
  119.     def __ge__(self, y):
  120.         """ x.__ge__(y) <==> x>=y """
  121.         pass
  122.  
  123.     def __gt__(self, y):
  124.         """ x.__gt__(y) <==> x>y """
  125.         pass
  126.  
  127.     def __hash__(self):
  128.         """ x.__hash__() <==> hash(x) """
  129.         pass
  130.  
  131.     def __init__(self, x):
  132.         pass
  133.  
  134.     def __int__(self):
  135.         """ x.__int__() <==> int(x) """
  136.         pass
  137.  
  138.     def __le__(self, y):
  139.         """ x.__le__(y) <==> x<=y """
  140.         pass
  141.  
  142.     def __long__(self):
  143.         """ x.__long__() <==> long(x) """
  144.         pass
  145.  
  146.     def __lt__(self, y):
  147.         """ x.__lt__(y) <==> x<y """
  148.         pass
  149.  
  150.     def __mod__(self, y):
  151.         """ x.__mod__(y) <==> x%y """
  152.         pass
  153.  
  154.     def __mul__(self, y):
  155.         """ x.__mul__(y) <==> x*y """
  156.         pass
  157.  
  158.     def __neg__(self):
  159.         """ x.__neg__() <==> -x """
  160.         pass
  161.  
  162.     @staticmethod # known case of __new__
  163.     def __new__(S, *more):
  164.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  165.         pass
  166.  
  167.     def __ne__(self, y):
  168.         """ x.__ne__(y) <==> x!=y """
  169.         pass
  170.  
  171.     def __nonzero__(self):
  172.         """ x.__nonzero__() <==> x != 0 """
  173.         pass
  174.  
  175.     def __pos__(self):
  176.         """ x.__pos__() <==> +x """
  177.         pass
  178.  
  179.     def __pow__(self, y, z=None):
  180.         """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
  181.         pass
  182.  
  183.     def __radd__(self, y):
  184.         """ x.__radd__(y) <==> y+x """
  185.         pass
  186.  
  187.     def __rdivmod__(self, y):
  188.         """ x.__rdivmod__(y) <==> divmod(y, x) """
  189.         pass
  190.  
  191.     def __rdiv__(self, y):
  192.         """ x.__rdiv__(y) <==> y/x """
  193.         pass
  194.  
  195.     def __repr__(self):
  196.         """ x.__repr__() <==> repr(x) """
  197.         pass
  198.  
  199.     def __rfloordiv__(self, y):
  200.         """ x.__rfloordiv__(y) <==> y//x """
  201.         pass
  202.  
  203.     def __rmod__(self, y):
  204.         """ x.__rmod__(y) <==> y%x """
  205.         pass
  206.  
  207.     def __rmul__(self, y):
  208.         """ x.__rmul__(y) <==> y*x """
  209.         pass
  210.  
  211.     def __rpow__(self, x, z=None):
  212.         """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
  213.         pass
  214.  
  215.     def __rsub__(self, y):
  216.         """ x.__rsub__(y) <==> y-x """
  217.         pass
  218.  
  219.     def __rtruediv__(self, y):
  220.         """ x.__rtruediv__(y) <==> y/x """
  221.         pass
  222.  
  223.     def __setformat__(self, typestr, fmt):
  224.         """
  225.         float.__setformat__(typestr, fmt) -> None
  226.  
  227.         You probably don't want to use this function.  It exists mainly to be
  228.         used in Python's test suite.
  229.  
  230.         typestr must be 'double' or 'float'.  fmt must be one of 'unknown',
  231.         'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
  232.         one of the latter two if it appears to match the underlying C reality.
  233.  
  234.         Override the automatic determination of C-level floating point type.
  235.         This affects how floats are converted to and from binary strings.
  236.         """
  237.         pass
  238.  
  239.     def __str__(self):
  240.         """ x.__str__() <==> str(x) """
  241.         pass
  242.  
  243.     def __sub__(self, y):
  244.         """ x.__sub__(y) <==> x-y """
  245.         pass
  246.  
  247.     def __truediv__(self, y):
  248.         """ x.__truediv__(y) <==> x/y """
  249.         pass
  250.  
  251.     def __trunc__(self, *args, **kwargs): # real signature unknown
  252.         """ Return the Integral closest to x between 0 and x. """
  253.         pass
  254.  
  255.     imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  256.     """the imaginary part of a complex number"""
  257.  
  258.     real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  259.     """the real part of a complex number"""
  260.  
  261. float

float

/str字符串/

如：'tiannan'、'alex'

每个字符串都具备如下功能：

  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):
  9.         """ 首字母变大写 """
  10.         """
  11.         S.capitalize() -> string
  12.  
  13.         Return a copy of the string S with only its first character
  14.         capitalized.
  15.         """
  16.         return ""
  17.  
  18.     def center(self, width, fillchar=None):
  19.         """ 内容居中，width：总长度；fillchar：空白处填充内容，默认无 """
  20.         """
  21.         S.center(width[, fillchar]) -> string
  22.  
  23.         Return S centered in a string of length width. Padding is
  24.         done using the specified fill character (default is a space)
  25.         """
  26.         return ""
  27.  
  28.     def count(self, sub, start=None, end=None):
  29.         """ 子序列个数 """
  30.         """
  31.         S.count(sub[, start[, end]]) -> int
  32.  
  33.         Return the number of non-overlapping occurrences of substring sub in
  34.         string S[start:end].  Optional arguments start and end are interpreted
  35.         as in slice notation.
  36.         """
  37.         return 0
  38.  
  39.     def decode(self, encoding=None, errors=None):
  40.         """ 解码 """
  41.         """
  42.         S.decode([encoding[,errors]]) -> object
  43.  
  44.         Decodes S using the codec registered for encoding. encoding defaults
  45.         to the default encoding. errors may be given to set a different error
  46.         handling scheme. Default is 'strict' meaning that encoding errors raise
  47.         a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
  48.         as well as any other name registered with codecs.register_error that is
  49.         able to handle UnicodeDecodeErrors.
  50.         """
  51.         return object()
  52.  
  53.     def encode(self, encoding=None, errors=None):
  54.         """ 编码，针对unicode """
  55.         """
  56.         S.encode([encoding[,errors]]) -> object
  57.  
  58.         Encodes S using the codec registered for encoding. encoding defaults
  59.         to the default encoding. errors may be given to set a different error
  60.         handling scheme. Default is 'strict' meaning that encoding errors raise
  61.         a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
  62.         'xmlcharrefreplace' as well as any other name registered with
  63.         codecs.register_error that is able to handle UnicodeEncodeErrors.
  64.         """
  65.         return object()
  66.  
  67.     def endswith(self, suffix, start=None, end=None):
  68.         """ 是否以 xxx 结束 """
  69.         """
  70.         S.endswith(suffix[, start[, end]]) -> bool
  71.  
  72.         Return True if S ends with the specified suffix, False otherwise.
  73.         With optional start, test S beginning at that position.
  74.         With optional end, stop comparing S at that position.
  75.         suffix can also be a tuple of strings to try.
  76.         """
  77.         return False
  78.  
  79.     def expandtabs(self, tabsize=None):
  80.         """ 将tab转换成空格，默认一个tab转换成8个空格 """
  81.         """
  82.         S.expandtabs([tabsize]) -> string
  83.  
  84.         Return a copy of S where all tab characters are expanded using spaces.
  85.         If tabsize is not given, a tab size of 8 characters is assumed.
  86.         """
  87.         return ""
  88.  
  89.     def find(self, sub, start=None, end=None):
  90.         """ 寻找子序列位置，如果没找到，返回 -1 """
  91.         """
  92.         S.find(sub [,start [,end]]) -> int
  93.  
  94.         Return the lowest index in S where substring sub is found,
  95.         such that sub is contained within S[start:end].  Optional
  96.         arguments start and end are interpreted as in slice notation.
  97.  
  98.         Return -1 on failure.
  99.         """
  100.         return 0
  101.  
  102.     def format(*args, **kwargs): # known special case of str.format
  103.         """ 字符串格式化，动态参数，将函数式编程时细说 """
  104.         """
  105.         S.format(*args, **kwargs) -> string
  106.  
  107.         Return a formatted version of S, using substitutions from args and kwargs.
  108.         The substitutions are identified by braces ('{' and '}').
  109.         """
  110.         pass
  111.  
  112.     def index(self, sub, start=None, end=None):
  113.         """ 子序列位置，如果没找到，报错 """
  114.         S.index(sub [,start [,end]]) -> int
  115.  
  116.         Like S.find() but raise ValueError when the substring is not found.
  117.         """
  118.         return 0
  119.  
  120.     def isalnum(self):
  121.         """ 是否是字母和数字 """
  122.         """
  123.         S.isalnum() -> bool
  124.  
  125.         Return True if all characters in S are alphanumeric
  126.         and there is at least one character in S, False otherwise.
  127.         """
  128.         return False
  129.  
  130.     def isalpha(self):
  131.         """ 是否是字母 """
  132.         """
  133.         S.isalpha() -> bool
  134.  
  135.         Return True if all characters in S are alphabetic
  136.         and there is at least one character in S, False otherwise.
  137.         """
  138.         return False
  139.  
  140.     def isdigit(self):
  141.         """ 是否是数字 """
  142.         """
  143.         S.isdigit() -> bool
  144.  
  145.         Return True if all characters in S are digits
  146.         and there is at least one character in S, False otherwise.
  147.         """
  148.         return False
  149.  
  150.     def islower(self):
  151.         """ 是否小写 """
  152.         """
  153.         S.islower() -> bool
  154.  
  155.         Return True if all cased characters in S are lowercase and there is
  156.         at least one cased character in S, False otherwise.
  157.         """
  158.         return False
  159.  
  160.     def isspace(self):
  161.         """
  162.         S.isspace() -> bool
  163.  
  164.         Return True if all characters in S are whitespace
  165.         and there is at least one character in S, False otherwise.
  166.         """
  167.         return False
  168.  
  169.     def istitle(self):
  170.         """
  171.         S.istitle() -> bool
  172.  
  173.         Return True if S is a titlecased string and there is at least one
  174.         character in S, i.e. uppercase characters may only follow uncased
  175.         characters and lowercase characters only cased ones. Return False
  176.         otherwise.
  177.         """
  178.         return False
  179.  
  180.     def isupper(self):
  181.         """
  182.         S.isupper() -> bool
  183.  
  184.         Return True if all cased characters in S are uppercase and there is
  185.         at least one cased character in S, False otherwise.
  186.         """
  187.         return False
  188.  
  189.     def join(self, iterable):
  190.         """ 连接 """
  191.         """
  192.         S.join(iterable) -> string
  193.  
  194.         Return a string which is the concatenation of the strings in the
  195.         iterable.  The separator between elements is S.
  196.         """
  197.         return ""
  198.  
  199.     def ljust(self, width, fillchar=None):
  200.         """ 内容左对齐，右侧填充 """
  201.         """
  202.         S.ljust(width[, fillchar]) -> string
  203.  
  204.         Return S left-justified in a string of length width. Padding is
  205.         done using the specified fill character (default is a space).
  206.         """
  207.         return ""
  208.  
  209.     def lower(self):
  210.         """ 变小写 """
  211.         """
  212.         S.lower() -> string
  213.  
  214.         Return a copy of the string S converted to lowercase.
  215.         """
  216.         return ""
  217.  
  218.     def lstrip(self, chars=None):
  219.         """ 移除左侧空白 """
  220.         """
  221.         S.lstrip([chars]) -> string or unicode
  222.  
  223.         Return a copy of the string S with leading whitespace removed.
  224.         If chars is given and not None, remove characters in chars instead.
  225.         If chars is unicode, S will be converted to unicode before stripping
  226.         """
  227.         return ""
  228.  
  229.     def partition(self, sep):
  230.         """ 分割，前，中，后三部分 """
  231.         """
  232.         S.partition(sep) -> (head, sep, tail)
  233.  
  234.         Search for the separator sep in S, and return the part before it,
  235.         the separator itself, and the part after it.  If the separator is not
  236.         found, return S and two empty strings.
  237.         """
  238.         pass
  239.  
  240.     def replace(self, old, new, count=None):
  241.         """ 替换 """
  242.         """
  243.         S.replace(old, new[, count]) -> string
  244.  
  245.         Return a copy of string S with all occurrences of substring
  246.         old replaced by new.  If the optional argument count is
  247.         given, only the first count occurrences are replaced.
  248.         """
  249.         return ""
  250.  
  251.     def rfind(self, sub, start=None, end=None):
  252.         """
  253.         S.rfind(sub [,start [,end]]) -> int
  254.  
  255.         Return the highest index in S where substring sub is found,
  256.         such that sub is contained within S[start:end].  Optional
  257.         arguments start and end are interpreted as in slice notation.
  258.  
  259.         Return -1 on failure.
  260.         """
  261.         return 0
  262.  
  263.     def rindex(self, sub, start=None, end=None):
  264.         """
  265.         S.rindex(sub [,start [,end]]) -> int
  266.  
  267.         Like S.rfind() but raise ValueError when the substring is not found.
  268.         """
  269.         return 0
  270.  
  271.     def rjust(self, width, fillchar=None):
  272.         """
  273.         S.rjust(width[, fillchar]) -> string
  274.  
  275.         Return S right-justified in a string of length width. Padding is
  276.         done using the specified fill character (default is a space)
  277.         """
  278.         return ""
  279.  
  280.     def rpartition(self, sep):
  281.         """
  282.         S.rpartition(sep) -> (head, sep, tail)
  283.  
  284.         Search for the separator sep in S, starting at the end of S, and return
  285.         the part before it, the separator itself, and the part after it.  If the
  286.         separator is not found, return two empty strings and S.
  287.         """
  288.         pass
  289.  
  290.     def rsplit(self, sep=None, maxsplit=None):
  291.         """
  292.         S.rsplit([sep [,maxsplit]]) -> list of strings
  293.  
  294.         Return a list of the words in the string S, using sep as the
  295.         delimiter string, starting at the end of the string and working
  296.         to the front.  If maxsplit is given, at most maxsplit splits are
  297.         done. If sep is not specified or is None, any whitespace string
  298.         is a separator.
  299.         """
  300.         return []
  301.  
  302.     def rstrip(self, chars=None):
  303.         """
  304.         S.rstrip([chars]) -> string or unicode
  305.  
  306.         Return a copy of the string S with trailing whitespace removed.
  307.         If chars is given and not None, remove characters in chars instead.
  308.         If chars is unicode, S will be converted to unicode before stripping
  309.         """
  310.         return ""
  311.  
  312.     def split(self, sep=None, maxsplit=None):
  313.         """ 分割， maxsplit最多分割几次 """
  314.         """
  315.         S.split([sep [,maxsplit]]) -> list of strings
  316.  
  317.         Return a list of the words in the string S, using sep as the
  318.         delimiter string.  If maxsplit is given, at most maxsplit
  319.         splits are done. If sep is not specified or is None, any
  320.         whitespace string is a separator and empty strings are removed
  321.         from the result.
  322.         """
  323.         return []
  324.  
  325.     def splitlines(self, keepends=False):
  326.         """ 根据换行分割 """
  327.         """
  328.         S.splitlines(keepends=False) -> list of strings
  329.  
  330.         Return a list of the lines in S, breaking at line boundaries.
  331.         Line breaks are not included in the resulting list unless keepends
  332.         is given and true.
  333.         """
  334.         return []
  335.  
  336.     def startswith(self, prefix, start=None, end=None):
  337.         """ 是否起始 """
  338.         """
  339.         S.startswith(prefix[, start[, end]]) -> bool
  340.  
  341.         Return True if S starts with the specified prefix, False otherwise.
  342.         With optional start, test S beginning at that position.
  343.         With optional end, stop comparing S at that position.
  344.         prefix can also be a tuple of strings to try.
  345.         """
  346.         return False
  347.  
  348.     def strip(self, chars=None):
  349.         """ 移除两段空白 """
  350.         """
  351.         S.strip([chars]) -> string or unicode
  352.  
  353.         Return a copy of the string S with leading and trailing
  354.         whitespace removed.
  355.         If chars is given and not None, remove characters in chars instead.
  356.         If chars is unicode, S will be converted to unicode before stripping
  357.         """
  358.         return ""
  359.  
  360.     def swapcase(self):
  361.         """ 大写变小写，小写变大写 """
  362.         """
  363.         S.swapcase() -> string
  364.  
  365.         Return a copy of the string S with uppercase characters
  366.         converted to lowercase and vice versa.
  367.         """
  368.         return ""
  369.  
  370.     def title(self):
  371.         """
  372.         S.title() -> string
  373.  
  374.         Return a titlecased version of S, i.e. words start with uppercase
  375.         characters, all remaining cased characters have lowercase.
  376.         """
  377.         return ""
  378.  
  379.     def translate(self, table, deletechars=None):
  380.         """
  381.         转换，需要先做一个对应表，最后一个表示删除字符集合
  382.         intab = "aeiou"
  383.         outtab = ""
  384.         trantab = maketrans(intab, outtab)
  385.         str = "this is string example....wow!!!"
  386.         print str.translate(trantab, 'xm')
  387.         """
  388.  
  389.         """
  390.         S.translate(table [,deletechars]) -> string
  391.  
  392.         Return a copy of the string S, where all characters occurring
  393.         in the optional argument deletechars are removed, and the
  394.         remaining characters have been mapped through the given
  395.         translation table, which must be a string of length 256 or None.
  396.         If the table argument is None, no translation is applied and
  397.         the operation simply removes the characters in deletechars.
  398.         """
  399.         return ""
  400.  
  401.     def upper(self):
  402.         """
  403.         S.upper() -> string
  404.  
  405.         Return a copy of the string S converted to uppercase.
  406.         """
  407.         return ""
  408.  
  409.     def zfill(self, width):
  410.         """方法返回指定长度的字符串，原字符串右对齐，前面填充0。"""
  411.         """
  412.         S.zfill(width) -> string
  413.  
  414.         Pad a numeric string S with zeros on the left, to fill a field
  415.         of the specified width.  The string S is never truncated.
  416.         """
  417.         return ""
  418.  
  419.     def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown
  420.         pass
  421.  
  422.     def _formatter_parser(self, *args, **kwargs): # real signature unknown
  423.         pass
  424.  
  425.     def __add__(self, y):
  426.         """ x.__add__(y) <==> x+y """
  427.         pass
  428.  
  429.     def __contains__(self, y):
  430.         """ x.__contains__(y) <==> y in x """
  431.         pass
  432.  
  433.     def __eq__(self, y):
  434.         """ x.__eq__(y) <==> x==y """
  435.         pass
  436.  
  437.     def __format__(self, format_spec):
  438.         """
  439.         S.__format__(format_spec) -> string
  440.  
  441.         Return a formatted version of S as described by format_spec.
  442.         """
  443.         return ""
  444.  
  445.     def __getattribute__(self, name):
  446.         """ x.__getattribute__('name') <==> x.name """
  447.         pass
  448.  
  449.     def __getitem__(self, y):
  450.         """ x.__getitem__(y) <==> x[y] """
  451.         pass
  452.  
  453.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  454.         pass
  455.  
  456.     def __getslice__(self, i, j):
  457.         """
  458.         x.__getslice__(i, j) <==> x[i:j]
  459.  
  460.                    Use of negative indices is not supported.
  461.         """
  462.         pass
  463.  
  464.     def __ge__(self, y):
  465.         """ x.__ge__(y) <==> x>=y """
  466.         pass
  467.  
  468.     def __gt__(self, y):
  469.         """ x.__gt__(y) <==> x>y """
  470.         pass
  471.  
  472.     def __hash__(self):
  473.         """ x.__hash__() <==> hash(x) """
  474.         pass
  475.  
  476.     def __init__(self, string=''): # known special case of str.__init__
  477.         """
  478.         str(object='') -> string
  479.  
  480.         Return a nice string representation of the object.
  481.         If the argument is a string, the return value is the same object.
  482.         # (copied from class doc)
  483.         """
  484.         pass
  485.  
  486.     def __len__(self):
  487.         """ x.__len__() <==> len(x) """
  488.         pass
  489.  
  490.     def __le__(self, y):
  491.         """ x.__le__(y) <==> x<=y """
  492.         pass
  493.  
  494.     def __lt__(self, y):
  495.         """ x.__lt__(y) <==> x<y """
  496.         pass
  497.  
  498.     def __mod__(self, y):
  499.         """ x.__mod__(y) <==> x%y """
  500.         pass
  501.  
  502.     def __mul__(self, n):
  503.         """ x.__mul__(n) <==> x*n """
  504.         pass
  505.  
  506.     @staticmethod # known case of __new__
  507.     def __new__(S, *more):
  508.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  509.         pass
  510.  
  511.     def __ne__(self, y):
  512.         """ x.__ne__(y) <==> x!=y """
  513.         pass
  514.  
  515.     def __repr__(self):
  516.         """ x.__repr__() <==> repr(x) """
  517.         pass
  518.  
  519.     def __rmod__(self, y):
  520.         """ x.__rmod__(y) <==> y%x """
  521.         pass
  522.  
  523.     def __rmul__(self, n):
  524.         """ x.__rmul__(n) <==> n*x """
  525.         pass
  526.  
  527.     def __sizeof__(self):
  528.         """ S.__sizeof__() -> size of S in memory, in bytes """
  529.         pass
  530.  
  531.     def __str__(self):
  532.         """ x.__str__() <==> str(x) """
  533.         pass
  534.  
  535. str
  536.  
  537. str

str

注：编码；字符串的乘法；字符串和格式化

/list列表/

如：[11,22,33]、['tiannan', 'alex']

每个列表都具备如下功能：

  1. class list(object):
  2.     """
  3.     list() -> new empty list
  4.     list(iterable) -> new list initialized from iterable's items
  5.     """
  6.     def append(self, p_object): # real signature unknown; restored from __doc__
  7.         """ L.append(object) -- append object to end """
  8.         pass
  9.  
  10.     def count(self, value): # real signature unknown; restored from __doc__
  11.         """ L.count(value) -> integer -- return number of occurrences of value """
  12.         return 0
  13.  
  14.     def extend(self, iterable): # real signature unknown; restored from __doc__
  15.         """ L.extend(iterable) -- extend list by appending elements from the iterable """
  16.         pass
  17.  
  18.     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
  19.         """
  20.         L.index(value, [start, [stop]]) -> integer -- return first index of value.
  21.         Raises ValueError if the value is not present.
  22.         """
  23.         return 0
  24.  
  25.     def insert(self, index, p_object): # real signature unknown; restored from __doc__
  26.         """ L.insert(index, object) -- insert object before index """
  27.         pass
  28.  
  29.     def pop(self, index=None): # real signature unknown; restored from __doc__
  30.         """
  31.         L.pop([index]) -> item -- remove and return item at index (default last).
  32.         Raises IndexError if list is empty or index is out of range.
  33.         """
  34.         pass
  35.  
  36.     def remove(self, value): # real signature unknown; restored from __doc__
  37.         """
  38.         L.remove(value) -- remove first occurrence of value.
  39.         Raises ValueError if the value is not present.
  40.         """
  41.         pass
  42.  
  43.     def reverse(self): # real signature unknown; restored from __doc__
  44.         """ L.reverse() -- reverse *IN PLACE* """
  45.         pass
  46.  
  47.     def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__
  48.         """
  49.         L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
  50.         cmp(x, y) -> -1, 0, 1
  51.         """
  52.         pass
  53.  
  54.     def __add__(self, y): # real signature unknown; restored from __doc__
  55.         """ x.__add__(y) <==> x+y """
  56.         pass
  57.  
  58.     def __contains__(self, y): # real signature unknown; restored from __doc__
  59.         """ x.__contains__(y) <==> y in x """
  60.         pass
  61.  
  62.     def __delitem__(self, y): # real signature unknown; restored from __doc__
  63.         """ x.__delitem__(y) <==> del x[y] """
  64.         pass
  65.  
  66.     def __delslice__(self, i, j): # real signature unknown; restored from __doc__
  67.         """
  68.         x.__delslice__(i, j) <==> del x[i:j]
  69.  
  70.                    Use of negative indices is not supported.
  71.         """
  72.         pass
  73.  
  74.     def __eq__(self, y): # real signature unknown; restored from __doc__
  75.         """ x.__eq__(y) <==> x==y """
  76.         pass
  77.  
  78.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  79.         """ x.__getattribute__('name') <==> x.name """
  80.         pass
  81.  
  82.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  83.         """ x.__getitem__(y) <==> x[y] """
  84.         pass
  85.  
  86.     def __getslice__(self, i, j): # real signature unknown; restored from __doc__
  87.         """
  88.         x.__getslice__(i, j) <==> x[i:j]
  89.  
  90.                    Use of negative indices is not supported.
  91.         """
  92.         pass
  93.  
  94.     def __ge__(self, y): # real signature unknown; restored from __doc__
  95.         """ x.__ge__(y) <==> x>=y """
  96.         pass
  97.  
  98.     def __gt__(self, y): # real signature unknown; restored from __doc__
  99.         """ x.__gt__(y) <==> x>y """
  100.         pass
  101.  
  102.     def __iadd__(self, y): # real signature unknown; restored from __doc__
  103.         """ x.__iadd__(y) <==> x+=y """
  104.         pass
  105.  
  106.     def __imul__(self, y): # real signature unknown; restored from __doc__
  107.         """ x.__imul__(y) <==> x*=y """
  108.         pass
  109.  
  110.     def __init__(self, seq=()): # known special case of list.__init__
  111.         """
  112.         list() -> new empty list
  113.         list(iterable) -> new list initialized from iterable's items
  114.         # (copied from class doc)
  115.         """
  116.         pass
  117.  
  118.     def __iter__(self): # real signature unknown; restored from __doc__
  119.         """ x.__iter__() <==> iter(x) """
  120.         pass
  121.  
  122.     def __len__(self): # real signature unknown; restored from __doc__
  123.         """ x.__len__() <==> len(x) """
  124.         pass
  125.  
  126.     def __le__(self, y): # real signature unknown; restored from __doc__
  127.         """ x.__le__(y) <==> x<=y """
  128.         pass
  129.  
  130.     def __lt__(self, y): # real signature unknown; restored from __doc__
  131.         """ x.__lt__(y) <==> x<y """
  132.         pass
  133.  
  134.     def __mul__(self, n): # real signature unknown; restored from __doc__
  135.         """ x.__mul__(n) <==> x*n """
  136.         pass
  137.  
  138.     @staticmethod # known case of __new__
  139.     def __new__(S, *more): # real signature unknown; restored from __doc__
  140.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  141.         pass
  142.  
  143.     def __ne__(self, y): # real signature unknown; restored from __doc__
  144.         """ x.__ne__(y) <==> x!=y """
  145.         pass
  146.  
  147.     def __repr__(self): # real signature unknown; restored from __doc__
  148.         """ x.__repr__() <==> repr(x) """
  149.         pass
  150.  
  151.     def __reversed__(self): # real signature unknown; restored from __doc__
  152.         """ L.__reversed__() -- return a reverse iterator over the list """
  153.         pass
  154.  
  155.     def __rmul__(self, n): # real signature unknown; restored from __doc__
  156.         """ x.__rmul__(n) <==> n*x """
  157.         pass
  158.  
  159.     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
  160.         """ x.__setitem__(i, y) <==> x[i]=y """
  161.         pass
  162.  
  163.     def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
  164.         """
  165.         x.__setslice__(i, j, y) <==> x[i:j]=y
  166.  
  167.                    Use  of negative indices is not supported.
  168.         """
  169.         pass
  170.  
  171.     def __sizeof__(self): # real signature unknown; restored from __doc__
  172.         """ L.__sizeof__() -- size of L in memory, in bytes """
  173.         pass
  174.  
  175.     __hash__ = None
  176.  
  177. list

list

注：排序；

/tuple元组/

如：(11,22,33)、('tiannan', 'alex')

每个元组都具备如下功能：

  1. class tuple(object):
  2.     """
  3.     tuple() -> empty tuple
  4.     tuple(iterable) -> tuple initialized from iterable's items
  5.  
  6.     If the argument is a tuple, the return value is the same object.
  7.     """
  8.     def count(self, value): # real signature unknown; restored from __doc__
  9.         """ T.count(value) -> integer -- return number of occurrences of value """
  10.         return 0
  11.  
  12.     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
  13.         """
  14.         T.index(value, [start, [stop]]) -> integer -- return first index of value.
  15.         Raises ValueError if the value is not present.
  16.         """
  17.         return 0
  18.  
  19.     def __add__(self, y): # real signature unknown; restored from __doc__
  20.         """ x.__add__(y) <==> x+y """
  21.         pass
  22.  
  23.     def __contains__(self, y): # real signature unknown; restored from __doc__
  24.         """ x.__contains__(y) <==> y in x """
  25.         pass
  26.  
  27.     def __eq__(self, y): # real signature unknown; restored from __doc__
  28.         """ x.__eq__(y) <==> x==y """
  29.         pass
  30.  
  31.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  32.         """ x.__getattribute__('name') <==> x.name """
  33.         pass
  34.  
  35.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  36.         """ x.__getitem__(y) <==> x[y] """
  37.         pass
  38.  
  39.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  40.         pass
  41.  
  42.     def __getslice__(self, i, j): # real signature unknown; restored from __doc__
  43.         """
  44.         x.__getslice__(i, j) <==> x[i:j]
  45.  
  46.                    Use of negative indices is not supported.
  47.         """
  48.         pass
  49.  
  50.     def __ge__(self, y): # real signature unknown; restored from __doc__
  51.         """ x.__ge__(y) <==> x>=y """
  52.         pass
  53.  
  54.     def __gt__(self, y): # real signature unknown; restored from __doc__
  55.         """ x.__gt__(y) <==> x>y """
  56.         pass
  57.  
  58.     def __hash__(self): # real signature unknown; restored from __doc__
  59.         """ x.__hash__() <==> hash(x) """
  60.         pass
  61.  
  62.     def __init__(self, seq=()): # known special case of tuple.__init__
  63.         """
  64.         tuple() -> empty tuple
  65.         tuple(iterable) -> tuple initialized from iterable's items
  66.  
  67.         If the argument is a tuple, the return value is the same object.
  68.         # (copied from class doc)
  69.         """
  70.         pass
  71.  
  72.     def __iter__(self): # real signature unknown; restored from __doc__
  73.         """ x.__iter__() <==> iter(x) """
  74.         pass
  75.  
  76.     def __len__(self): # real signature unknown; restored from __doc__
  77.         """ x.__len__() <==> len(x) """
  78.         pass
  79.  
  80.     def __le__(self, y): # real signature unknown; restored from __doc__
  81.         """ x.__le__(y) <==> x<=y """
  82.         pass
  83.  
  84.     def __lt__(self, y): # real signature unknown; restored from __doc__
  85.         """ x.__lt__(y) <==> x<y """
  86.         pass
  87.  
  88.     def __mul__(self, n): # real signature unknown; restored from __doc__
  89.         """ x.__mul__(n) <==> x*n """
  90.         pass
  91.  
  92.     @staticmethod # known case of __new__
  93.     def __new__(S, *more): # real signature unknown; restored from __doc__
  94.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  95.         pass
  96.  
  97.     def __ne__(self, y): # real signature unknown; restored from __doc__
  98.         """ x.__ne__(y) <==> x!=y """
  99.         pass
  100.  
  101.     def __repr__(self): # real signature unknown; restored from __doc__
  102.         """ x.__repr__() <==> repr(x) """
  103.         pass
  104.  
  105.     def __rmul__(self, n): # real signature unknown; restored from __doc__
  106.         """ x.__rmul__(n) <==> n*x """
  107.         pass
  108.  
  109.     def __sizeof__(self): # real signature unknown; restored from __doc__
  110.         """ T.__sizeof__() -- size of T in memory, in bytes """
  111.         pass
  112.  
  113. tuple

tuple

/dict字典/

如：{'name': 'tiannan', 'age': 18} 、{'host': '2.2.2.2', 'port': 80]}

ps：循环时，默认循环key

每个字典都具备如下功能：

  1. class dict(object):
  2.     """
  3.     dict() -> new empty dictionary
  4.     dict(mapping) -> new dictionary initialized from a mapping object's
  5.         (key, value) pairs
  6.     dict(iterable) -> new dictionary initialized as if via:
  7.         d = {}
  8.         for k, v in iterable:
  9.             d[k] = v
  10.     dict(**kwargs) -> new dictionary initialized with the name=value pairs
  11.         in the keyword argument list.  For example:  dict(one=1, two=2)
  12.     """
  13.  
  14.     def clear(self): # real signature unknown; restored from __doc__
  15.         """ 清除内容 """
  16.         """ D.clear() -> None.  Remove all items from D. """
  17.         pass
  18.  
  19.     def copy(self): # real signature unknown; restored from __doc__
  20.         """ 浅拷贝 """
  21.         """ D.copy() -> a shallow copy of D """
  22.         pass
  23.  
  24.     @staticmethod # known case
  25.     def fromkeys(S, v=None): # real signature unknown; restored from __doc__
  26.         """
  27.         dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
  28.         v defaults to None.
  29.         """
  30.         pass
  31.  
  32.     def get(self, k, d=None): # real signature unknown; restored from __doc__
  33.         """ 根据key获取值，d是默认值 """
  34.         """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
  35.         pass
  36.  
  37.     def has_key(self, k): # real signature unknown; restored from __doc__
  38.         """ 是否有key """
  39.         """ D.has_key(k) -> True if D has a key k, else False """
  40.         return False
  41.  
  42.     def items(self): # real signature unknown; restored from __doc__
  43.         """ 所有项的列表形式 """
  44.         """ D.items() -> list of D's (key, value) pairs, as 2-tuples """
  45.         return []
  46.  
  47.     def iteritems(self): # real signature unknown; restored from __doc__
  48.         """ 项可迭代 """
  49.         """ D.iteritems() -> an iterator over the (key, value) items of D """
  50.         pass
  51.  
  52.     def iterkeys(self): # real signature unknown; restored from __doc__
  53.         """ key可迭代 """
  54.         """ D.iterkeys() -> an iterator over the keys of D """
  55.         pass
  56.  
  57.     def itervalues(self): # real signature unknown; restored from __doc__
  58.         """ value可迭代 """
  59.         """ D.itervalues() -> an iterator over the values of D """
  60.         pass
  61.  
  62.     def keys(self): # real signature unknown; restored from __doc__
  63.         """ 所有的key列表 """
  64.         """ D.keys() -> list of D's keys """
  65.         return []
  66.  
  67.     def pop(self, k, d=None): # real signature unknown; restored from __doc__
  68.         """ 获取并在字典中移除 """
  69.         """
  70.         D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
  71.         If key is not found, d is returned if given, otherwise KeyError is raised
  72.         """
  73.         pass
  74.  
  75.     def popitem(self): # real signature unknown; restored from __doc__
  76.         """ 获取并在字典中移除 """
  77.         """
  78.         D.popitem() -> (k, v), remove and return some (key, value) pair as a
  79.         2-tuple; but raise KeyError if D is empty.
  80.         """
  81.         pass
  82.  
  83.     def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
  84.         """ 如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """
  85.         """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
  86.         pass
  87.  
  88.     def update(self, E=None, **F): # known special case of dict.update
  89.         """ 更新
  90.             {'name':'alex', 'age': 18000}
  91.             [('name','sbsbsb'),]
  92.         """
  93.         """
  94.         D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
  95.         If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
  96.         If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
  97.         In either case, this is followed by: for k in F: D[k] = F[k]
  98.         """
  99.         pass
  100.  
  101.     def values(self): # real signature unknown; restored from __doc__
  102.         """ 所有的值 """
  103.         """ D.values() -> list of D's values """
  104.         return []
  105.  
  106.     def viewitems(self): # real signature unknown; restored from __doc__
  107.         """ 所有项，只是将内容保存至view对象中 """
  108.         """ D.viewitems() -> a set-like object providing a view on D's items """
  109.         pass
  110.  
  111.     def viewkeys(self): # real signature unknown; restored from __doc__
  112.         """ D.viewkeys() -> a set-like object providing a view on D's keys """
  113.         pass
  114.  
  115.     def viewvalues(self): # real signature unknown; restored from __doc__
  116.         """ D.viewvalues() -> an object providing a view on D's values """
  117.         pass
  118.  
  119.     def __cmp__(self, y): # real signature unknown; restored from __doc__
  120.         """ x.__cmp__(y) <==> cmp(x,y) """
  121.         pass
  122.  
  123.     def __contains__(self, k): # real signature unknown; restored from __doc__
  124.         """ D.__contains__(k) -> True if D has a key k, else False """
  125.         return False
  126.  
  127.     def __delitem__(self, y): # real signature unknown; restored from __doc__
  128.         """ x.__delitem__(y) <==> del x[y] """
  129.         pass
  130.  
  131.     def __eq__(self, y): # real signature unknown; restored from __doc__
  132.         """ x.__eq__(y) <==> x==y """
  133.         pass
  134.  
  135.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  136.         """ x.__getattribute__('name') <==> x.name """
  137.         pass
  138.  
  139.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  140.         """ x.__getitem__(y) <==> x[y] """
  141.         pass
  142.  
  143.     def __ge__(self, y): # real signature unknown; restored from __doc__
  144.         """ x.__ge__(y) <==> x>=y """
  145.         pass
  146.  
  147.     def __gt__(self, y): # real signature unknown; restored from __doc__
  148.         """ x.__gt__(y) <==> x>y """
  149.         pass
  150.  
  151.     def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
  152.         """
  153.         dict() -> new empty dictionary
  154.         dict(mapping) -> new dictionary initialized from a mapping object's
  155.             (key, value) pairs
  156.         dict(iterable) -> new dictionary initialized as if via:
  157.             d = {}
  158.             for k, v in iterable:
  159.                 d[k] = v
  160.         dict(**kwargs) -> new dictionary initialized with the name=value pairs
  161.             in the keyword argument list.  For example:  dict(one=1, two=2)
  162.         # (copied from class doc)
  163.         """
  164.         pass
  165.  
  166.     def __iter__(self): # real signature unknown; restored from __doc__
  167.         """ x.__iter__() <==> iter(x) """
  168.         pass
  169.  
  170.     def __len__(self): # real signature unknown; restored from __doc__
  171.         """ x.__len__() <==> len(x) """
  172.         pass
  173.  
  174.     def __le__(self, y): # real signature unknown; restored from __doc__
  175.         """ x.__le__(y) <==> x<=y """
  176.         pass
  177.  
  178.     def __lt__(self, y): # real signature unknown; restored from __doc__
  179.         """ x.__lt__(y) <==> x<y """
  180.         pass
  181.  
  182.     @staticmethod # known case of __new__
  183.     def __new__(S, *more): # real signature unknown; restored from __doc__
  184.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  185.         pass
  186.  
  187.     def __ne__(self, y): # real signature unknown; restored from __doc__
  188.         """ x.__ne__(y) <==> x!=y """
  189.         pass
  190.  
  191.     def __repr__(self): # real signature unknown; restored from __doc__
  192.         """ x.__repr__() <==> repr(x) """
  193.         pass
  194.  
  195.     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
  196.         """ x.__setitem__(i, y) <==> x[i]=y """
  197.         pass
  198.  
  199.     def __sizeof__(self): # real signature unknown; restored from __doc__
  200.         """ D.__sizeof__() -> size of D in memory, in bytes """
  201.         pass
  202.  
  203.     __hash__ = None
  204.  
  205. dict

dict

/set集合/

set是一个无序且不重复的元素集合

  1. class set(object):
  2.     """
  3.     set() -> new empty set object
  4.     set(iterable) -> new set object
  5.  
  6.     Build an unordered collection of unique elements.
  7.     """
  8.     def add(self, *args, **kwargs): # real signature unknown
  9.         """ 添加 """
  10.         """
  11.         Add an element to a set.
  12.  
  13.         This has no effect if the element is already present.
  14.         """
  15.         pass
  16.  
  17.     def clear(self, *args, **kwargs): # real signature unknown
  18.         """ Remove all elements from this set. """
  19.         pass
  20.  
  21.     def copy(self, *args, **kwargs): # real signature unknown
  22.         """ Return a shallow copy of a set. """
  23.         pass
  24.  
  25.     def difference(self, *args, **kwargs): # real signature unknown
  26.         """
  27.         Return the difference of two or more sets as a new set.
  28.  
  29.         (i.e. all elements that are in this set but not the others.)
  30.         """
  31.         pass
  32.  
  33.     def difference_update(self, *args, **kwargs): # real signature unknown
  34.         """ 删除当前set中的所有包含在 new set 里的元素 """
  35.         """ Remove all elements of another set from this set. """
  36.         pass
  37.  
  38.     def discard(self, *args, **kwargs): # real signature unknown
  39.         """ 移除元素 """
  40.         """
  41.         Remove an element from a set if it is a member.
  42.  
  43.         If the element is not a member, do nothing.
  44.         """
  45.         pass
  46.  
  47.     def intersection(self, *args, **kwargs): # real signature unknown
  48.         """ 取交集，新创建一个set """
  49.         """
  50.         Return the intersection of two or more sets as a new set.
  51.  
  52.         (i.e. elements that are common to all of the sets.)
  53.         """
  54.         pass
  55.  
  56.     def intersection_update(self, *args, **kwargs): # real signature unknown
  57.         """ 取交集，修改原来set """
  58.         """ Update a set with the intersection of itself and another. """
  59.         pass
  60.  
  61.     def isdisjoint(self, *args, **kwargs): # real signature unknown
  62.         """ 如果没有交集，返回true  """
  63.         """ Return True if two sets have a null intersection. """
  64.         pass
  65.  
  66.     def issubset(self, *args, **kwargs): # real signature unknown
  67.         """ 是否是子集 """
  68.         """ Report whether another set contains this set. """
  69.         pass
  70.  
  71.     def issuperset(self, *args, **kwargs): # real signature unknown
  72.         """ 是否是父集 """
  73.         """ Report whether this set contains another set. """
  74.         pass
  75.  
  76.     def pop(self, *args, **kwargs): # real signature unknown
  77.         """ 移除 """
  78.         """
  79.         Remove and return an arbitrary set element.
  80.         Raises KeyError if the set is empty.
  81.         """
  82.         pass
  83.  
  84.     def remove(self, *args, **kwargs): # real signature unknown
  85.         """ 移除 """
  86.         """
  87.         Remove an element from a set; it must be a member.
  88.  
  89.         If the element is not a member, raise a KeyError.
  90.         """
  91.         pass
  92.  
  93.     def symmetric_difference(self, *args, **kwargs): # real signature unknown
  94.         """ 差集，创建新对象"""
  95.         """
  96.         Return the symmetric difference of two sets as a new set.
  97.  
  98.         (i.e. all elements that are in exactly one of the sets.)
  99.         """
  100.         pass
  101.  
  102.     def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
  103.         """ 差集，改变原来 """
  104.         """ Update a set with the symmetric difference of itself and another. """
  105.         pass
  106.  
  107.     def union(self, *args, **kwargs): # real signature unknown
  108.         """ 并集 """
  109.         """
  110.         Return the union of sets as a new set.
  111.  
  112.         (i.e. all elements that are in either set.)
  113.         """
  114.         pass
  115.  
  116.     def update(self, *args, **kwargs): # real signature unknown
  117.         """ 更新 """
  118.         """ Update a set with the union of itself and others. """
  119.         pass
  120.  
  121.     def __and__(self, y): # real signature unknown; restored from __doc__
  122.         """ x.__and__(y) <==> x&y """
  123.         pass
  124.  
  125.     def __cmp__(self, y): # real signature unknown; restored from __doc__
  126.         """ x.__cmp__(y) <==> cmp(x,y) """
  127.         pass
  128.  
  129.     def __contains__(self, y): # real signature unknown; restored from __doc__
  130.         """ x.__contains__(y) <==> y in x. """
  131.         pass
  132.  
  133.     def __eq__(self, y): # real signature unknown; restored from __doc__
  134.         """ x.__eq__(y) <==> x==y """
  135.         pass
  136.  
  137.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  138.         """ x.__getattribute__('name') <==> x.name """
  139.         pass
  140.  
  141.     def __ge__(self, y): # real signature unknown; restored from __doc__
  142.         """ x.__ge__(y) <==> x>=y """
  143.         pass
  144.  
  145.     def __gt__(self, y): # real signature unknown; restored from __doc__
  146.         """ x.__gt__(y) <==> x>y """
  147.         pass
  148.  
  149.     def __iand__(self, y): # real signature unknown; restored from __doc__
  150.         """ x.__iand__(y) <==> x&=y """
  151.         pass
  152.  
  153.     def __init__(self, seq=()): # known special case of set.__init__
  154.         """
  155.         set() -> new empty set object
  156.         set(iterable) -> new set object
  157.  
  158.         Build an unordered collection of unique elements.
  159.         # (copied from class doc)
  160.         """
  161.         pass
  162.  
  163.     def __ior__(self, y): # real signature unknown; restored from __doc__
  164.         """ x.__ior__(y) <==> x|=y """
  165.         pass
  166.  
  167.     def __isub__(self, y): # real signature unknown; restored from __doc__
  168.         """ x.__isub__(y) <==> x-=y """
  169.         pass
  170.  
  171.     def __iter__(self): # real signature unknown; restored from __doc__
  172.         """ x.__iter__() <==> iter(x) """
  173.         pass
  174.  
  175.     def __ixor__(self, y): # real signature unknown; restored from __doc__
  176.         """ x.__ixor__(y) <==> x^=y """
  177.         pass
  178.  
  179.     def __len__(self): # real signature unknown; restored from __doc__
  180.         """ x.__len__() <==> len(x) """
  181.         pass
  182.  
  183.     def __le__(self, y): # real signature unknown; restored from __doc__
  184.         """ x.__le__(y) <==> x<=y """
  185.         pass
  186.  
  187.     def __lt__(self, y): # real signature unknown; restored from __doc__
  188.         """ x.__lt__(y) <==> x<y """
  189.         pass
  190.  
  191.     @staticmethod # known case of __new__
  192.     def __new__(S, *more): # real signature unknown; restored from __doc__
  193.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  194.         pass
  195.  
  196.     def __ne__(self, y): # real signature unknown; restored from __doc__
  197.         """ x.__ne__(y) <==> x!=y """
  198.         pass
  199.  
  200.     def __or__(self, y): # real signature unknown; restored from __doc__
  201.         """ x.__or__(y) <==> x|y """
  202.         pass
  203.  
  204.     def __rand__(self, y): # real signature unknown; restored from __doc__
  205.         """ x.__rand__(y) <==> y&x """
  206.         pass
  207.  
  208.     def __reduce__(self, *args, **kwargs): # real signature unknown
  209.         """ Return state information for pickling. """
  210.         pass
  211.  
  212.     def __repr__(self): # real signature unknown; restored from __doc__
  213.         """ x.__repr__() <==> repr(x) """
  214.         pass
  215.  
  216.     def __ror__(self, y): # real signature unknown; restored from __doc__
  217.         """ x.__ror__(y) <==> y|x """
  218.         pass
  219.  
  220.     def __rsub__(self, y): # real signature unknown; restored from __doc__
  221.         """ x.__rsub__(y) <==> y-x """
  222.         pass
  223.  
  224.     def __rxor__(self, y): # real signature unknown; restored from __doc__
  225.         """ x.__rxor__(y) <==> y^x """
  226.         pass
  227.  
  228.     def __sizeof__(self): # real signature unknown; restored from __doc__
  229.         """ S.__sizeof__() -> size of S in memory, in bytes """
  230.         pass
  231.  
  232.     def __sub__(self, y): # real signature unknown; restored from __doc__
  233.         """ x.__sub__(y) <==> x-y """
  234.         pass
  235.  
  236.     def __xor__(self, y): # real signature unknown; restored from __doc__
  237.         """ x.__xor__(y) <==> x^y """
  238.         pass
  239.  
  240.     __hash__ = None
  241.  
  242. set

set帮助

/collection系列/

1、计数器（Counter）

Counter是对字典类型的补充，用于追踪值的出现次数。

ps：具备字典的所有功能 + 自己的功能

  1. ########################################################################
  2. ###  Counter
  3. ########################################################################
  4.  
  5. class Counter(dict):
  6.     '''Dict subclass for counting hashable items.  Sometimes called a bag
  7.     or multiset.  Elements are stored as dictionary keys and their counts
  8.     are stored as dictionary values.
  9.  
  10.     >>> c = Counter('abcdeabcdabcaba')  # count elements from a string
  11.  
  12.     >>> c.most_common(3)                # three most common elements
  13.     [('a', 5), ('b', 4), ('c', 3)]
  14.     >>> sorted(c)                       # list all unique elements
  15.     ['a', 'b', 'c', 'd', 'e']
  16.     >>> ''.join(sorted(c.elements()))   # list elements with repetitions
  17.     'aaaaabbbbcccdde'
  18.     >>> sum(c.values())                 # total of all counts
  19.  
  20.     >>> c['a']                          # count of letter 'a'
  21.     >>> for elem in 'shazam':           # update counts from an iterable
  22.     ...     c[elem] += 1                # by adding 1 to each element's count
  23.     >>> c['a']                          # now there are seven 'a'
  24.     >>> del c['b']                      # remove all 'b'
  25.     >>> c['b']                          # now there are zero 'b'
  26.  
  27.     >>> d = Counter('simsalabim')       # make another counter
  28.     >>> c.update(d)                     # add in the second counter
  29.     >>> c['a']                          # now there are nine 'a'
  30.  
  31.     >>> c.clear()                       # empty the counter
  32.     >>> c
  33.     Counter()
  34.  
  35.     Note:  If a count is set to zero or reduced to zero, it will remain
  36.     in the counter until the entry is deleted or the counter is cleared:
  37.  
  38.     >>> c = Counter('aaabbc')
  39.     >>> c['b'] -= 2                     # reduce the count of 'b' by two
  40.     >>> c.most_common()                 # 'b' is still in, but its count is zero
  41.     [('a', 3), ('c', 1), ('b', 0)]
  42.  
  43.     '''
  44.     # References:
  45.     #   http://en.wikipedia.org/wiki/Multiset
  46.     #   http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html
  47.     #   http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm
  48.     #   http://code.activestate.com/recipes/259174/
  49.     #   Knuth, TAOCP Vol. II section 4.6.3
  50.  
  51.     def __init__(self, iterable=None, **kwds):
  52.         '''Create a new, empty Counter object.  And if given, count elements
  53.         from an input iterable.  Or, initialize the count from another mapping
  54.         of elements to their counts.
  55.  
  56.         >>> c = Counter()                           # a new, empty counter
  57.         >>> c = Counter('gallahad')                 # a new counter from an iterable
  58.         >>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping
  59.         >>> c = Counter(a=4, b=2)                   # a new counter from keyword args
  60.  
  61.         '''
  62.         super(Counter, self).__init__()
  63.         self.update(iterable, **kwds)
  64.  
  65.     def __missing__(self, key):
  66.         """ 对于不存在的元素，返回计数器为0 """
  67.         'The count of elements not in the Counter is zero.'
  68.         # Needed so that self[missing_item] does not raise KeyError
  69.         return 0
  70.  
  71.     def most_common(self, n=None):
  72.         """ 数量从大到写排列，获取前N个元素 """
  73.         '''List the n most common elements and their counts from the most
  74.         common to the least.  If n is None, then list all element counts.
  75.  
  76.         >>> Counter('abcdeabcdabcaba').most_common(3)
  77.         [('a', 5), ('b', 4), ('c', 3)]
  78.  
  79.         '''
  80.         # Emulate Bag.sortedByCount from Smalltalk
  81.         if n is None:
  82.             return sorted(self.iteritems(), key=_itemgetter(1), reverse=True)
  83.         return _heapq.nlargest(n, self.iteritems(), key=_itemgetter(1))
  84.  
  85.     def elements(self):
  86.         """ 计数器中的所有元素，注：此处非所有元素集合，而是包含所有元素集合的迭代器 """
  87.         '''Iterator over elements repeating each as many times as its count.
  88.  
  89.         >>> c = Counter('ABCABC')
  90.         >>> sorted(c.elements())
  91.         ['A', 'A', 'B', 'B', 'C', 'C']
  92.  
  93.         # Knuth's example for prime factors of 1836:  2**2 * 3**3 * 17**1
  94.         >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
  95.         >>> product = 1
  96.         >>> for factor in prime_factors.elements():     # loop over factors
  97.         ...     product *= factor                       # and multiply them
  98.         >>> product
  99.  
  100.         Note, if an element's count has been set to zero or is a negative
  101.         number, elements() will ignore it.
  102.  
  103.         '''
  104.         # Emulate Bag.do from Smalltalk and Multiset.begin from C++.
  105.         return _chain.from_iterable(_starmap(_repeat, self.iteritems()))
  106.  
  107.     # Override dict methods where necessary
  108.  
  109.     @classmethod
  110.     def fromkeys(cls, iterable, v=None):
  111.         # There is no equivalent method for counters because setting v=1
  112.         # means that no element can have a count greater than one.
  113.         raise NotImplementedError(
  114.             'Counter.fromkeys() is undefined.  Use Counter(iterable) instead.')
  115.  
  116.     def update(self, iterable=None, **kwds):
  117.         """ 更新计数器，其实就是增加；如果原来没有，则新建，如果有则加一 """
  118.         '''Like dict.update() but add counts instead of replacing them.
  119.  
  120.         Source can be an iterable, a dictionary, or another Counter instance.
  121.  
  122.         >>> c = Counter('which')
  123.         >>> c.update('witch')           # add elements from another iterable
  124.         >>> d = Counter('watch')
  125.         >>> c.update(d)                 # add elements from another counter
  126.         >>> c['h']                      # four 'h' in which, witch, and watch
  127.  
  128.         '''
  129.         # The regular dict.update() operation makes no sense here because the
  130.         # replace behavior results in the some of original untouched counts
  131.         # being mixed-in with all of the other counts for a mismash that
  132.         # doesn't have a straight-forward interpretation in most counting
  133.         # contexts.  Instead, we implement straight-addition.  Both the inputs
  134.         # and outputs are allowed to contain zero and negative counts.
  135.  
  136.         if iterable is not None:
  137.             if isinstance(iterable, Mapping):
  138.                 if self:
  139.                     self_get = self.get
  140.                     for elem, count in iterable.iteritems():
  141.                         self[elem] = self_get(elem, 0) + count
  142.                 else:
  143.                     super(Counter, self).update(iterable) # fast path when counter is empty
  144.             else:
  145.                 self_get = self.get
  146.                 for elem in iterable:
  147.                     self[elem] = self_get(elem, 0) + 1
  148.         if kwds:
  149.             self.update(kwds)
  150.  
  151.     def subtract(self, iterable=None, **kwds):
  152.         """ 相减，原来的计数器中的每一个元素的数量减去后添加的元素的数量 """
  153.         '''Like dict.update() but subtracts counts instead of replacing them.
  154.         Counts can be reduced below zero.  Both the inputs and outputs are
  155.         allowed to contain zero and negative counts.
  156.  
  157.         Source can be an iterable, a dictionary, or another Counter instance.
  158.  
  159.         >>> c = Counter('which')
  160.         >>> c.subtract('witch')             # subtract elements from another iterable
  161.         >>> c.subtract(Counter('watch'))    # subtract elements from another counter
  162.         >>> c['h']                          # 2 in which, minus 1 in witch, minus 1 in watch
  163.         >>> c['w']                          # 1 in which, minus 1 in witch, minus 1 in watch
  164.         -1
  165.  
  166.         '''
  167.         if iterable is not None:
  168.             self_get = self.get
  169.             if isinstance(iterable, Mapping):
  170.                 for elem, count in iterable.items():
  171.                     self[elem] = self_get(elem, 0) - count
  172.             else:
  173.                 for elem in iterable:
  174.                     self[elem] = self_get(elem, 0) - 1
  175.         if kwds:
  176.             self.subtract(kwds)
  177.  
  178.     def copy(self):
  179.         """ 拷贝 """
  180.         'Return a shallow copy.'
  181.         return self.__class__(self)
  182.  
  183.     def __reduce__(self):
  184.         """ 返回一个元组（类型，元组） """
  185.         return self.__class__, (dict(self),)
  186.  
  187.     def __delitem__(self, elem):
  188.         """ 删除元素 """
  189.         'Like dict.__delitem__() but does not raise KeyError for missing values.'
  190.         if elem in self:
  191.             super(Counter, self).__delitem__(elem)
  192.  
  193.     def __repr__(self):
  194.         if not self:
  195.             return '%s()' % self.__class__.__name__
  196.         items = ', '.join(map('%r: %r'.__mod__, self.most_common()))
  197.         return '%s({%s})' % (self.__class__.__name__, items)
  198.  
  199.     # Multiset-style mathematical operations discussed in:
  200.     #       Knuth TAOCP Volume II section 4.6.3 exercise 19
  201.     #       and at http://en.wikipedia.org/wiki/Multiset
  202.     #
  203.     # Outputs guaranteed to only include positive counts.
  204.     #
  205.     # To strip negative and zero counts, add-in an empty counter:
  206.     #       c += Counter()
  207.  
  208.     def __add__(self, other):
  209.         '''Add counts from two counters.
  210.  
  211.         >>> Counter('abbb') + Counter('bcc')
  212.         Counter({'b': 4, 'c': 2, 'a': 1})
  213.  
  214.         '''
  215.         if not isinstance(other, Counter):
  216.             return NotImplemented
  217.         result = Counter()
  218.         for elem, count in self.items():
  219.             newcount = count + other[elem]
  220.             if newcount > 0:
  221.                 result[elem] = newcount
  222.         for elem, count in other.items():
  223.             if elem not in self and count > 0:
  224.                 result[elem] = count
  225.         return result
  226.  
  227.     def __sub__(self, other):
  228.         ''' Subtract count, but keep only results with positive counts.
  229.  
  230.         >>> Counter('abbbc') - Counter('bccd')
  231.         Counter({'b': 2, 'a': 1})
  232.  
  233.         '''
  234.         if not isinstance(other, Counter):
  235.             return NotImplemented
  236.         result = Counter()
  237.         for elem, count in self.items():
  238.             newcount = count - other[elem]
  239.             if newcount > 0:
  240.                 result[elem] = newcount
  241.         for elem, count in other.items():
  242.             if elem not in self and count < 0:
  243.                 result[elem] = 0 - count
  244.         return result
  245.  
  246.     def __or__(self, other):
  247.         '''Union is the maximum of value in either of the input counters.
  248.  
  249.         >>> Counter('abbb') | Counter('bcc')
  250.         Counter({'b': 3, 'c': 2, 'a': 1})
  251.  
  252.         '''
  253.         if not isinstance(other, Counter):
  254.             return NotImplemented
  255.         result = Counter()
  256.         for elem, count in self.items():
  257.             other_count = other[elem]
  258.             newcount = other_count if count < other_count else count
  259.             if newcount > 0:
  260.                 result[elem] = newcount
  261.         for elem, count in other.items():
  262.             if elem not in self and count > 0:
  263.                 result[elem] = count
  264.         return result
  265.  
  266.     def __and__(self, other):
  267.         ''' Intersection is the minimum of corresponding counts.
  268.  
  269.         >>> Counter('abbb') & Counter('bcc')
  270.         Counter({'b': 1})
  271.  
  272.         '''
  273.         if not isinstance(other, Counter):
  274.             return NotImplemented
  275.         result = Counter()
  276.         for elem, count in self.items():
  277.             other_count = other[elem]
  278.             newcount = count if count < other_count else other_count
  279.             if newcount > 0:
  280.                 result[elem] = newcount
  281.         return result
  282.  
  283. Counter

Counter帮助

  1. import collections
  2. c = collections.Counter('abcdeabcdabcaba')
  3. print(c)
  4.  
  5. #Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

2、有序字典(OrderedDict )

orderdDict是对字典类型的补充，他记住了字典元素添加的顺序

  1. class OrderedDict(dict):
  2.     'Dictionary that remembers insertion order'
  3.     # An inherited dict maps keys to values.
  4.     # The inherited dict provides __getitem__, __len__, __contains__, and get.
  5.     # The remaining methods are order-aware.
  6.     # Big-O running times for all methods are the same as regular dictionaries.
  7.  
  8.     # The internal self.__map dict maps keys to links in a doubly linked list.
  9.     # The circular doubly linked list starts and ends with a sentinel element.
  10.     # The sentinel element never gets deleted (this simplifies the algorithm).
  11.     # Each link is stored as a list of length three:  [PREV, NEXT, KEY].
  12.  
  13.     def __init__(self, *args, **kwds):
  14.         '''Initialize an ordered dictionary.  The signature is the same as
  15.         regular dictionaries, but keyword arguments are not recommended because
  16.         their insertion order is arbitrary.
  17.  
  18.         '''
  19.         if len(args) > 1:
  20.             raise TypeError('expected at most 1 arguments, got %d' % len(args))
  21.         try:
  22.             self.__root
  23.         except AttributeError:
  24.             self.__root = root = []                     # sentinel node
  25.             root[:] = [root, root, None]
  26.             self.__map = {}
  27.         self.__update(*args, **kwds)
  28.  
  29.     def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
  30.         'od.__setitem__(i, y) <==> od[i]=y'
  31.         # Setting a new item creates a new link at the end of the linked list,
  32.         # and the inherited dictionary is updated with the new key/value pair.
  33.         if key not in self:
  34.             root = self.__root
  35.             last = root[0]
  36.             last[1] = root[0] = self.__map[key] = [last, root, key]
  37.         return dict_setitem(self, key, value)
  38.  
  39.     def __delitem__(self, key, dict_delitem=dict.__delitem__):
  40.         'od.__delitem__(y) <==> del od[y]'
  41.         # Deleting an existing item uses self.__map to find the link which gets
  42.         # removed by updating the links in the predecessor and successor nodes.
  43.         dict_delitem(self, key)
  44.         link_prev, link_next, _ = self.__map.pop(key)
  45.         link_prev[1] = link_next                        # update link_prev[NEXT]
  46.         link_next[0] = link_prev                        # update link_next[PREV]
  47.  
  48.     def __iter__(self):
  49.         'od.__iter__() <==> iter(od)'
  50.         # Traverse the linked list in order.
  51.         root = self.__root
  52.         curr = root[1]                                  # start at the first node
  53.         while curr is not root:
  54.             yield curr[2]                               # yield the curr[KEY]
  55.             curr = curr[1]                              # move to next node
  56.  
  57.     def __reversed__(self):
  58.         'od.__reversed__() <==> reversed(od)'
  59.         # Traverse the linked list in reverse order.
  60.         root = self.__root
  61.         curr = root[0]                                  # start at the last node
  62.         while curr is not root:
  63.             yield curr[2]                               # yield the curr[KEY]
  64.             curr = curr[0]                              # move to previous node
  65.  
  66.     def clear(self):
  67.         'od.clear() -> None.  Remove all items from od.'
  68.         root = self.__root
  69.         root[:] = [root, root, None]
  70.         self.__map.clear()
  71.         dict.clear(self)
  72.  
  73.     # -- the following methods do not depend on the internal structure --
  74.  
  75.     def keys(self):
  76.         'od.keys() -> list of keys in od'
  77.         return list(self)
  78.  
  79.     def values(self):
  80.         'od.values() -> list of values in od'
  81.         return [self[key] for key in self]
  82.  
  83.     def items(self):
  84.         'od.items() -> list of (key, value) pairs in od'
  85.         return [(key, self[key]) for key in self]
  86.  
  87.     def iterkeys(self):
  88.         'od.iterkeys() -> an iterator over the keys in od'
  89.         return iter(self)
  90.  
  91.     def itervalues(self):
  92.         'od.itervalues -> an iterator over the values in od'
  93.         for k in self:
  94.             yield self[k]
  95.  
  96.     def iteritems(self):
  97.         'od.iteritems -> an iterator over the (key, value) pairs in od'
  98.         for k in self:
  99.             yield (k, self[k])
  100.  
  101.     update = MutableMapping.update
  102.  
  103.     __update = update # let subclasses override update without breaking __init__
  104.  
  105.     __marker = object()
  106.  
  107.     def pop(self, key, default=__marker):
  108.         '''od.pop(k[,d]) -> v, remove specified key and return the corresponding
  109.         value.  If key is not found, d is returned if given, otherwise KeyError
  110.         is raised.
  111.  
  112.         '''
  113.         if key in self:
  114.             result = self[key]
  115.             del self[key]
  116.             return result
  117.         if default is self.__marker:
  118.             raise KeyError(key)
  119.         return default
  120.  
  121.     def setdefault(self, key, default=None):
  122.         'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
  123.         if key in self:
  124.             return self[key]
  125.         self[key] = default
  126.         return default
  127.  
  128.     def popitem(self, last=True):
  129.         '''od.popitem() -> (k, v), return and remove a (key, value) pair.
  130.         Pairs are returned in LIFO order if last is true or FIFO order if false.
  131.  
  132.         '''
  133.         if not self:
  134.             raise KeyError('dictionary is empty')
  135.         key = next(reversed(self) if last else iter(self))
  136.         value = self.pop(key)
  137.         return key, value
  138.  
  139.     def __repr__(self, _repr_running={}):
  140.         'od.__repr__() <==> repr(od)'
  141.         call_key = id(self), _get_ident()
  142.         if call_key in _repr_running:
  143.             return '...'
  144.         _repr_running[call_key] = 1
  145.         try:
  146.             if not self:
  147.                 return '%s()' % (self.__class__.__name__,)
  148.             return '%s(%r)' % (self.__class__.__name__, self.items())
  149.         finally:
  150.             del _repr_running[call_key]
  151.  
  152.     def __reduce__(self):
  153.         'Return state information for pickling'
  154.         items = [[k, self[k]] for k in self]
  155.         inst_dict = vars(self).copy()
  156.         for k in vars(OrderedDict()):
  157.             inst_dict.pop(k, None)
  158.         if inst_dict:
  159.             return (self.__class__, (items,), inst_dict)
  160.         return self.__class__, (items,)
  161.  
  162.     def copy(self):
  163.         'od.copy() -> a shallow copy of od'
  164.         return self.__class__(self)
  165.  
  166.     @classmethod
  167.     def fromkeys(cls, iterable, value=None):
  168.         '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
  169.         If not specified, the value defaults to None.
  170.  
  171.         '''
  172.         self = cls()
  173.         for key in iterable:
  174.             self[key] = value
  175.         return self
  176.  
  177.     def __eq__(self, other):
  178.         '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
  179.         while comparison to a regular mapping is order-insensitive.
  180.  
  181.         '''
  182.         if isinstance(other, OrderedDict):
  183.             return dict.__eq__(self, other) and all(_imap(_eq, self, other))
  184.         return dict.__eq__(self, other)
  185.  
  186.     def __ne__(self, other):
  187.         'od.__ne__(y) <==> od!=y'
  188.         return not self == other
  189.  
  190.     # -- the following methods support python 3.x style dictionary views --
  191.  
  192.     def viewkeys(self):
  193.         "od.viewkeys() -> a set-like object providing a view on od's keys"
  194.         return KeysView(self)
  195.  
  196.     def viewvalues(self):
  197.         "od.viewvalues() -> an object providing a view on od's values"
  198.         return ValuesView(self)
  199.  
  200.     def viewitems(self):
  201.         "od.viewitems() -> a set-like object providing a view on od's items"
  202.         return ItemsView(self)
  203.  
  204. OrderedDict

OrderedDict帮助

  1. import collections
  2. dic = collections.OrderedDict()
  3. #dic = dict()
  4. dic['k1']='v1'
  5. dic['k2']='v2'
  6. dic['k3']='v3'
  7. print(dic)
  8.  
  9. #OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
  10. #{'k1': 'v1', 'k3': 'v3', 'k2': 'v2'}

3、默认字典(defaultdict)

defaultdict是对字典的类型的补充，他默认给字典的值设置了一个类型。

  1. class defaultdict(dict):
  2.     """
  3.     defaultdict(default_factory[, ...]) --> dict with default factory
  4.  
  5.     The default factory is called without arguments to produce
  6.     a new value when a key is not present, in __getitem__ only.
  7.     A defaultdict compares equal to a dict with the same items.
  8.     All remaining arguments are treated the same as if they were
  9.     passed to the dict constructor, including keyword arguments.
  10.     """
  11.     def copy(self): # real signature unknown; restored from __doc__
  12.         """ D.copy() -> a shallow copy of D. """
  13.         pass
  14.  
  15.     def __copy__(self, *args, **kwargs): # real signature unknown
  16.         """ D.copy() -> a shallow copy of D. """
  17.         pass
  18.  
  19.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  20.         """ x.__getattribute__('name') <==> x.name """
  21.         pass
  22.  
  23.     def __init__(self, default_factory=None, **kwargs): # known case of _collections.defaultdict.__init__
  24.         """
  25.         defaultdict(default_factory[, ...]) --> dict with default factory
  26.  
  27.         The default factory is called without arguments to produce
  28.         a new value when a key is not present, in __getitem__ only.
  29.         A defaultdict compares equal to a dict with the same items.
  30.         All remaining arguments are treated the same as if they were
  31.         passed to the dict constructor, including keyword arguments.
  32.  
  33.         # (copied from class doc)
  34.         """
  35.         pass
  36.  
  37.     def __missing__(self, key): # real signature unknown; restored from __doc__
  38.         """
  39.         __missing__(key) # Called by __getitem__ for missing key; pseudo-code:
  40.           if self.default_factory is None: raise KeyError((key,))
  41.           self[key] = value = self.default_factory()
  42.           return value
  43.         """
  44.         pass
  45.  
  46.     def __reduce__(self, *args, **kwargs): # real signature unknown
  47.         """ Return state information for pickling. """
  48.         pass
  49.  
  50.     def __repr__(self): # real signature unknown; restored from __doc__
  51.         """ x.__repr__() <==> repr(x) """
  52.         pass
  53.  
  54.     default_factory = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  55.     """Factory for default value called by __missing__()."""
  56.  
  57. defaultdict

defaultdict帮助

  1. import collections
  2. dic = collections.defaultdict(list)
  3. print(dic)
  4. dic['k1'].append('alex')
  5. print(dic)
  6.  
  7. #defaultdict(<class 'list'>, {})
  8. #defaultdict(<class 'list'>, {'k1': ['alex']})

4、可命名元组(namedtuple)

根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型。　

  1. class MytupleClass(builtins.tuple)
  2.  |  MytupleClass(x, y, z)
  3.  |
  4.  |  Method resolution order:
  5.  |      MytupleClass
  6.  |      builtins.tuple
  7.  |      builtins.object
  8.  |
  9.  |  Methods defined here:
  10.  |
  11.  |  __getnewargs__(self)
  12.  |      Return self as a plain tuple.  Used by copy and pickle.
  13.  |
  14.  |  __repr__(self)
  15.  |      Return a nicely formatted representation string
  16.  |
  17.  |  _asdict(self)
  18.  |      Return a new OrderedDict which maps field names to their values.
  19.  |
  20.  |  _replace(_self, **kwds)
  21.  |      Return a new MytupleClass object replacing specified fields with new values
  22.  |
  23.  |  ----------------------------------------------------------------------
  24.  |  Class methods defined here:
  25.  |
  26.  |  _make(iterable, new=<built-in method __new__ of type object at 0x66E3B5C8>, len=<built-in function len>) from builtins.type
  27.  |      Make a new MytupleClass object from a sequence or iterable
  28.  |
  29.  |  ----------------------------------------------------------------------
  30.  |  Static methods defined here:
  31.  |
  32.  |  __new__(_cls, x, y, z)
  33.  |      Create new instance of MytupleClass(x, y, z)
  34.  |
  35.  |  ----------------------------------------------------------------------
  36.  |  Data descriptors defined here:
  37.  |
  38.  |  x
  39.  |      Alias for field number 0
  40.  |
  41.  |  y
  42.  |      Alias for field number 1
  43.  |
  44.  |  z
  45.  |      Alias for field number 2
  46.  |
  47.  |  ----------------------------------------------------------------------
  48.  |  Data and other attributes defined here:
  49.  |
  50.  |  _fields = ('x', 'y', 'z')
  51.  |
  52.  |  _source = "from builtins import property as _property, tupl..._itemget...
  53.  |
  54.  |  ----------------------------------------------------------------------
  55.  |  Methods inherited from builtins.tuple:
  56.  |
  57.  |  __add__(self, value, /)
  58.  |      Return self+value.
  59.  |
  60.  |  __contains__(self, key, /)
  61.  |      Return key in self.
  62.  |
  63.  |  __eq__(self, value, /)
  64.  |      Return self==value.
  65.  |
  66.  |  __ge__(self, value, /)
  67.  |      Return self>=value.
  68.  |
  69.  |  __getattribute__(self, name, /)
  70.  |      Return getattr(self, name).
  71.  |
  72.  |  __getitem__(self, key, /)
  73.  |      Return self[key].
  74.  |
  75.  |  __gt__(self, value, /)
  76.  |      Return self>value.
  77.  |
  78.  |  __hash__(self, /)
  79.  |      Return hash(self).
  80.  |
  81.  |  __iter__(self, /)
  82.  |      Implement iter(self).
  83.  |
  84.  |  __le__(self, value, /)
  85.  |      Return self<=value.
  86.  |
  87.  |  __len__(self, /)
  88.  |      Return len(self).
  89.  |
  90.  |  __lt__(self, value, /)
  91.  |      Return self<value.
  92.  |
  93.  |  __mul__(self, value, /)
  94.  |      Return self*value.n
  95.  |
  96.  |  __ne__(self, value, /)
  97.  |      Return self!=value.
  98.  |
  99.  |  __rmul__(self, value, /)
  100.  |      Return self*value.
  101.  |
  102.  |  count(...)
  103.  |      T.count(value) -> integer -- return number of occurrences of value
  104.  |
  105.  |  index(...)
  106.  |      T.index(value, [start, [stop]]) -> integer -- return first index of value.
  107.  |      Raises ValueError if the value is not present.

namedtuple帮助

  1. import collections
  2. MytupleClass = collections.namedtuple('MytupleClass',['x','y','z'])
  3. obj = MytupleClass(11,22,33)
  4. print(obj)
  5. print(obj.x)
  6. print(obj.y)
  7. print(obj.z)
  8.  
  9. #MytupleClass(x=11, y=22, z=33)
  10. #
  11. #
  12. #

5、双向队列(deque)

一个线程安全的双向队列

  1. class deque(object):
  2.     """
  3.     deque([iterable[, maxlen]]) --> deque object
  4.  
  5.     Build an ordered collection with optimized access from its endpoints.
  6.     """
  7.     def append(self, *args, **kwargs): # real signature unknown
  8.         """ Add an element to the right side of the deque. """
  9.         pass
  10.  
  11.     def appendleft(self, *args, **kwargs): # real signature unknown
  12.         """ Add an element to the left side of the deque. """
  13.         pass
  14.  
  15.     def clear(self, *args, **kwargs): # real signature unknown
  16.         """ Remove all elements from the deque. """
  17.         pass
  18.  
  19.     def count(self, value): # real signature unknown; restored from __doc__
  20.         """ D.count(value) -> integer -- return number of occurrences of value """
  21.         return 0
  22.  
  23.     def extend(self, *args, **kwargs): # real signature unknown
  24.         """ Extend the right side of the deque with elements from the iterable """
  25.         pass
  26.  
  27.     def extendleft(self, *args, **kwargs): # real signature unknown
  28.         """ Extend the left side of the deque with elements from the iterable """
  29.         pass
  30.  
  31.     def pop(self, *args, **kwargs): # real signature unknown
  32.         """ Remove and return the rightmost element. """
  33.         pass
  34.  
  35.     def popleft(self, *args, **kwargs): # real signature unknown
  36.         """ Remove and return the leftmost element. """
  37.         pass
  38.  
  39.     def remove(self, value): # real signature unknown; restored from __doc__
  40.         """ D.remove(value) -- remove first occurrence of value. """
  41.         pass
  42.  
  43.     def reverse(self): # real signature unknown; restored from __doc__
  44.         """ D.reverse() -- reverse *IN PLACE* """
  45.         pass
  46.  
  47.     def rotate(self, *args, **kwargs): # real signature unknown
  48.         """ Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """
  49.         pass
  50.  
  51.     def __copy__(self, *args, **kwargs): # real signature unknown
  52.         """ Return a shallow copy of a deque. """
  53.         pass
  54.  
  55.     def __delitem__(self, y): # real signature unknown; restored from __doc__
  56.         """ x.__delitem__(y) <==> del x[y] """
  57.         pass
  58.  
  59.     def __eq__(self, y): # real signature unknown; restored from __doc__
  60.         """ x.__eq__(y) <==> x==y """
  61.         pass
  62.  
  63.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  64.         """ x.__getattribute__('name') <==> x.name """
  65.         pass
  66.  
  67.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  68.         """ x.__getitem__(y) <==> x[y] """
  69.         pass
  70.  
  71.     def __ge__(self, y): # real signature unknown; restored from __doc__
  72.         """ x.__ge__(y) <==> x>=y """
  73.         pass
  74.  
  75.     def __gt__(self, y): # real signature unknown; restored from __doc__
  76.         """ x.__gt__(y) <==> x>y """
  77.         pass
  78.  
  79.     def __iadd__(self, y): # real signature unknown; restored from __doc__
  80.         """ x.__iadd__(y) <==> x+=y """
  81.         pass
  82.  
  83.     def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__
  84.         """
  85.         deque([iterable[, maxlen]]) --> deque object
  86.  
  87.         Build an ordered collection with optimized access from its endpoints.
  88.         # (copied from class doc)
  89.         """
  90.         pass
  91.  
  92.     def __iter__(self): # real signature unknown; restored from __doc__
  93.         """ x.__iter__() <==> iter(x) """
  94.         pass
  95.  
  96.     def __len__(self): # real signature unknown; restored from __doc__
  97.         """ x.__len__() <==> len(x) """
  98.         pass
  99.  
  100.     def __le__(self, y): # real signature unknown; restored from __doc__
  101.         """ x.__le__(y) <==> x<=y """
  102.         pass
  103.  
  104.     def __lt__(self, y): # real signature unknown; restored from __doc__
  105.         """ x.__lt__(y) <==> x<y """
  106.         pass
  107.  
  108.     @staticmethod # known case of __new__
  109.     def __new__(S, *more): # real signature unknown; restored from __doc__
  110.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  111.         pass
  112.  
  113.     def __ne__(self, y): # real signature unknown; restored from __doc__
  114.         """ x.__ne__(y) <==> x!=y """
  115.         pass
  116.  
  117.     def __reduce__(self, *args, **kwargs): # real signature unknown
  118.         """ Return state information for pickling. """
  119.         pass
  120.  
  121.     def __repr__(self): # real signature unknown; restored from __doc__
  122.         """ x.__repr__() <==> repr(x) """
  123.         pass
  124.  
  125.     def __reversed__(self): # real signature unknown; restored from __doc__
  126.         """ D.__reversed__() -- return a reverse iterator over the deque """
  127.         pass
  128.  
  129.     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
  130.         """ x.__setitem__(i, y) <==> x[i]=y """
  131.         pass
  132.  
  133.     def __sizeof__(self): # real signature unknown; restored from __doc__
  134.         """ D.__sizeof__() -- size of D in memory, in bytes """
  135.         pass
  136.  
  137.     maxlen = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  138.     """maximum size of a deque or None if unbounded"""
  139.  
  140.     __hash__ = None
  141.  
  142. deque

deque帮助

  1. import collections
  2. d = collections.deque()
  3. d.append('')
  4. d.appendleft('')
  5. d.appendleft('')
  6. print(d)
  7. r = d.count('')
  8. print(r)
  9. d.extend(['yy','uu','ii'])
  10. d.extendleft(['yy1','uu1','ii1'])
  11. print(d)
  12. d.rotate(1)
  13. print(d)
  14.  
  15. #deque(['1', '10', '1'])
  16. #
  17. #deque(['ii1', 'uu1', 'yy1', '1', '10', '1', 'yy', 'uu', 'ii'])
  18. #deque(['ii', 'ii1', 'uu1', 'yy1', '1', '10', '1', 'yy', 'uu'])

注：既然有双向队列，也有单项队列（先进先出 FIFO ）

单项队列(queue)

  1. class Queue:
  2.     """Create a queue object with a given maximum size.
  3.  
  4.     If maxsize is <= 0, the queue size is infinite.
  5.     """
  6.     def __init__(self, maxsize=0):
  7.         self.maxsize = maxsize
  8.         self._init(maxsize)
  9.         # mutex must be held whenever the queue is mutating.  All methods
  10.         # that acquire mutex must release it before returning.  mutex
  11.         # is shared between the three conditions, so acquiring and
  12.         # releasing the conditions also acquires and releases mutex.
  13.         self.mutex = _threading.Lock()
  14.         # Notify not_empty whenever an item is added to the queue; a
  15.         # thread waiting to get is notified then.
  16.         self.not_empty = _threading.Condition(self.mutex)
  17.         # Notify not_full whenever an item is removed from the queue;
  18.         # a thread waiting to put is notified then.
  19.         self.not_full = _threading.Condition(self.mutex)
  20.         # Notify all_tasks_done whenever the number of unfinished tasks
  21.         # drops to zero; thread waiting to join() is notified to resume
  22.         self.all_tasks_done = _threading.Condition(self.mutex)
  23.         self.unfinished_tasks = 0
  24.  
  25.     def task_done(self):
  26.         """Indicate that a formerly enqueued task is complete.
  27.  
  28.         Used by Queue consumer threads.  For each get() used to fetch a task,
  29.         a subsequent call to task_done() tells the queue that the processing
  30.         on the task is complete.
  31.  
  32.         If a join() is currently blocking, it will resume when all items
  33.         have been processed (meaning that a task_done() call was received
  34.         for every item that had been put() into the queue).
  35.  
  36.         Raises a ValueError if called more times than there were items
  37.         placed in the queue.
  38.         """
  39.         self.all_tasks_done.acquire()
  40.         try:
  41.             unfinished = self.unfinished_tasks - 1
  42.             if unfinished <= 0:
  43.                 if unfinished < 0:
  44.                     raise ValueError('task_done() called too many times')
  45.                 self.all_tasks_done.notify_all()
  46.             self.unfinished_tasks = unfinished
  47.         finally:
  48.             self.all_tasks_done.release()
  49.  
  50.     def join(self):
  51.         """Blocks until all items in the Queue have been gotten and processed.
  52.  
  53.         The count of unfinished tasks goes up whenever an item is added to the
  54.         queue. The count goes down whenever a consumer thread calls task_done()
  55.         to indicate the item was retrieved and all work on it is complete.
  56.  
  57.         When the count of unfinished tasks drops to zero, join() unblocks.
  58.         """
  59.         self.all_tasks_done.acquire()
  60.         try:
  61.             while self.unfinished_tasks:
  62.                 self.all_tasks_done.wait()
  63.         finally:
  64.             self.all_tasks_done.release()
  65.  
  66.     def qsize(self):
  67.         """Return the approximate size of the queue (not reliable!)."""
  68.         self.mutex.acquire()
  69.         n = self._qsize()
  70.         self.mutex.release()
  71.         return n
  72.  
  73.     def empty(self):
  74.         """Return True if the queue is empty, False otherwise (not reliable!)."""
  75.         self.mutex.acquire()
  76.         n = not self._qsize()
  77.         self.mutex.release()
  78.         return n
  79.  
  80.     def full(self):
  81.         """Return True if the queue is full, False otherwise (not reliable!)."""
  82.         self.mutex.acquire()
  83.         n = 0 < self.maxsize == self._qsize()
  84.         self.mutex.release()
  85.         return n
  86.  
  87.     def put(self, item, block=True, timeout=None):
  88.         """Put an item into the queue.
  89.  
  90.         If optional args 'block' is true and 'timeout' is None (the default),
  91.         block if necessary until a free slot is available. If 'timeout' is
  92.         a non-negative number, it blocks at most 'timeout' seconds and raises
  93.         the Full exception if no free slot was available within that time.
  94.         Otherwise ('block' is false), put an item on the queue if a free slot
  95.         is immediately available, else raise the Full exception ('timeout'
  96.         is ignored in that case).
  97.         """
  98.         self.not_full.acquire()
  99.         try:
  100.             if self.maxsize > 0:
  101.                 if not block:
  102.                     if self._qsize() == self.maxsize:
  103.                         raise Full
  104.                 elif timeout is None:
  105.                     while self._qsize() == self.maxsize:
  106.                         self.not_full.wait()
  107.                 elif timeout < 0:
  108.                     raise ValueError("'timeout' must be a non-negative number")
  109.                 else:
  110.                     endtime = _time() + timeout
  111.                     while self._qsize() == self.maxsize:
  112.                         remaining = endtime - _time()
  113.                         if remaining <= 0.0:
  114.                             raise Full
  115.                         self.not_full.wait(remaining)
  116.             self._put(item)
  117.             self.unfinished_tasks += 1
  118.             self.not_empty.notify()
  119.         finally:
  120.             self.not_full.release()
  121.  
  122.     def put_nowait(self, item):
  123.         """Put an item into the queue without blocking.
  124.  
  125.         Only enqueue the item if a free slot is immediately available.
  126.         Otherwise raise the Full exception.
  127.         """
  128.         return self.put(item, False)
  129.  
  130.     def get(self, block=True, timeout=None):
  131.         """Remove and return an item from the queue.
  132.  
  133.         If optional args 'block' is true and 'timeout' is None (the default),
  134.         block if necessary until an item is available. If 'timeout' is
  135.         a non-negative number, it blocks at most 'timeout' seconds and raises
  136.         the Empty exception if no item was available within that time.
  137.         Otherwise ('block' is false), return an item if one is immediately
  138.         available, else raise the Empty exception ('timeout' is ignored
  139.         in that case).
  140.         """
  141.         self.not_empty.acquire()
  142.         try:
  143.             if not block:
  144.                 if not self._qsize():
  145.                     raise Empty
  146.             elif timeout is None:
  147.                 while not self._qsize():
  148.                     self.not_empty.wait()
  149.             elif timeout < 0:
  150.                 raise ValueError("'timeout' must be a non-negative number")
  151.             else:
  152.                 endtime = _time() + timeout
  153.                 while not self._qsize():
  154.                     remaining = endtime - _time()
  155.                     if remaining <= 0.0:
  156.                         raise Empty
  157.                     self.not_empty.wait(remaining)
  158.             item = self._get()
  159.             self.not_full.notify()
  160.             return item
  161.         finally:
  162.             self.not_empty.release()
  163.  
  164.     def get_nowait(self):
  165.         """Remove and return an item from the queue without blocking.
  166.  
  167.         Only get an item if one is immediately available. Otherwise
  168.         raise the Empty exception.
  169.         """
  170.         return self.get(False)
  171.  
  172.     # Override these methods to implement other queue organizations
  173.     # (e.g. stack or priority queue).
  174.     # These will only be called with appropriate locks held
  175.  
  176.     # Initialize the queue representation
  177.     def _init(self, maxsize):
  178.         self.queue = deque()
  179.  
  180.     def _qsize(self, len=len):
  181.         return len(self.queue)
  182.  
  183.     # Put a new item in the queue
  184.     def _put(self, item):
  185.         self.queue.append(item)
  186.  
  187.     # Get an item from the queue
  188.     def _get(self):
  189.         return self.queue.popleft()
  190.  
  191. Queue.Queue

Queue帮助

  1. import queue
  2. q = queue.Queue()
  3. q.put('')
  4. q.put('')
  5. print(q.qsize())
  6. print(q.get())
  7. print(q.get())
  8.  
  9. #
  10. #
  11. #

python-基本数据类型的更多相关文章

  1. python 基本数据类型分析

    在python中,一切都是对象!对象由类创建而来,对象所拥有的功能都来自于类.在本节中,我们了解一下python基本数据类型对象具有哪些功能,我们平常是怎么使用的. 对于python,一切事物都是对象 ...

  2. python常用数据类型内置方法介绍

    熟练掌握python常用数据类型内置方法是每个初学者必须具备的内功. 下面介绍了python常用的集中数据类型及其方法,点开源代码,其中对主要方法都进行了中文注释. 一.整型 a = 100 a.xx ...

  3. 闲聊之Python的数据类型 - 零基础入门学习Python005

    闲聊之Python的数据类型 让编程改变世界 Change the world by program Python的数据类型 闲聊之Python的数据类型所谓闲聊,goosip,就是屁大点事可以咱聊上 ...

  4. python自学笔记（二）python基本数据类型之字符串处理

    一.数据类型的组成分3部分:身份.类型.值 身份:id方法来看它的唯一标识符,内存地址靠这个查看 类型:type方法查看 值:数据项 二.常用基本数据类型 int 整型 boolean 布尔型 str ...

  5. Python入门-数据类型

    一.变量 1)变量定义 name = 100(name是变量名 = 号是赋值号100是变量的值) 2)变量赋值 直接赋值 a=1 链式赋值  a=b=c=1 序列解包赋值  a,b,c = 1,2,3 ...

  6. Python基础：八、python基本数据类型

    一.什么是数据类型? 我们人类可以很容易的分清数字与字符的区别,但是计算机并不能,计算机虽然很强大,但从某种角度上来看又很傻,除非你明确告诉它,"1"是数字,"壹&quo ...

  7. python之数据类型详解

    python之数据类型详解 二.列表list  (可以存储多个值)(列表内数字不需要加引号) sort s1=[','!'] # s1.sort() # print(s1) -->['!', ' ...

  8. Python特色数据类型（列表）（上）

    Python从零开始系列连载(9)——Python特色数据类型(列表)(上) 原创 2017-10-07 王大伟 Python爱好者社区 列表 列表,可以是这样的: 分享了一波我的网易云音乐列表 今天 ...

  9. 【Python】-NO.97.Note.2.Python -【Python 基本数据类型】

    1.0.0 Summary Tittle:[Python]-NO.97.Note.2.Python -[Python 基本数据类型] Style:Python Series:Python Since: ...

  10. python基本数据类型之集合

    python基本数据类型之集合 集合是一种容器,用来存放不同元素. 集合有3大特点: 集合的元素必须是不可变类型(字符串.数字.元组): 集合中的元素不能重复: 集合是无序的. 在集合中直接存入lis ...

随机推荐

  1. xcode8.1 插件失效的问题

    1,查看 Xcode 插件安装目录 ~/Library/Application Support/Developer/Shared/Xcode/Plug-ins 鼠标点一下桌面, command+shi ...

  2. LINQ系列目录

    1. LINQ准备 1.1 C#中与LINQ相关特性 2. LINQ to Object 2.1 LINQ to Object投影操作符(Select/SelectMany/Let) 2.2 LINQ ...

  3. LBaaS 实现机制 - 每天5分钟玩转 OpenStack（125）

    上一节我们已经配置并测试 LBaaS,今天重点分析 Neutron 是如何用 Haproxy 来实现负责均衡的. 在控制节点上运行 ip netns,我们发现 Neutron 创建了新的 namesp ...

  4. MVC默认路由实现分页-PagerExtend.dll

    这两天在群里有人咨询有没有现成的.net mvc分页方法,由此写了一个简单分页工具,这里简单分享下实现思路,代码,希望能对大家有些帮助,鼓励大家多造些轮子还是好的. A.效果(这里用了bootstra ...

  5. K近邻法(KNN)原理小结

    K近邻法(k-nearst neighbors,KNN)是一种很基本的机器学习方法了,在我们平常的生活中也会不自主的应用.比如,我们判断一个人的人品,只需要观察他来往最密切的几个人的人品好坏就可以得出 ...

  6. 你真的会玩SQL吗？实用函数方法汇总

    你真的会玩SQL吗?系列目录 你真的会玩SQL吗?之逻辑查询处理阶段 你真的会玩SQL吗?和平大使 内连接.外连接 你真的会玩SQL吗?三范式.数据完整性 你真的会玩SQL吗?查询指定节点及其所有父节 ...

  7. java netty socket库和自定义C#socket库利用protobuf进行通信完整实例

    之前的文章讲述了socket通信的一些基本知识,已经本人自定义的C#版本的socket.和java netty 库的二次封装,但是没有真正的发表测试用例. 本文只是为了讲解利用protobuf 进行C ...

  8. Rafy 框架 - 执行SQL或存储过程

    有时候,开发者不想通过实体来操作数据库,而是希望通过 SQL 语句或存储过程来直接访问数据库.Rafy 也提供了一组 API 来方便实现这类需求. IDbAccesser 接口 为了尽量屏蔽各数据库中 ...

  9. C#基础-MD5验证

    一.前言 MD5验证主要用于更新文件功能方面,服务器告知客户端要下载哪些更新文件并提供给客户端其MD5值,客户端从服务器将更新文件下载到本地并计算下载文件的MD5值,将本地接收的MD5值与服务器提供的 ...

  10. [python] File path and system path

    1. get files in the current directory with the assum that the directory is like this: a .py |----dat ...