Python基本数据类型（一）

一、int的函数说明（部分函数Python2特有，Python3已删除，部分函数Python3新增；） 

class int(object):
    """
    int(x=0) -> int or long
    int(x=0) -> integer （Python3）
    
    Python2和Python3的用法一致，在Python2中，主要将数字或字符串转换为整数，如果没有给出参数，则返回0；如果x是浮点数，则先截断小数点在进行转换；如果x在整数范围之外，函数将返回long；在Python3中，主要将一个数字或字符串转换为整数，如果没有参数，返回0；如果x是一个数，返回X __int__()；如果x是浮点数，则先截断小数点在进行转换；
    例如（python2）：
    >>> int()
    >>> int(1.9)
    >>> int(2**63)
    9223372036854775808L
    >>> int(x = 0)
    >>> int(x = 1.9)
    >>> int(x = 2**63)
    9223372036854775808L
    
    例如（python3）：
    >>> int()
    >>> int(1.9)
    >>> int(2**63)
    >>> int(x = 0)
    >>> int(x = 1.9)
    >>> int(x = 2**63)
    int(x, base=10) -> int or long
    int(x, base=10) -> integer
    
    Python2和Python3的用法一致，主要将浮点数或数字字符串转换为整数，如果参数x不是一个数字，必须是字符串、数组bytes或bytearray类型，可以在x可以在前面加上“+”或“-”来表示正数及负数；base参数必须是整数，表示字符串参数的进制，有效值为0和2-36，默认10就是表示使用十进制；当它是2时，表示二进制的字符串转换。当它是8时，表示是八进制的字符串转换。当它是16时，表示是十六进制的字符串转换。当它是0时，它表示不是0进制，而是按照十进制进行转换；
    例如：
    >>> int('100',base = 2)
    >>> int('100',base = 0)
    >>> int('100',base = 8)
    >>> int('100',base = 10)
    >>> int('a',base = 10)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: invalid literal for int() with base 10: 'a'
    不是数字字符串会产生报错；
    >>> int('-100',base = 8)
    -64
    >>> int('+100',base = 8)
    """
    def bit_length(self): # real signature unknown; restored from __doc__
        """
        int.bit_length() -> int
        
        返回表示该数字的时占用的最少位数；
        例如：
        >>> int(10)
        >>> (10).bit_length()
        >>> bin(10)
        '0b1010'
        """
        return 0
    def conjugate(self, *args, **kwargs): # real signature unknown
        """ 返回该复数的共轭复数； """
        pass
    def from_bytes(cls, bytes, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        int.from_bytes(bytes, byteorder, *, signed=False) -> int （Python3新增）
        
        返回给定的字节数组所表示的整数；
        bytes参数必须是一个类似字节的对象（例如字节或bytearray）；
        byteorder参数确定用于表示整数的字节顺序。如果字节序是'big'，最高有效字节排在在字节数组最开始。如果字节序是'little'，则最高有效字节排在字节数组的结尾。如果要要求按照主机系统的本地字节顺序排序，则需使用'sys.byteorder'作为字节顺序值；
        signed参数指示是否使用二进制补码表示整数；
        例如：
        >>> int.from_bytes(b'\x00\x10', byteorder='big')
        >>> int.from_bytes(b'\x00\x10', byteorder='little')
        >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
        -1024
        >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
        >>> int.from_bytes([255, 0, 0], byteorder='big')
        """
        pass
    def to_bytes(self, length, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        int.to_bytes(length, byteorder, *, signed=False) -> bytes （Python3新增）
        
        返回一个表示整数的字节数组；        
        用字节长度表示整数。如果整数不能用给定的字节数表示，则会引发OverflowError；        
        byteorder参数确定用于表示整数的字节顺序。如果字节序是'big'，最高有效字节排在在字节数组最开始。如果字节序是'little'，则最高有效字节排在字节数组的结尾。如果要要求按照主机系统的本地字节顺序排序，则需使用'sys.byteorder'作为字节顺序值；
        signed参数确定是否使用二进制补码表示整数。如果signed是False，并给出一个负整数，则会引发一个OverflowError。 signed的默认值为False；
        例如：
        >>> (1024).to_bytes(2, byteorder='big')
        b'\x04\x00'
        >>> (1024).to_bytes(10, byteorder='big')
        b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
        >>> (-1024).to_bytes(10, byteorder='big', signed=True)
        b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
        >>> x = 1000
        >>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
        b'\xe8\x03
        >>> (-1024).to_bytes(10, byteorder='big')
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        OverflowError: can't convert negative int to unsigned
        """
        pass
    def __abs__(self): # real signature unknown; restored from __doc__
        """ 
        x.__abs__() 等同于 abs(x) 
        
        返回绝对值，参数可以是：负数、正数、浮点数或者长整形；
        例如：
        >>> x = -2
        >>> x.__abs__()
        >>> abs(x)
        """
        pass
    def __add__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__add__(y) 等同于 x+y 

        加法；
        例如：
        >>> x = 2
        >>> y = 4
        >>> x.__add__(y)
        >>> x + y
               
        """
        pass
    def __and__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__and__(y) 等同于 x&y 

        按位与；
        例如：
        >>> x = 60
        >>> y = 13
        >>> bin(x)
        '0b111100'
        >>> bin(y)
        '0b1101'
        >>> x.__and__(y)
        >>> x & y
        """
        pass
    def __cmp__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__cmp__(y) <==> cmp(x,y) （Python2特有，Python3已删除） 

        比较两个对象x和y，如果x < y ,返回负数；x == y, 返回0；x > y,返回正数；
        例如：
        >>> x = 10
        >>> y = 20
        >>> x.__cmp__(y)
        -1
        >>> y.__cmp__(x)
        >>> cmp(x,y)
        -1
        >>> cmp(y,x)
        >>> y = 10
        >>> x.__cmp__(y)
        >>> cmp(x,y)
        """
        pass
    def __coerce__(self, y): # real signature unknown; restored from __doc__
        """
        x.__coerce__(y) <==> coerce(x, y) （Python2特有，Python3已删除） 

        强制生成一个元组；
        例如：
        >>> x = 10
        >>> y = 20
        >>> x.__coerce__(y)
        (10, 20)
        >>> coerce(x,y)
        (10, 20)
        """
        pass
    def __bool__(self, *args, **kwargs): # real signature unknown
        """
        self != 0 （Python3新增）  

        布尔型判断；
        例如：
        >>> a = True
        >>> b = False
        >>> a.__bool__()
        True
        >>> b.__bool__()
        False
        >>> x = 0
        >>> b = x > 1
        >>> b.__bool__()
        False    
        """
        pass
    def __ceil__(self, *args, **kwargs): # real signature unknown
        """ 
        返回数字的上入整数，如果数值是小数，则返回的数值是整数加一，配合math函数使用； （Python3新增）
        例如：
        >>> import math
        >>> math.ceil(4.1)

        """
    def __divmod__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__divmod__(y) 等同于 divmod(x, y)

        数字相除，将商和余数返回一个数组，相当于 x//y ，返回（商，余数）
        例如：
        >>> x = 10
        >>> y = 11
        >>> x.__divmod__(y)
        (0, 10)
        >>> divmod(x,y)
        (0, 10)
        """
        pass
    def __div__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__div__(y) 等同于 x/y （Python2特有，Python3已删除）
 
        数字相除，返回商；
        例如：
        >>> x = 10
        >>> y = 9
        >>> x.__div__(y)
        >>> div(x,y)
        >>> x / y
        """
        pass
    def __eq__(self, *args, **kwargs): # real signature unknown
        """ 
        Return self==value. （Python3新增）   

        用于判断数值是否相等，返回布尔值，等价于 x == y；
        例如：
        >>> x = 10
        >>> y = 11
        >>> x.__eq__(y)
        False
        >>> z = 10
        >>> x.__eq__(z)
        True
        """
        pass
    def __float__(self): # real signature unknown; restored from __doc__
        """ 
        x.__float__() <==> float(x) 

        转换为浮点类型，即小数型；
        例如：
        >>> x = 1.4
        >>> x.__float__()
        1.4
        >>> float(x)
        1.4
        >>> y = 2
        >>> y.__float__()
        2.0
        >>> float(y)
        2.0
        """
        pass
    def __floordiv__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__floordiv__(y) 等同于 x//y 

        用于数字相除取其商，例如， 4//3 返回 1；
        例如：
        >>> x = 9
        >>> y = 7
        >>> x.__floordiv__(y)
        >>> x // y
        """
        pass
    def __floor__(self, *args, **kwargs): # real signature unknown
        """ 
        Flooring an Integral returns itself. （Python3新增）
  
        返回数字的下舍整数，配合math函数使用；
        例如：
        >>> import math
        >>> x = 1.54
        >>> math.floor(x)
        """
        pass
    def __format__(self, *args, **kwargs): # real signature unknown
        """
        无意义；
        """
        pass
    def __getattribute__(self, name): # real signature unknown; restored from __doc__
        """ 
        x.__getattribute__('name') 等同于 x.name 
        """
        pass
    def __getnewargs__(self, *args, **kwargs): # real signature unknown
        """
        内部调用 __new__方法或创建对象时传入参数使用；
        """
        pass
    def __ge__(self, *args, **kwargs): # real signature unknown
        """ 
        Return self>=value. （Python3新增）   

        数字判断大于等于，相当于 x >= y，返回布尔值；
        例如：
        >>> x = 4
        >>> y = 4
        >>> x.__ge__(y)
        True
        >>> x >= y
        True
        >>> x = 5
        >>> x.__ge__(y)
        True
        >>> x >= y
        True
        >>> y = 7
        >>> x.__ge__(y)
        False
        >>> x >= y
        False
        """
        pass
    def __gt__(self, *args, **kwargs): # real signature unknown
        """ 
        Return self>value. （Python3新增） 
  
        数字大于判断，相当于 x > y，返回布尔值；
        例如：
        >>> x = 10
        >>> y = 9
        >>> x.__gt__(y)
        True
        >>> y.__gt__(x)
        False
        >>> x > y
        True
        >>> y < x
        False
        >>> x = 4
        >>> y = 4
        >>> x > y
        False
        >>> x.__gt__(y)
        False
        """
        pass
    def __hash__(self): # real signature unknown; restored from __doc__
        """ 
        x.__hash__() <==> hash(x) 

        如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等；
        """
        pass
    def __hex__(self): # real signature unknown; restored from __doc__
        """ 
        x.__hex__() 等同于 hex(x) 

        返回当前数的十六进制表示； （Python2特有，Python3已删除）
        例如：
        >>> x = 100
        >>> x.__hex__()
        '0x64'
        >>> hex(x)
        '0x64'
        """
        pass
    def __index__(self): # real signature unknown; restored from __doc__
        """ 
        x[y:z] <==> x[y.__index__():z.__index__()] 

        用于切片，数字无意义；
        """
        pass
    def __init__(self, x, base=10): # known special case of int.__init__
        """
        构造方法，执行 x = 123 或 x = int(10) 时，自动调用；
        """
        pass
    def __int__(self): # real signature unknown; restored from __doc__
        """ 
        x.__int__() 等同于 int(x) 

        转换为整数；
        """
        pass
    def __invert__(self): # real signature unknown; restored from __doc__
        """ 
        x.__invert__() 等同于 ~x 

        数字取反操作；
        例如：
        >>> x = 10
        >>> x.__invert__()
        -11
        >>> ~x
        -11
        """
        pass
    def __long__(self): # real signature unknown; restored from __doc__
        """ 
        x.__long__() 等同于 long(x) 

        转换为长整数； （Python2特有，Python3已删除）
        例如：
        >>> x = 10
        >>> x.__long__()
        10L
        >>> long(x)
        10L
        """
        pass
    def __le__(self, *args, **kwargs): # real signature unknown
        """ 
        Return self<=value. （Python3新增）  

        数字小于等于判断，相当于 x <= y，返回布尔值；
        例如：
        >>> x = 2
        >>> y = 4
        >>> x.__le__(y)
        True
        >>> x <= y
        True
        >>> y.__le__(x)
        False
        >>> y <= x
        False
        >>> y = 2
        >>> x.__le__(y)
        True
        >>> x <= y
        True
        """
        pass
    def __lshift__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__lshift__(y) 等同于 x<<y 

        实现一个位左移操作的功能，即x向左移动y位；
        例如：
        >>> x = 2
        >>> y = 1
        >>> bin(x)
        '0b10'
        >>> x.__lshift__(y)
        >>> z = x.__lshift__(y)
        >>> bin(y)
        '0b100'
        >>> y = 2
        >>> z = x.__lshift__(y)
        >>> x.__lshift__(y)
        >>> bin(z)
        '0b1000'
        """
        pass
    def __lt__(self, *args, **kwargs): # real signature unknown
        """ 
        Return self<value. 

        数字小于判断，相当于 x < y，返回布尔值； （Python3新增）
        例如：
        >>> x = 2
        >>> y = 4
        >>> x.__lt__(y)
        True
        >>> x < y
        True
        >>> y.__lt__(x)
        False
        >>> y < x
        False
        """
        pass
    def __mod__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__mod__(y) 等同于 x%y 

        实现一个“%”操作符代表的取模操作；
        例如：
        >>> x = 7
        >>> y = 3
        >>> x.__mod__(y)
        >>> x % y
        """
        pass
    def __mul__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__mul__(y) 等同于 x*y
 
        实现乘法；
        例如：
        >>> x = 2
        >>> y = 4
        >>> x.__mul__(y)
        >>> x * y
        """
        pass
    def __neg__(self): # real signature unknown; restored from __doc__
        """ 
        x.__neg__() 等同于 -x 

        数字取负操作；
        例如：
        >>> x = 3
        >>> x.__neg__()
        -3
        >>> -x
        -3
        """
        pass
    @staticmethod # known case of __new__
    def __new__(S, *more): # real signature unknown; restored from __doc__
        """ 
        T.__new__(S, ...) -> a new object with type S, a subtype of T 
        __new__方法接受的参数虽然也是和__init__一样，但__init__是在类实例创建之后调用，而__new__方法正是创建这个类实例的方法；__new__方法主要是当你继承一些不可变的class时(比如int, str, tuple)，提供给你一个自定义这些类的实例化过程的途径；
        """
        pass
    def __ne__(self, *args, **kwargs): # real signature unknown
        """ 
        Return self!=value. 

        数字不相等判断，相当于x != y，返回布尔值； （Python3新增）
        例如：
        >>> x = 2
        >>> y = 4
        >>> x.__ne__(y)
        True
        >>> x != y
        True
        >>> y =2
        >>> x.__ne__(y)
        False
        >>> x != y
        False
        """
        pass
    def __nonzero__(self): # real signature unknown; restored from __doc__
        """ 
        x.__nonzero__() 等同于 x != 0 

        数字不等于0判断，相当于x != 0，返回布尔值； （Python2特有，Python3已删除）
        例如：
        >>> x = 2
        >>> x.__nonzero__()
        True
        >>> x != 0
        True
        >>> x = 0
        >>> x.__nonzero__()
        False
        >>> x != 0
        False
        """
        pass
    def __oct__(self): # real signature unknown; restored from __doc__
        """ 
        x.__oct__() 等同于 oct(x) 

        返回当前数的八进制表示； （Python2特有，Python3已删除）
        例如：
        >>> x = 17
        >>> x.__oct__()
        '021'
        >>> oct(x)
        '021'
        """
        pass
    def __or__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__or__(y) 等同于 x|y 

        按位或；
        例如：
        >>> x = 3
        >>> y = 5
        >>> bin(x)
        '0b11'
        >>> bin(y)
        '0b101'
        >>> x.__or__(y)
        >>> x|y
        >>> a = x.__or__(y)
        >>> bin(a)
        '0b111'
        """
        pass
    def __pos__(self): # real signature unknown; restored from __doc__
        """ 
        x.__pos__() 等同于 +x 

        数字取正操作；
        """
        pass
    def __pow__(self, y, z=None): # real signature unknown; restored from __doc__
        """ 
        x.__pow__(y[, z]) 等同于 pow(x, y[, z]) 

        幂，次方,计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z，也可以配合math函数使用；pow()通过内置的方法直接调用，内置方法会把参数作为整型，而math模块则会把参数转换为float；
        例如：
        >>> x = 2
        >>> y = 4
        >>> pow(x,y)
        >>> z = 3
        >>> pow(x,y,z)
        >>> import math
        >>> math.pow(x,y)
        16.0
        """
        pass
    def __radd__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__radd__(y) 等同于 y+x 

        右加法；
        例如：
        >>> x = 2
        >>> y = 1
        >>> x.__radd__(y)
        >>> y + x
        """
        pass
    def __rand__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__rand__(y) 等同于 y&x 
        
        按位右与；
        例如：
        >>> x = 63
        >>> y = 13
        >>> bin(x)
        '0b111111'
        >>> bin(y)
        '0b1101'
        >>> x.__rand__(y)
        >>> y & x
        >>> a = x.__rand__(y)
        >>> bin(a)
        '0b1101'
        >>> a = x & y
        >>> bin(a)
        '0b1101'
        """
        pass
    def __rdivmod__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__rdivmod__(y) 等同于 divmod(y, x) 

        数字相除，将商和余数返回一个数组，相当于 y//x ，返回（商，余数）
        """
        pass
    def __rdiv__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__rdiv__(y) 等同于 y/x 

        数字相除，返回商； （Python2特有，Python3已删除）
        """
        pass
    def __repr__(self): # real signature unknown; restored from __doc__
        """ 
        x.__repr__() 等同于 repr(x) 

        转化为解释器可读取的形式，即转换为字符串类型；
        例如：
        >>> x = 2.0
        >>> repr(x)
        '2.0'
        >>> a = repr(x)
        >>> type(a)
        <type 'str'>
        """
        pass
    def __rfloordiv__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__rfloordiv__(y) 等同于 y//x 

        用于数字相除取其商；
        """
        pass
    def __rlshift__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__rlshift__(y) 等同于 y<<x 
        
        实现一个位左移操作的功能，即y向左移动x位；
        例如：
        >>> x = 1
        >>> y = 2
        >>> bin(y)
        '0b10'
        >>> x.__rlshift__(y)
        >>> z = x.__rlshift__(y)
        >>> bin(z)
        '0b100'
        >>> z = y << x
        >>> bin(z)
        '0b100'
        >>> x = 2
        >>> z = x.__rlshift__(y)
        >>> bin(z)
        '0b1000'
        """
        pass
    def __rmod__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__rmod__(y) 等同于 y%x 

        实现一个右“%”操作符代表的取模操作；
        """
        pass
    def __rmul__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__rmul__(y) 等同于 y*x 

        实现右乘法；
        """
        pass
    def __ror__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__ror__(y) 等同于 y|x 

        按位右或；
        """
        pass
    def __round__(self, *args, **kwargs): # real signature unknown
        """
        x.__rount__() 等同于 round( x [, n]  )

        返回浮点数x的四舍五入值，n参数表示保留的小数点位数； （Python3新增）
        例如：
        >>> x = 2.56
        >>> x.__round__()
        >>> x.__round__(1)
        2.6
        >>> x.__round__(2)
        2.56
        >>> round(x)
        >>> round(x,1)
        2.6
        >>> round(x,2)
        2.56
        """
        pass
    def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__
        """ 
        y.__rpow__(x[, z]) 等同于 pow(x, y[, z]) 

        幂，次方,计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z，也可以配合math函数使用；pow()通过内置的方法直接调用，内置方法会把参数作为整型，而math模块则会把参数转换为float；
        """
        pass
    def __rrshift__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__rrshift__(y) 等同于 y>>x 

        实现一个位右移操作的功能，即y向右移动x位；
        例如：
        >>> x = 1
        >>> y = 4
        >>> bin(y)
        '0b100'
        >>> x.__rrshift__(y)
        >>> z = x.__rrshift__(y)
        >>> bin(z)
        '0b10'
        >>> y >> x
        >>> z = y >> x
        >>> bin(z)
        '0b10'
        """
        pass
    def __rshift__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__rshift__(y) 等同于 x>>y

        实现一个位右移操作的功能，即x向右移动y位；
        例如：
        >>> x = 4
        >>> y = 1
        >>> bin(x)
        '0b100'
        >>> x.__rshift__(y)
        >>> z = x.__rrshift__(y)
        >>> bin(z)
        '0b10'
        >>> x >> y
        >>> z = x >> y
        >>> bin(z)
        '0b10'
        """
        pass
    def __rsub__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__rsub__(y) 等同于 y-x 

        右减法，相当于y减x；
        例如：
        >>> x = 4
        >>> y = 1
        >>> x.__rsub__(y)
        -3
        >>> y - x
        -3
        """
        pass
    def __rtruediv__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__rtruediv__(y) 等同于 y/x 

        右除法，相当于y除以x；
        """
        pass
    def __rxor__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__rxor__(y) 等同于 y^x 

        按位右异或，相当于y按x进行异或；
        """
        pass
    def __sizeof__(self, *args, **kwargs): # real signature unknown
        """ 
        返回内存中的大小（以字节为单位）； （Python2存在于long函数，Python3中合并进int函数）
        """
    def __str__(self): # real signature unknown; restored from __doc__
        """ 
        x.__str__() 等同于 str(x) 

        转换为人阅读的形式，如果没有适于人阅读的解释形式的话，则返回解释器课阅读的形式，即转换为字符串类型；
        例如：
        >>> x = 1
        >>> x.__str__()
        '1'
        >>> a = x.__str__()
        >>> type(a)
        <type 'str'>
        >>> a = str(x)
        >>> type(a)
        <type 'str'>
        """
        pass
    def __sub__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__sub__(y) <==> x-y 

        减法，相当于x减y；
        """
        pass
    def __truediv__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__truediv__(y) <==> x/y 

        除法，相当于x除以y；
        """
        pass
    def __trunc__(self, *args, **kwargs): # real signature unknown
        """ 
        返回数值被截取为整形的值，在整形中无意义；
        """
        pass
    def __xor__(self, y): # real signature unknown; restored from __doc__
        """ 
        x.__xor__(y) 等同于 x^y 

        按位异或，相当于x按y进行异或；
        """
        pass
    denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """
    分母，等于1；
    """
    imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """
    虚数，无意义；
    """
    numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """
    分子，等于数字大小；
    """
    real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """
    实数，无意义；
    """

int