精华内容
下载资源
问答
  • 整数整数是没有小数部分数值,与数学上一样:>>> 11>>> -1-1整数没有大小限制,只要你内存足够大,就可以创建任意大小整数:>>> ...

    Python内置了整数、复数、浮点数三种数字类型。

    整数

    整数是没有小数部分的数值,与数学上的一样:

    >>> 1

    1

    >>> -1

    -1

    整数没有大小限制,只要你的内存足够大,就可以创建任意大小的整数:

    >>> 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

    1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

    除了十进制外,Python还允许你使用二进制、八进制和十六进制创建整数:

    #二进制:

    >>> 0b10

    2

    >>> 0B10

    2

    #八进制:

    >>> 0o10

    8

    >>> 0O10

    8

    #十六进制:

    >>> 0x10

    16

    >>> 0X10

    16

    如果你不明白什么是进制,可以去查阅其他资料,或者直接略过就好了。

    浮点数

    浮点数是带有小数部分的数值,类似于数学上的小数:

    >>> 1.1

    1.1

    如果你要创建的浮点数的小数部分或整数部分是0,那么可以省略不写,Python会自动帮你填上:

    >>> .1

    0.1

    >>> 1.

    1.0

    与整数不同的是,浮点数的有效长度只有17位,对于超出的部分,Python会进行四舍五入操作:

    >>> 1111.1111111111111111111111111111111111111

    1111.111111111111

    >>> 1111.8888888888888888888888888888888888888

    1111.888888888889

    需要注意的是,浮点数的运算不精确,请尽量不要使用浮点数进行运算:

    >>> 1.75 * 2.3

    4.0249999999999995

    算数运算符

    Python提供了一些基本的算数运算符,你可以通过这些运算符进行算数运算:

    >>> 5 + 1

    6

    >>> 5 - 1

    4

    >>> 5 * 2

    10

    >>> 5 / 2

    2.5

    >>> 5 // 2

    2

    >>> 5 % 2

    1

    >>> 5 ** 2

    25

    需要注意除法操作,/我们称作真除法,对于真除操作,Python始终会得到浮点数:

    >>> 1 / 2

    0.5

    >>> 1 / 1

    1.0

    //我们称作整除,对于整除操作,如果有小数部分的话,Python会省略小数向下取整:

    >>> 5 // 2

    2

    >>> 5.0 // 2.0

    2.0

    比较运算符

    除了算数运算符外,Python还提供了比较运算符,比较运算符会返回True或False:

    >>> 1 < 5

    True

    >>> 1 > 5

    False

    >>> 1 <= 5

    True

    >>> 1 >= 5

    False

    >>> 5 == 5

    True

    >>> 5 != 5

    False

    True和False很好理解,如果比较的条件满足,就返回True,否则返回False。

    展开全文
  • 在实际开发中,可能数据在流转或者传递环节中,需要对数值类型做转换(比如:将varchar类型的"3.14",转为浮点类型的3.14)如何使用SQL语句实现此种场景的数据转换呢?解决方案数据转换可以用到MySQL自带的函数 cast()...

    在实际开发中,可能数据在流转或者传递环节中,需要对数值类型做转换(比如:将varchar类型的"3.14",转为浮点类型的3.14)

    如何使用SQL语句实现此种场景的数据转换呢?

    解决方案

    数据转换可以用到MySQL自带的函数 cast()或者convert(),浮点类型可以使用decimal()函数。

    示例如下:

    1)不保留小数的情况

    select cast("3.14159" as decimal);        # 运行结果:3select convert("3.14159", decimal);       # 运行结果:3

    2)保留小数的情况

    5b0759b3e2847fb4dce50b25062d48c9.gifselect cast("3.14159" as decimal(10, 2));  # 运行结果:3.14select convert("3.14159", decimal(10, 2)); # 运行结果:3.14select cast("3.14159" as decimal(10, 3));  # 运行结果:3.142select convert("3.14159", decimal(10, 3)); # 运行结果:3.142select cast("3.14159" as decimal(10, 4));  # 运行结果:3.1416select convert("3.14159", decimal(10, 4)); # 运行结果:3.1416select cast("3.14159" as decimal(10, 5));  # 运行结果:3.14159select convert("3.14159", decimal(10, 5)); # 运行结果:3.14159

    5b0759b3e2847fb4dce50b25062d48c9.gif

    补充说明

    demical(M,D)函数采取四舍五入的方式,保留小数位数。

    M:浮点型数值的总位数;

    D:浮点型数值的小数保留位数。

    欢迎来到技术之家,

    如需转载,烦请保留本文链接和出处:http://www.jszja.com/contents/97/1332.html

    您的支持将是我们前进的动力!如对本篇文章有疑问或建议,请通过本站下方邮箱联系我们,让技术之家每天进步一点点!(●'◡'●)

    展开全文
  • 一、数字数据类型Python的数字数据类型用于存储数值,它是可变的数据类型,这意味着改变数字数据类型,则需要一个新分配的对象;Python支持四种不同的数值类型:整型(Int):通常被称为是整型或整数,是正或负整数...

    一、数字数据类型

    Python的数字数据类型用于存储数值,它是不可变的数据类型,这意味着改变数字数据类型,则需要一个新分配的对象;

    Python支持四种不同的数值类型:整型(Int):通常被称为是整型或整数,是正或负整数,不带小数点;

    长整型(long integers):无限大小的整数,整数最后是一个大写或小写的L;

    浮点型(floating point real values):浮点型由整数部分与小数部分组成,浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x 102 = 250);

    复数(complex numbers):复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型;

    注:在Python 3里,只有一种整数类型int,表示为长整型,没有python2中的Long类型;

    例如:

    intlongfloatcomplex

    1051924361L03.14j

    100-0x19323L15.245.j

    -7860122L-21.99.322e-36j

    800xDEFABCECBDAECBFBAEl32.3+e18.876j

    -490535633629843L-90-.6545+0J

    -0x260-052318172735L-3.25E+1013e+26J

    0x69-4721885298529L70.2-E124.53e-7j

    长整型也可以使用小写"l",但是还是建议您使用大写"L",避免与数字"1"混淆。因此,还是使用"L"来显示长整型;

    复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型;

    在Python中整型(int)最常用,在32位机器上,整数的位数为32位,取值范围为-2**31~2**31-1,即-2147483648~2147483647;在64位系统上,整数的位数为64位,取值范围为-2**63~2**63-1,即-9223372036854775808~9223372036854775807;

    二、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()

    0

    >>> int(1.9)

    1

    >>> int(2**63)

    9223372036854775808L

    >>> int(x = 0)

    0

    >>> int(x = 1.9)

    1

    >>> int(x = 2**63)

    9223372036854775808L

    例如(python3):

    >>> int()

    0

    >>> int(1.9)

    1

    >>> int(2**63)

    9223372036854775808

    >>> int(x = 0)

    0

    >>> int(x = 1.9)

    1

    >>> int(x = 2**63)

    9223372036854775808

    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)

    4

    >>> int('100',base = 0)

    100

    >>> int('100',base = 8)

    64

    >>> int('100',base = 10)

    100

    >>> int('a',base = 10)

    Traceback (most recent call last):

    File "", line 1, in 

    ValueError: invalid literal for int() with base 10: 'a'

    不是数字字符串会产生报错;

    >>> int('-100',base = 8)

    -64

    >>> int('+100',base = 8)

    64

    """

    def bit_length(self): # real signature unknown; restored from __doc__

    """

    int.bit_length() -> int

    返回表示该数字的时占用的最少位数;

    例如:

    >>> int(10)

    10

    >>> (10).bit_length()

    4

    >>> 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')

    16

    >>> int.from_bytes(b'\x00\x10', byteorder='little')

    4096

    >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)

    -1024

    >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)

    64512

    >>> int.from_bytes([255, 0, 0], byteorder='big')

    16711680

    """

    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 "", line 1, in 

    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__()

    2

    >>> abs(x)

    2

    """

    pass

    def __add__(self, y): # real signature unknown; restored from __doc__

    """

    x.__add__(y) 等同于 x+y

    加法;

    例如:

    >>> x = 2

    >>> y = 4

    >>> x.__add__(y)

    6

    >>> x + y

    6

    """

    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)

    12

    >>> x & y

    12

    """

    pass

    def __cmp__(self, y): # real signature unknown; restored from __doc__

    """

    x.__cmp__(y) <==> cmp(x,y) (Python2特有,Python3已删除)

    比较两个对象x和y,如果x  y,返回正数;

    例如:

    >>> x = 10

    >>> y = 20

    >>> x.__cmp__(y)

    -1

    >>> y.__cmp__(x)

    1

    >>> cmp(x,y)

    -1

    >>> cmp(y,x)

    1

    >>> y = 10

    >>> x.__cmp__(y)

    0

    >>> cmp(x,y)

    0

    """

    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)

    5

    """

    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)

    1

    >>> div(x,y)

    >>> x / y

    1

    """

    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)

    1

    >>> x // y

    1

    """

    pass

    def __floor__(self, *args, **kwargs): # real signature unknown

    """

    Flooring an Integral returns itself. (Python3新增)

    返回数字的下舍整数,配合math函数使用;

    例如:

    >>> import math

    >>> x = 1.54

    >>> math.floor(x)

    1

    """

    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 

    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<

    实现一个位左移操作的功能,即x向左移动y位;

    例如:

    >>> x = 2

    >>> y = 1

    >>> bin(x)

    '0b10'

    >>> x.__lshift__(y)

    4

    >>> z = x.__lshift__(y)

    >>> bin(y)

    '0b100'

    >>> y = 2

    >>> z = x.__lshift__(y)

    >>> x.__lshift__(y)

    8

    >>> bin(z)

    '0b1000'

    """

    pass

    def __lt__(self, *args, **kwargs): # real signature unknown

    """

    Return self

    数字小于判断,相当于 x 

    例如:

    >>> x = 2

    >>> y = 4

    >>> x.__lt__(y)

    True

    >>> x 

    True

    >>> y.__lt__(x)

    False

    >>> y 

    False

    """

    pass

    def __mod__(self, y): # real signature unknown; restored from __doc__

    """

    x.__mod__(y) 等同于 x%y

    实现一个“%”操作符代表的取模操作;

    例如:

    >>> x = 7

    >>> y = 3

    >>> x.__mod__(y)

    1

    >>> x % y

    1

    """

    pass

    def __mul__(self, y): # real signature unknown; restored from __doc__

    """

    x.__mul__(y) 等同于 x*y

    实现乘法;

    例如:

    >>> x = 2

    >>> y = 4

    >>> x.__mul__(y)

    8

    >>> x * y

    8

    """

    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)

    7

    >>> x|y

    7

    >>> 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)

    16

    >>> z = 3

    >>> pow(x,y,z)

    1

    >>> 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)

    3

    >>> y + x

    3

    """

    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)

    13

    >>> y & x

    13

    >>> 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)

    """

    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<

    实现一个位左移操作的功能,即y向左移动x位;

    例如:

    >>> x = 1

    >>> y = 2

    >>> bin(y)

    '0b10'

    >>> x.__rlshift__(y)

    4

    >>> z = x.__rlshift__(y)

    >>> bin(z)

    '0b100'

    >>> z = y <

    >>> 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__()

    3

    >>> x.__round__(1)

    2.6

    >>> x.__round__(2)

    2.56

    >>> round(x)

    3

    >>> 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)

    2

    >>> z = x.__rrshift__(y)

    >>> bin(z)

    '0b10'

    >>> y >> x

    2

    >>> 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)

    2

    >>> z = x.__rrshift__(y)

    >>> bin(z)

    '0b10'

    >>> x >> y

    2

    >>> 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)

    >>> a = str(x)

    >>> type(a)

    """

    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

    """

    实数,无意义;

    """

    三、long的函数说明(函数与方法与int一致,Python3已与int类型进行合并;)

    class long(object):

    """

    long(x=0) -> long

    long(x, base=10) -> long

    Convert a number or string to a long integer, or return 0L if no arguments

    are given.  If x is floating point, the conversion truncates towards zero.

    If x is not a number or if base is given, then x must be a string or

    Unicode object representing an integer literal in the given base.  The

    literal can be preceded by '+' or '-' and be surrounded by whitespace.

    The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to

    interpret the base from the string as an integer literal.

    >>> int('0b100', base=0)

    4L

    """

    def bit_length(self): # real signature unknown; restored from __doc__

    """

    long.bit_length() -> int or long

    Number of bits necessary to represent self in binary.

    >>> bin(37L)

    '0b100101'

    >>> (37L).bit_length()

    6

    """

    return 0

    def conjugate(self, *args, **kwargs): # real signature unknown

    """ Returns self, the complex conjugate of any long. """

    pass

    def __abs__(self): # real signature unknown; restored from __doc__

    """ x.__abs__() <==> abs(x) """

    pass

    def __add__(self, y): # real signature unknown; restored from __doc__

    """ x.__add__(y) <==> x+y """

    pass

    def __and__(self, y): # real signature unknown; restored from __doc__

    """ x.__and__(y) <==> x&y """

    pass

    def __cmp__(self, y): # real signature unknown; restored from __doc__

    """ x.__cmp__(y) <==> cmp(x,y) """

    pass

    def __coerce__(self, y): # real signature unknown; restored from __doc__

    """ x.__coerce__(y) <==> coerce(x, y) """

    pass

    def __divmod__(self, y): # real signature unknown; restored from __doc__

    """ x.__divmod__(y) <==> divmod(x, y) """

    pass

    def __div__(self, y): # real signature unknown; restored from __doc__

    """ x.__div__(y) <==> x/y """

    pass

    def __float__(self): # real signature unknown; restored from __doc__

    """ x.__float__() <==> float(x) """

    pass

    def __floordiv__(self, y): # real signature unknown; restored from __doc__

    """ x.__floordiv__(y) <==> x//y """

    pass

    def __format__(self, *args, **kwargs): # real signature unknown

    pass

    def __getattribute__(self, name): # real signature unknown; restored from __doc__

    """ x.__getattribute__('name') <==> x.name """

    pass

    def __getnewargs__(self, *args, **kwargs): # real signature unknown

    pass

    def __hash__(self): # real signature unknown; restored from __doc__

    """ x.__hash__() <==> hash(x) """

    pass

    def __hex__(self): # real signature unknown; restored from __doc__

    """ x.__hex__() <==> hex(x) """

    pass

    def __index__(self): # real signature unknown; restored from __doc__

    """ x[y:z] <==> x[y.__index__():z.__index__()] """

    pass

    def __init__(self, x=0): # real signature unknown; restored from __doc__

    pass

    def __int__(self): # real signature unknown; restored from __doc__

    """ x.__int__() <==> int(x) """

    pass

    def __invert__(self): # real signature unknown; restored from __doc__

    """ x.__invert__() <==> ~x """

    pass

    def __long__(self): # real signature unknown; restored from __doc__

    """ x.__long__() <==> long(x) """

    pass

    def __lshift__(self, y): # real signature unknown; restored from __doc__

    """ x.__lshift__(y) <==> x<

    pass

    def __mod__(self, y): # real signature unknown; restored from __doc__

    """ x.__mod__(y) <==> x%y """

    pass

    def __mul__(self, y): # real signature unknown; restored from __doc__

    """ x.__mul__(y) <==> x*y """

    pass

    def __neg__(self): # real signature unknown; restored from __doc__

    """ x.__neg__() <==> -x """

    pass

    @staticmethod # known case of __new__

    def __new__(S, *more): # real signature unknown; restored from __doc__

    """ T.__new__(S, ...) -> a new object with type S, a subtype of T """

    pass

    def __nonzero__(self): # real signature unknown; restored from __doc__

    """ x.__nonzero__() <==> x != 0 """

    pass

    def __oct__(self): # real signature unknown; restored from __doc__

    """ x.__oct__() <==> oct(x) """

    pass

    def __or__(self, y): # real signature unknown; restored from __doc__

    """ x.__or__(y) <==> x|y """

    pass

    def __pos__(self): # real signature unknown; restored from __doc__

    """ x.__pos__() <==> +x """

    pass

    def __pow__(self, y, z=None): # real signature unknown; restored from __doc__

    """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """

    pass

    def __radd__(self, y): # real signature unknown; restored from __doc__

    """ x.__radd__(y) <==> y+x """

    pass

    def __rand__(self, y): # real signature unknown; restored from __doc__

    """ x.__rand__(y) <==> y&x """

    pass

    def __rdivmod__(self, y): # real signature unknown; restored from __doc__

    """ x.__rdivmod__(y) <==> divmod(y, x) """

    pass

    def __rdiv__(self, y): # real signature unknown; restored from __doc__

    """ x.__rdiv__(y) <==> y/x """

    pass

    def __repr__(self): # real signature unknown; restored from __doc__

    """ x.__repr__() <==> repr(x) """

    pass

    def __rfloordiv__(self, y): # real signature unknown; restored from __doc__

    """ x.__rfloordiv__(y) <==> y//x """

    pass

    def __rlshift__(self, y): # real signature unknown; restored from __doc__

    """ x.__rlshift__(y) <==> y<

    pass

    def __rmod__(self, y): # real signature unknown; restored from __doc__

    """ x.__rmod__(y) <==> y%x """

    pass

    def __rmul__(self, y): # real signature unknown; restored from __doc__

    """ x.__rmul__(y) <==> y*x """

    pass

    def __ror__(self, y): # real signature unknown; restored from __doc__

    """ x.__ror__(y) <==> y|x """

    pass

    def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__

    """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """

    pass

    def __rrshift__(self, y): # real signature unknown; restored from __doc__

    """ x.__rrshift__(y) <==> y>>x """

    pass

    def __rshift__(self, y): # real signature unknown; restored from __doc__

    """ x.__rshift__(y) <==> x>>y """

    pass

    def __rsub__(self, y): # real signature unknown; restored from __doc__

    """ x.__rsub__(y) <==> y-x """

    pass

    def __rtruediv__(self, y): # real signature unknown; restored from __doc__

    """ x.__rtruediv__(y) <==> y/x """

    pass

    def __rxor__(self, y): # real signature unknown; restored from __doc__

    """ x.__rxor__(y) <==> y^x """

    pass

    def __sizeof__(self, *args, **kwargs): # real signature unknown

    """ Returns size in memory, in bytes """

    pass

    def __str__(self): # real signature unknown; restored from __doc__

    """ x.__str__() <==> str(x) """

    pass

    def __sub__(self, y): # real signature unknown; restored from __doc__

    """ x.__sub__(y) <==> x-y """

    pass

    def __truediv__(self, y): # real signature unknown; restored from __doc__

    """ x.__truediv__(y) <==> x/y """

    pass

    def __trunc__(self, *args, **kwargs): # real signature unknown

    """ Truncating an Integral returns itself. """

    pass

    def __xor__(self, y): # real signature unknown; restored from __doc__

    """ x.__xor__(y) <==> x^y """

    pass

    denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    """the denominator of a rational number in lowest terms"""

    imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    """the imaginary part of a complex number"""

    numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    """the numerator of a rational number in lowest terms"""

    real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

    """the real part of a complex number"""

    四、float的函数说明(函数与方法的使用与int类似;)

    class float(object):

    """

    float(x) ->

    将字符串或数字转换为浮点数;

    """

    def as_integer_ratio(self): # real signature unknown; restored from __doc__

    """

    float.as_integer_ratio() -> (int, int)

    获取值的最简化结果,返回一对整数,其比例完全等于原始浮点数,并使用正分母;在无穷大上产生OverflowError,在NaNs上产生ValueError;

    例如:

    >>> (10.0).as_integer_ratio()

    (10, 1)

    >>> (0.0).as_integer_ratio()

    (0, 1)

    >>> (-.25).as_integer_ratio()

    (-1, 4)

    """

    pass

    def conjugate(self, *args, **kwargs): # real signature unknown

    """

    返回该复数的共轭复数;

    """

    pass

    def fromhex(self, string): # real signature unknown; restored from __doc__

    """

    float.fromhex(string) -> float

    将十六进制转换为浮点数;

    例如:

    >>> float.fromhex('0x1.ffffp10')

    2047.984375

    >>> float.fromhex('-0x1p-1074')

    -4.9406564584124654e-324

    """

    return 0.0

    def hex(self): # real signature unknown; restored from __doc__

    """

    float.hex() -> string

    将浮点数转换为十六进制;

    例如:

    >>> (-0.1).hex()

    '-0x1.999999999999ap-4'

    >>> 3.14159.hex()

    '0x1.921f9f01b866ep+1'

    """

    return ""

    def is_integer(self, *args, **kwargs): # real signature unknown

    """

    判断是不是整数,返回布尔值;

    例如:

    >>> x = 1.1

    >>> x.is_integer()

    False

    >>> x = 2.0

    >>> x.is_integer()

    True

    """

    pass

    def __abs__(self): # real signature unknown; restored from __doc__

    """

    x.__abs__() 等同于 abs(x)

    返回绝对值,参数可以是:负数、正数、浮点数或者长×××;

    例如:

    >>> x = -1.1

    >>> x.__abs__()

    1.1

    >>> abs(x)

    1.1

    """

    pass

    def __add__(self, y): # real signature unknown; restored from __doc__

    """

    x.__add__(y) 等同于 x+y

    """

    pass

    def __coerce__(self, y): # real signature unknown; restored from __doc__

    """

    x.__coerce__(y) 等同于 coerce(x, y)

    强制生成一个元组; (Python2特有,Python3已删除)

    例如:

    >>> x = 1.1

    >>> y = 2.2

    >>> x.__coerce__(y)

    (1.1, 2.2)

    >>> coerce(x,y)

    (1.1, 2.2)

    """

    pass

    def __bool__(self, *args, **kwargs): # real signature unknown

    """

    self != 0 (Python3新增)

    布尔型判断;

    """

    pass

    def __divmod__(self, y): # real signature unknown; restored from __doc__

    """

    x.__divmod__(y) 等同于 divmod(x, y)

    数字相除,将商和余数返回一个数组,相当于 x//y ,返回(商,余数);

    例如:

    >>> x = 1.1

    >>> y = 3.3

    >>> x.__divmod__(y)

    (0.0, 1.1)

    >>> divmod(x,y)

    (0.0, 1.1)

    """

    pass

    def __div__(self, y): # real signature unknown; restored from __doc__

    """

    x.__div__(y) 等同于 x/y(Python2特有,Python3已删除)

    数字相除,返回商;

    """

    pass

    def __eq__(self, y): # real signature unknown; restored from __doc__

    """

    x.__eq__(y) 等同于 x==y

    用于判断数值是否相等,返回布尔值,等价于 x == y;

    """

    pass

    def __float__(self): # real signature unknown; restored from __doc__

    """

    x.__float__() 等同于 float(x)

    转换为浮点类型,即小数型;

    例如:

    >>> x = 2

    >>> x.__float__()

    2.0

    >>> float(x)

    2.0

    """

    pass

    def __floordiv__(self, y): # real signature unknown; restored from __doc__

    """

    x.__floordiv__(y) 等同于 x//y

    用于数字相除取其商;

    """

    pass

    def __format__(self, format_spec): # real signature unknown; restored from __doc__

    """

    float.__format__(format_spec) -> string

    无意义;

    """

    return ""

    def __getattribute__(self, name): # real signature unknown; restored from __doc__

    """

    x.__getattribute__('name') 等同于 x.name

    """

    pass

    def __getformat__(self, typestr): # real signature unknown; restored from __doc__

    """

    float.__getformat__(typestr) -> string

    你最好不要使用这个函数,它的主要存在Python中的的测试套件中;

    typestr参数必须是'double'和'float'类型;

    This function returns whichever of

    'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the

    format of floating point numbers used by the C type named by typestr.

    """

    return ""

    def __getnewargs__(self, *args, **kwargs): # real signature unknown

    """

    内部调用 __new__方法或创建对象时传入参数使用;

    """

    pass

    def __ge__(self, y): # real signature unknown; restored from __doc__

    """

    x.__ge__(y) 等同于 x>=y

    数字判断大于等于,相当于 x >= y,返回布尔值;

    """

    pass

    def __gt__(self, y): # real signature unknown; restored from __doc__

    """

    x.__gt__(y) 等同于 x>y

    数字大于判断,相当于 x > y,返回布尔值;

    """

    pass

    def __hash__(self): # real signature unknown; restored from __doc__

    """

    x.__hash__() 等同于 hash(x)

    如果对象object为哈希表类型,返回对象object的哈希值。哈希值为整数。在字典查找中,哈希值用于快速比较字典的键。两个数值如果相等,则哈希值也相等;

    """

    pass

    def __init__(self, x): # real signature unknown; restored from __doc__

    """

    构造方法,执行 x = 1.1 或 x = float(1.1) 时,自动调用;

    """

    pass

    def __int__(self): # real signature unknown; restored from __doc__

    """

    x.__int__() 等同于 int(x)

    转换为整数;

    """

    pass

    def __le__(self, y): # real signature unknown; restored from __doc__

    """

    x.__le__(y) 等同于 x<=y

    数字小于等于判断,相当于 x <= y,返回布尔值;

    """

    pass

    def __long__(self): # real signature unknown; restored from __doc__

    """

    x.__long__() 等同于 long(x)

    转换为长整数; (Python2特有,Python3已删除)

    """

    pass

    def __lt__(self, y): # real signature unknown; restored from __doc__

    """

    x.__lt__(y) 等同于 x

    数字小于判断,相当于 x 

    """

    pass

    def __mod__(self, y): # real signature unknown; restored from __doc__

    """

    x.__mod__(y) 等同于 x%y

    实现一个“%”操作符代表的取模操作;

    """

    pass

    def __mul__(self, y): # real signature unknown; restored from __doc__

    """

    x.__mul__(y) 等同于 x*y

    实现乘法;

    """

    pass

    def __neg__(self): # real signature unknown; restored from __doc__

    """

    x.__neg__() 等同于 -x

    数字取负操作;

    """

    pass

    @staticmethod # known case of __new__

    def __new__(S, *more): # real signature unknown; restored from __doc__

    """

    T.__new__(S, ...) -> a new object with type S, a subtype of T

    __new__方法接受的参数虽然也是和__init__一样,但__init__是在类实例创建之后调用,而__new__方法正是创建这个类实例的方法;__new__方法主要是当你继承一些不可变的class时(比如int, str, tuple),提供给你一个自定义这些类的实例化过程的途径;

    """

    pass

    def __ne__(self, y): # real signature unknown; restored from __doc__

    """

    x.__ne__(y) 等同于 x!=y

    数字不相等判断,相当于x != y,返回布尔值;

    """

    pass

    def __nonzero__(self): # real signature unknown; restored from __doc__

    """

    x.__nonzero__() 等同于 x != 0

    数字不等于0判断,相当于x != 0,返回布尔值; (Python2特有,Python3已删除)

    """

    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函数使用;

    """

    pass

    def __radd__(self, y): # real signature unknown; restored from __doc__

    """

    x.__radd__(y) 等同于 y+x

    右加法;

    """

    pass

    def __rdivmod__(self, y): # real signature unknown; restored from __doc__

    """

    x.__rdivmod__(y) 等同于 divmod(y, x)

    数字相除,将商和余数返回一个数组,相当于 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)

    转化为解释器可读取的形式,即转换为字符串类型;

    """

    pass

    def __rfloordiv__(self, y): # real signature unknown; restored from __doc__

    """

    x.__rfloordiv__(y) 等同于 y//x

    用于数字相除取其商;

    """

    pass

    def __rmod__(self, y): # real signature unknown; restored from __doc__

    """

    x.__rmod__(y) 等同于 y%x

    实现一个右“%”操作符代表的取模操作;

    """

    pass

    def __rmul__(self, y): # real signature unknown; restored from __doc__

    """

    x.__rmul__(y) 等同于 y*x

    实现右乘法;

    """

    pass

    def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__

    """

    y.__rpow__(x[, z]) 等同于 pow(x, y[, z])

    幂,次方,计算x的y次方,如果z在存在,则再对结果进行取模,其结果等效于pow(x,y) %z,也可以配合math函数使用;

    """

    pass

    def __rsub__(self, y): # real signature unknown; restored from __doc__

    """

    x.__rsub__(y) 等同于 y-x

    右减法,相当于y减x;

    """

    pass

    def __rtruediv__(self, y): # real signature unknown; restored from __doc__

    """

    x.__rtruediv__(y) 等同于 y/x

    右除法,相当于y除以x;

    """

    pass

    def __setformat__(self, typestr, fmt): # real signature unknown; restored from __doc__

    """

    float.__setformat__(typestr, fmt) -> None

    你最好不要使用这个函数,它的主要存在Python中的的测试套件中;

    typestr must be 'double' or 'float'.  fmt must be one of 'unknown',

    'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be

    one of the latter two if it appears to match the underlying C reality.

    Override the automatic determination of C-level floating point type.

    This affects how floats are converted to and from binary strings.

    """

    pass

    def __str__(self): # real signature unknown; restored from __doc__

    """

    x.__str__() 等同于 str(x)

    转换为人阅读的形式,如果没有适于人阅读的解释形式的话,则返回解释器课阅读的形式,即转换为字符串类型;

    """

    pass

    def __sub__(self, y): # real signature unknown; restored from __doc__

    """

    x.__sub__(y) 等同于 x-y

    减法,相当于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

    """

    返回0和x之间最接近x的积分,即返回数值被截取为×××的值;

    例如:

    >>> x = 1.1

    >>> x.__trunc__()

    1

    >>> x = 3.6

    >>> x.__trunc__()

    3

    """

    pass

    imag = 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

    """

    实数,无意义;

    """

    展开全文
  • 不带小数的,integer 的缩写,常用于数据的计算或者大小的比较2. a = 4 #整数print (type (a)) 结果为 class int #打印数据类型3、整数可以执行 +-*/# print(10/3) #小数是能完美的表示 有...

    Python常用的数据类型有很多,今天暂时介绍这三种,int(整数类型)、str(字符串)、bool(布尔类型)

    一.int(整数类型)

    1.不带小数的,integer 的缩写,常用于数据的计算或者大小的比较

    2. a = 4 #整数

    print (type (a)) 结果为 class int #打印数据类型

    3、整数可以执行 +-*/

    # print(10/3) #小数是不能完美的表示 有可能显示结果错误

    # //整除(地板除) print (10//3) 显示3

    # %计算余数 print(10%3) 显示1

    二.str(字符串)

    凡是用引号引起来的,全是字符串 包含 单引号,双引号,三个单引号,三个双引号,且为成双的 (srting)

    1.print ("文能提笔安天下,")

    print ("武能上马定乾坤.")

    print("心存谋略何人胜,")

    print("古今英雄唯是君.")

    #或者用下面的方法

    a = '''

    文能提笔安天下,

    武能上马定乾坤.

    心存谋略何人胜,

    古今英雄唯是君.

    '''

    print (a)

    #或者用下面的方法

    print ('''文能提笔安天下,

    武能上马定乾坤.

    心存谋略何人胜,

    古今英雄唯是君.

    '''

    )

    2.可进行 + 只能字符串拼接,不能与整数类型拼接; 例如 print ("axle"+2+4+5)会出现错误,str不能和int进行拼接 must be str, not int

    3. * 重复 print ("sb"*10) #打印 10次sb

    4.没有- / 运算

    三、(bool) 布尔 boolen的缩写

    真或假 ,结果只有False ,True , 该两个为关键字

    print (10 >3) True

    展开全文
  • 数据类型

    2020-12-21 15:47:34
    第 1 类:整数型(不带小数的数字):byte,short,int,long 第 2 类:浮点型(带小数的数字):float,double 第 3 类:字符型(文字,单个字符):char 第 4 类:布尔型(真和假):boolean 大家可以看到,在以上的...
  • java常用数据类型

    2021-01-09 10:42:16
    ava中,常用的数据类型主要有: 按类型分为: 第一类:数值类型 a、整数型 int 特点:只能包含整数,带小数 例如: 100,0,-20,123 b、小数型 (浮点型) double 特点:可以包含整数,也可以小数 ...
  • Python的数据类型

    千次阅读 2018-08-08 17:38:20
    Python的数据类型有数值类型、字符串类型、布尔类型、复合数据类型。 数值类型 1、 整形数据 整形数据即整数,不带小数点,但可以有正好或负号。 2、浮点数数据 浮点型数据表示一个实数,有以下两种形式...
  • 整形​整型数是不带小数部分数字。包括自然数,0及负数自然数。如: -2, 100, 0整数字面值表示方式​整数可以以二进制、十进制、八进制和十六进制方式进行表示,默认以十进制方式进行展示。十进制方式表示...
  • python的数据类型

    2019-06-14 23:45:03
    Python数据类型 整形(不带小数点) int()不是四舍五入,而是将小数部分全部去掉 布尔型:属于特殊的整数类型 Ture 对应 1 False 对应 0 可以进行加减,可进行 ture/false 因为0能...Python的数据类型的获取...
  • Python常用的数据类型

    2019-10-07 20:16:23
    Python常用的数据类型有很多,今天暂时...不带小数的,integer 的缩写,常用于数据的计算或者大小的比较2. a = 4 #整数 print (type (a)) 结果为 class int #打印数据类型 3、整数可以执行 +-*/# print(10/3) #小数...
  • PHP的数据类型

    2019-08-16 20:06:30
    带小数的是浮点类型 4、string(字符串) 可以用双引号或者单引号 表示 单引号能解析变量 双引号可以解析变量 $str=“张三”; $str=‘张三’; 转移符 $b=“我叫\ “王五””; 长文本 代码: ...
  • java的数据类型可以分为基本数据类型和引用数据类型,其中基本数据类型包括:字节型,字符型,短整型,整型,长整型,单精度型,双精度型和布尔型引用类型又可以划分为 类,接口和数组。java基本数据类型1.数值类型...
  • python核心数据类型... 整数(整型数)int整数是指不带小数部分数(自然数,0,负数自然数),如:-5,100,0,99999999999(python 整数可以很大)整型数字面值表示方式:十进制表示方式:10, 200, -1, 999999...
  • python基本数据类型

    2019-01-28 13:32:56
    float:浮点型,只要是带小数的类型都是浮点型 字符串: str:带引号,单引号和双引号可以互换,如对话中存在双引号,则字符串使用单引号,三引号指的是说明 布尔类型 bool:布尔类型分为true和false两种true为真,...
  • 然而,它们只是为了存储小数部分,也可以使用DEClMAL 存储比 BIGINT还大整数。 MySQL 既支持精确类型,也支持精确类型。FLOAT 和 DOUBLE 类型支持使用标准浑点运算进行近似计算。如果需要知道浮点运算是怎么...
  • Python核心数据类型

    2019-09-21 03:23:39
    ​ 整型数是不带小数部分数字。包括自然数,0及负数自然数。如: -2, 100, 0 整数字面值表示方式 ​ 整数可以以二进制、十进制、八进制和十六进制方式进行表示,默认以十进制方式进行展示。 十进制方式...
  • 数据的类型转换

    2018-10-26 13:45:05
    显示转换 —— 转数字 —— Number() 如果转换内容可以转成数字,那么就直接返回这个内容对应数字 如果在内容中出现小数,那么小数会保留 ... 如果小数,那么会去掉小数,转成整数(向下取整) pars...
  • Java数据类型

    2014-06-06 17:40:11
    整数类型 当数据不带小数或分数时,即可以声明为整数变量,如3,-147等即为整数。Java中,整数数据类型可以分为long、int、short及byte四种:long为64位,也就是8个字节(bytes),可表示范围为-92233720368...
  • 02基础的数据类型

    2020-08-16 20:32:01
    整型:通常称为整数,是整数或者负数,不带小数点。python3整型类型没有大小限制。int型数字:0、10 -780、-089、-0x270、0x90。 浮点型:浮点型由整数部分与小数部分组成。float型数字:0.0、15.2、-2.9、-32.5e10...
  • Python是一种面向对象语言,因此它使用类来定义数据类型,包括其原始类型。int() 将其他类型转换为整形:1)浮点类型转换之后,舍去小数部分;2)布尔值转换之后 True -> 1 False->0;3)字符串转换,仅纯整型...
  • 处理带小数的数值2. 浮点类型:float3. 浮点类型:double4. 浮点类型所占字节大小 1. 处理带小数的数值 我们来讨论一下类似于1.234567,0.00001,这类非整数的数据。 我们可以先试试看,int能能装这些数据呢? #...
  • 更小通常更好简单就好尽量避免null一、整数类型有两种类型的数字 :整数和实数。如果存储整数,可以使用这几种整数类型:...二、实数类型实数是小数部分数字。然而,它们 只是为了存储小数部分;也可以使用...
  • php数据类型

    2019-08-24 19:55:47
    带小数的是浮点型 4、string(字符串) 可以用双引号或者单引号 表示 单引号能解析变量 双引号可以解析变量 $str="花花"; $str='花花'; 转移符 $a="我叫蓝忘机"; 代码: $str...
  • 计算机顾名思义是用来计算数字的机器,但计算机可能只能用来计算数值,还可以处理图像,声音,文本,视频等等,不同的数据就需要定义不同的数据类型,下面就先介绍几个python中的几个简单的数据类型 整型数 ...
  • decimal(8,3)现在考虑最终要存储要在Android中验证的值的列的数据类型,我已经考虑了这些两种情况:如果用户输入不带小数的数字,则最大位数必须为8如果用户输入带小数的数字,则最大位数必须为8(包括小数点右边的...
  • 用type()函数可以数据的基本类型进行查询 1)字符串型: 用引号围起来文本就是字符串,可用str()转换浮点数与整数为字符串。可用+号拼接字符串。 2)整数型: 正整数、负整数、零都属于整数型,其没有小数,可用...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 270
精华内容 108
关键字:

不可以带小数的数据类型