精华内容
下载资源
问答
  • python数值类型
    2021-07-12 07:20:49

    数值类型是数值型数据,支持整型、浮点、布尔类型和复数。数值型即数值数据,用于表示数量,并可以进行数值运算。数值型数据由整数、小数、布尔值和复数组成,分别对应整型类型、浮点类型、布尔类型和复数类型。本文主要介绍Python 数值类型转换。
    原文地址:Python 数值类型转换

    更多相关内容
  • Python数值类型

    千次阅读 2020-11-28 11:32:30
    数值类型python数值类型包括常规的类型:整数(没有小数部分的数字)、浮点数(通俗地说,就是有小数部分的数字)以及其它数值类型(复数、分数、有理数、无理数、集合、进制数等)。除了十进制整数,还有二进制数、八...

    数值类型

    python的数值类型包括常规的类型:整数(没有小数部分的数字)、浮点数(通俗地说,就是有小数部分的数字)以及其它数值类型(复数、分数、有理数、无理数、集合、进制数等)。除了十进制整数,还有二进制数、八进制数、十六进制数。

    类型 示例

    ---------------------------------------

    整数 1234, -24, 0

    浮点数 1.23, 1., .2, 3.14e-10

    八进制 0o177, 0O177

    十六进制 0x9ff, 0X9ff

    二进制 0b1010, 0B1010

    需要说明的几点事项:

    python 3.x中的整数不区分一般整数和长整型整数,3.x版本中的整数支持无穷精度

    任何时候浮点数都是不精确的。当带有小数点或科学计数的标记符号e或E,就表示这是浮点数

    当浮点数参与表达式的运算时,会以浮点数的规则进行运算,也就是整数会转换成浮点数类型

    python中的浮点数精度和C语言的双精度浮点数精度相同

    整数除了十进制整数外,还可以写成二进制、八进制、十六进制甚至是其它进制的整数,它们的转换方式见后文

    当一个整数以0b或0B开头,其后都是0、1时,默认识别为二进制整数

    当一个整数以0o或0O开头(数值零和大、小写的字母o),其后都是0-7之间的数值时,默认识别为8进制整数

    当一个整数以0x或0X开始,其后都是[0-9a-fA-F]之间的字符时,默认识别为十六进制

    python中的数值类型是不可变对象,不可变意味着不可原处修改。假如a = 3333,那么现在内存中会有一个内存块保存数值对象3333,如果修改它,比如对它加上1操作a += 1,python将创建一个新的内存块用来保存新的数值对象3334,而不是在3333那个内存块中直接修改为3334,所以那个原始的数值3333就被丢弃了,它会等待垃圾回收器去回收。关于可变、不可变对象,后面的文章将会经常提到,请先留意这两个词。

    数值基本运算

    支持最基本的数学运算符号:+ - * / % **、取正负+x -x,地板除法//,除法和取模divmod(x, y):

    >>> 123 + 345

    468

    >>> 345 - 123

    222

    >>> 1.5 * 4

    6.0

    >>> 2/5

    0.4

    >>> 2 % 3

    2

    >>> 3 ** 2

    9

    >>> 3.00 ** 2

    9.0

    >>> 3 ** 100

    515377520732011331036461129765621272702107522001

    >>> a = 3; b = -3

    >>> -a, -b

    (-3, 3)

    >>> divmod(5, 2)

    (2, 1)

    可见,python的数值计算方式非常直接,且python 3.x中会自动为整数提供无穷精度。正如上面最后一个计算表达式(3**100),它将所有数字都显示出来了。就算是计算3**10000,3**1000000,python也不会报错,不过3的100万次方,显然需要花上一段时间来计算。这和其它编程语言有所区别,例如java中计算Math.pow(3,10000)将返回Infinity,表示无穷大。

    又是几个注意事项:

    python中的除法运算/得到的结果总是浮点数(例如9/3=3.0),后面还有一种地板除法(floor)不一样。

    当数值部分有小数时,会自动转换为浮点数类型进行运算,而且会自动忽略参与运算的小数尾部的0。

    加号+和乘号*也能处理字符串:

    +可以连接字符串,例如"abc" + "def"得到abcdef

    *可以重复字符串次数,例如"a"*3得到"aaa","ab"*3得到"ababab"

    其它数学运算方法

    除了上面的基础算术运算符,还支持很多数值类型的运算符,例如:取反(~)、位移(>>)、位与(&)、位异或(^)、逻辑与(and)、逻辑或(or)。

    除此之外,还有几个python的内置数学函数:

    pow():求幂,如pow(2,3)=8

    abs():求绝对值,如abs(-3)=3

    round():四舍五入,如round(3.5)=4

    int():取整(截去小数部分),如int(3.5)=3

    float():转换成浮点数,如float(3)=3.0

    oct():十进制整数转换成八进制

    hex():十进制整数转换成十六进制整数

    bin():十进制整数转换成二进制

    ...等等...

    还有专门的数学模块math、取随机数的模块random等。

    浮点数

    由于硬件的原因,使得计算机对于浮点数的处理总是不精确的。

    例如,按照数学运算时,1.1-0.9=0.2,但实际得到的结果为:

    >>> 1.1-0.9

    0.20000000000000007

    它以高精度的极限趋近的值来显示。上面的趋近结果大于按照数学运算结果,但并不总是如此,例如下面的运算则是小于数学运算的结果:

    >>> 3.3-3.2

    0.09999999999999964

    由于浮点数不精确,所以尽量不要对两个浮点数数进行等值==和不等值!=比较.如果非要比较,应该通过它们的减法求绝对值,再与一个足够小(不会影响结果)的值做不等比较。

    例如:

    >>> (3.2-2.8) == 0.4

    False

    >>> abs((3.2-2.8)-0.4) < 0.0002

    True

    最后,浮点数并非总是输出很长精度的值。正如前面的运算:

    >>> 3.2+3.2

    6.4

    >>> 3/10

    0.3

    浮点数有两个特殊方法,一个是is_integer(),用来测试这个浮点数是否是整数,另一个是as_integer_ratio(),可以将浮点数转换成分子分母组成的元组,不过这个方法并非总是如你所想的那样友好。例如:

    >>> (3.0).is_integer()

    True

    >>> (3.2).is_integer()

    False

    >>> (2.5).as_integer_ratio()

    (5, 2)

    >>> (2.6).as_integer_ratio()

    (5854679515581645, 2251799813685248)

    浮点数总是不精确的,而且不能指定小数位数。但在python中,有一个专门的小数模块decimal,它可以提供精确的小数运算,还有一个分数模块fractions,也能提供精确的小数运算。

    真除法、Floor除法和小数位截断

    /:实现的是真除法。在python中,它总是返回浮点数值。

    //:实现的是floor地板除法,它会去掉除法运算后的小数位,以便得到小于运算结果的最大整数。如果参与运算的有小数,则返回浮点数,否则返回整数

    在math模块中,有地板函数math.floor()和天花板函数math.ceil()。它们的意义可以根据现实中地板、空气、天花板的高低位置来考虑。地板位于空气之下,地板运算的返回值是比空气小的最大整数,天花板位于空气之上,天花板运算的的返回值是比空气大的最小整数

    round(x, N)是四舍五入,可以指定四舍五入到哪个小数位

    math.trunc()是直接截断小数

    实际上int()函数自身就是字节截断小数的

    看下面的示例。

    真除法总是返回浮点数。

    >>> 9/3

    3.0

    >>> 10/4

    2.5

    >>> 10/4.0

    2.5

    >>> -9/2

    -4.5

    >>> -9/2.0

    -4.5

    floor除法返回浮点数还是整数取决于参与运算的数是否包含浮点数。

    >>> 9 // 3

    3

    >>> 10 // 4

    2

    >>> 10 // 4.0

    2.0

    对于正数的运算结果,floor除法是直接去除小数位的。对于负数结果,它是取比运算结果更小的负整数。。

    例如,负数结果的floor除法:

    >>> -9 // 3

    -3

    >>> -10 // 4

    -3

    >>> -10 // 3

    -4

    -10 / 4的结果是-2.5,floor要取比它小的最大整数,也就是-3。-10 / 3的结果是-3.3,floor要取比它小的最大整数,也就是-4。

    除了真除法和floor除法,还有四舍五入round()和math.trunc()两种截断小数的方式。例如:

    >>> round(10/4)

    2

    >>> round(-5.2/2)

    -3

    >>> import math # import表示导入某个模块

    >>> math.trunc(5/2)

    2

    >>> math.trunc(-5.2/2)

    -2

    int()也可以直接截断小数。

    >>> int(3.6)

    3

    >>> int(-3.6)

    -3

    数值类型的转换

    int()可以将字符串或浮点数转换成整数,也可以用于进制数转换

    float()可以将字符串或整数转换成浮点数

    实际上它们表示根据给定参数在内存中构造一个整数、浮点数对象,所以可以用来作为类型转换工具。而且,前面已经说过,int()可以用来截断小数位。

    >>> int(3.5) # 浮点数 -> 整数

    3

    >>> int(-3.6) # 浮点数 -> 整数

    -3

    >>> int('3') # 字符串 -> 整数

    3

    >>> float(3) # 整数 -> 浮点数

    3.0

    >>> float('3') # 字符串 -> 浮点数

    3.0

    int()还可用于进制数转换,见下文。

    小数类型(Decimal)

    小数模块decimal,它有一个函数Decimal(),它是精确的,是可以指定小数位数的。

    如果没有python基础,这里能看懂多少算多少,反正小数用的也不多。

    例如,使用浮点数计算

    >>> 0.1 * 3 - 0.3

    5.551115123125783e-17

    它本该等于0,但结果却是无限接近于0,因为计算机硬件用于存储数值位数的空间有限。

    使用decimal模块的Decimal()可以构造精确的小数。例如:

    >>> import decimal

    >>> decimal.Decimal('0.1') * 3 - decimal.Decimal('0.3')

    Decimal('0.0')

    注意,Decimal()的参数都是字符串,如果不加引号,它还是会解释成浮点数。

    >>> decimal.Decimal(0.1)

    Decimal('0.1000000000000000055511151231257827021181583404541015625')

    Decimal()的运算的结果会取最长的小数位数。

    >>> decimal.Decimal('0.1') * 3 - decimal.Decimal('0.300')

    Decimal('0.000')

    可以设置decimal的精度,也就是小数位数。有两种范围的精度:全局范围、局部范围。

    例如,没有设置精度时,会保留很多位数的小数。

    >>> import decimal

    >>> decimal.Decimal(1) / decimal.Decimal(7)

    Decimal('0.1428571428571428571428571429')

    设置全局范围的精度为4,即保留4位小数:

    >>> import decimal

    >>> decimal.getcontext().prec = 4

    >>> decimal.Decimal(1) / decimal.Decimal(7)

    Decimal('0.1429')

    全局范围的精度表示整个线程执行时,这个模块的精度都是4。

    还可以设置局部范围的精度,局部表示退出了这个范围就失效了。使用with/as语句可以设置局部精度,所以退出with/as语句块精度的设置就失效了。

    >>> with decimal.localcontext() as ctx:

    ... ctx.prec = 2

    ... decimal.Decimal(1) / decimal.Decimal(7)

    ...

    Decimal('0.14')

    >>> decimal.Decimal(1) / decimal.Decimal(7)

    Decimal('0.1429') # 因为前面设置了全局精度为4

    分数(Fraction)

    分数模块fractions,它有一个函数Fraction(),它可以构建分数。有了分数之后,可以参与运算。分数和浮点数不同,分数是精确的。

    同样地,如果没有python基础,这里能看懂多少算多少,反正用的也不多。

    例如,构建分数三分之一。

    >>> import fractions

    >>> fractions.Fraction(1,3)

    Fraction(1, 3)

    还可以根据浮点数的字符串格式构建分数。

    >>> fractions.Fraction('0.3')

    Fraction(3, 10)

    然后可以用分数进行运算。

    分数加整数:

    >>> fractions.Fraction(1,3) + 1

    Fraction(4, 3)

    分数加、减、乘、除分数:

    >>> fractions.Fraction(1,3) + fractions.Fraction(2,3)

    Fraction(1, 1)

    >>> fractions.Fraction(1,3) - fractions.Fraction(2,3)

    Fraction(-1, 3)

    >>> fractions.Fraction(1,3) * fractions.Fraction(2,3)

    Fraction(2, 9)

    >>> fractions.Fraction(1,3) / fractions.Fraction(2,3)

    Fraction(1, 2)

    实际上,float对象有一个as_integer_ratio()函数,可以将浮点数转换成整数的元组表示形式(元组后面的文章会介绍),然后根据这个元组就可以构造出分数来。

    例如,将2.5转换成元组,并进而转换成分数。

    >>> (2.5).as_integer_ratio()

    (5, 2) # 得到元组

    >>> fractions.Fraction(*(2.5).as_integer_ratio())

    Fraction(5, 2)

    进制整数的转换

    oct():十进制整数转换成八进制

    hex():十进制整数转换成十六进制整数

    bin():十进制整数转换成二进制

    例如,将十进制的64转换成二进制、八进制、十六进制整数。

    >>> bin(64),oct(64),hex(64)

    ('0b1000000', '0o100', '0x40')

    int()函数也能进行进制转换,它的用法格式为:

    int(x, base=10)

    base指定要将x解释成哪个进制位的数,然后转换成十进制数,也就是前面说的构造一个整数对象。不指定base时,默认解释成10进制。

    base的值可以是0或2-36之间的任意一个数,base=0也表示解释成10进制。

    例如,将二进制的数转换为十进制整数。

    >>> int('0b11',base=2)

    3

    >>> int('11',base=2)

    3

    既然x要解释成某个进制的数,那么超出这个进制的数自然不能出现。例如:

    将x解释成二进制数的时候,x里就不能包含除0、1之外的数(当然,前缀0b除外);

    解释成7进制,就不能出现7、8、9;

    解释成8进制,就不能出现8、9;

    解释成11进制,就只能出现0-9、a/A这些字符;

    12进制就只能出现0-9、aAbB这几个字符;

    36进制就只能出现0-9、a-zA-Z这几个字符。

    例如,将一个字符串解释为15进制,并转换成整数。15进制只能出现0-9、a-eA-E这几个字符。

    >>> int('93E', base=15)

    2084

    展开全文
  • 数值类型是计算机程序最常用的一种类型,既可用于记录各种游戏的分数、游戏角色的生命值、伤害值等,也可记录各种物品的价格、数量等,Python 提供了对各种数值类型的支持,如支持整型、浮点型和复数。 Python...

    数值类型是计算机程序最常用的一种类型,既可用于记录各种游戏的分数、游戏角色的生命值、伤害值等,也可记录各种物品的价格、数量等,Python 提供了对各种数值类型的支持,如支持整型、浮点型和复数。

     

    Python整型

    Python 3 的整型支持各种整数值,不管是小的整数值,还是大的整数值,Python 都能轻松处理(不像某些语言,short、int、long 等整型增加了开发难度)。

    例如如下代码:

      #定义变量a,赋值为56  a = 56  print(a)  #为a赋值一个大整数  a = 9999999999999999999999  print(a)  #type()函数用于返回变量的类型  print(type (a))

    对于没有编程基础的读者, 同样可以在交互式解释器中逐行“试验”上面程序来观看运行效果。由于篇幅限制,本教程后面的程序不再详细列出在交互式解释器中逐行“试验”的过程;但没有基础的读者依然可以按照这种方式来“玩”Python。

    上面程序中粗体字代码将 9999999999999999999999 大整数赋值给变量 a,Python 也不会发生溢出等问题,程序运行一样正常,这就是 Python 的魅力:别搞那些乱七八糟的底层细节,非专业人士也不关心什么字节之类的细节。

    使用 Python 3.x 运行上面程序,可以看到如下输出结果:

    56
    9999999999999999999999
    <class 'int'>

    从上面的输出结果可以看出,此时 a 依然是 int 类型。

    但如果用 Python 2.x 运行上面程序,则可以看到如下输出结果:

    56
    9999999999999999999999
    <type 'long'>

    对比两种输出结果,不难发现:不管是 Python 3.x 还是 Python 2.x,Python 完全可以正常处理很大的整数,只是 Python 2.x 底层会将大整数当成 long 类型处理,但开发者通常不需要理会这种细节。

    Python 的整型支持 None 值(空值),例如如下代码:

    a = None
    print(a)

    Python 的整型数值有 4 种表示形式:

    1. 十进制形式:最普通的整数就是十进制形式的整数。
    2. 二进制形式:以 0b 或 0B 开头的整数就是二进制形式的整数。
    3. 八进制形式:以 0o 或 0O 开头的整数就是八进制形式的整数(第二个字母是大写或小写的 O)。
    4. 十六进制形式:以 0x 或 0X 开头的整数就是十六进制形式的整数,其中 10~15 分别以 a~f( 此处的 a~f 不区分大小写)来表示。

    下面代码片段使用了其他进制形式的数:

      #以0x或0X开头的整型数值是十六进制形式的整数  hex_value1 = 0x13  hex_value2 = 0xaF  print("hexValue1 的值为:",hex_value1)  print("hexValue2 的值为:",hex_value2)  #以0b或0B开头的整型数值是二进制形式的整数  bin_val = 0b111  print('bin_val的值为:',bin_val)  bin_val = 0B101  print('bin_val的值为:',bin_val)  #以0o或0O开头的整型数值是八进制形式的整数  oct_val = 0o54  print('oct_val 的值为:',oct_val)  oct_val = 0O17  print('oct_val 的值为:',oct_val)

    为了提高数值(包括浮点型)的可读性,Python 3.x 允许为数值(包括浮点型)增加下画线作为分隔符。这些下画线并不会影响数值本身。例如如下代码:

      #在数值中使用下画线  one_million = 1000000  print(one_million)  price = 234_234_234 #price 实际的值为234234234  android = 12341234 #android 实际的值为12341234

    注意,Python 2.x 还支持八进制形式的整数(要求以 0 开头),但由于八进制形式的整数其实很“鸡肋”,所以 Python 3.x 删除了这个功能。此外,Python 2.x 不支持在数值中使用下画线。

    Python浮点型

    浮点型数值用于保存带小数点的数值,Python 的浮点数有两种表示形式:

    • 十进制形式:这种形式就是平常简单的浮点数,例如 5.12、512.0、0.512。浮点数必须包含一个小数点,否则会被当成整数类型处理。
    • 科学计数形式:例如 5.12e2(即 5.12×102)、5.12E2(也是 5.12 ×102)。

    必须指出的是,只有浮点型数值才可以使用科学计数形式表示。例如 51200 是一个整型值,但 512E2 则是浮点型值。

    Python 不允许除以 0 。不管是整型值还是浮点型值,Python 都不允许除以 0。

    下面程序示范了上面介绍的关于浮点数的各个知识点:

      af1 = 5.2345556  #输出af1的值  print("af1的值为:",af1)  af2 = 25.2345  print("af2的类型为:",type(af2))  f1=5.12e2  print("f1的值为:",f1)  f2 = 5e3  print("f2的值为:",f2)  print("f2的类型为:",type(f2))#看到类型为float

    通过最后一行粗体字代码可以看出,虽然 5e3 的值是 5000,但它依然是浮点型值,而不是整型值,因为 Python 会自动将该数值变为 5000.0。

    复数

    Python 甚至可以支持复数,复数的虚部用 j 或 J 来表示。

    如果读者对虚数虚部感到困惑,请直接跳过本节,大部分编程并不会用到复数这么“高级”的数学知识。

    如果需要在程序中对复数进行计算,可导入 Python 的 cmath 模块(c 代表 complex),在该模块下包含了各种支持复数运算的函数。

    模块就是一个 Python 程序,Python 正是通过模块提高了自身的可扩展性的;Python 本身内置了大量模块,此外还有大量第三方模块,导入这些模块即可直接使用这些程序中定义的函数。

    下面程序示范了复数的用法:

      ac1 = 3 + 0.2j  print (ac1)  print(type(ac1)) #输出复数类型  ac2 = 4 - 0.1j  print

    推荐学习目录:Python字符串

    展开全文
  • Python数值类型 int、float、complex 详解

    千次阅读 2021-01-12 02:40:04
    Python数值类型:int、float、complex在Python程序中,int、float和complex是三种十分重要的数值类型,分别代表整数、浮点数和复数。本节将进一步讲解与这三种数据类型相关的其他函数。1、三种类型的关系在Python...

    Python数值类型:int、float、complex

    在Python程序中,int、float和complex是三种十分重要的数值类型,分别代表整数、浮点数和复数。本节将进一步讲解与这三种数据类型相关的其他函数。

    1、三种类型的关系

    在Python程序中有三种数值类型,分别是整型(integers), 浮点型(floating point numbers), 以及复数(complex numbers)。其中整型拥有准确的精度,浮点型一般是实现C中的double 类型,有关浮点型的精度信息以及其在具体机器中的内部特性信息,可以使用函数sys.float_info()获取。复数类型由一个实数部分(即实部)与一个虚数部分(即虚部)构成,而这两个部分都是浮点型。

    Python所有的数值类型(复数除外)都支持表2-1中的操作(按优先级升序排列)(所有数字操作的优先级均高于比较操作)。

    表 数值类型操作

    操作

    结果

    x + y

    x 和 y 的总和

    x - y

    x 和 y 的差

    x * y

    x 和 y 的乘积

    x / y

    x 和 y 的商

    x // y

    x 除以y的商向下取整的整数

    x % y

    求余数 x / y

    -x

    x 取负

    +x

    x 保持不变

    abs(x)

    x的绝对值或x的大小

    int(x)

    x 转换为整数

    float(x)

    x 转换为浮点数

    complex(re, im)

    将参数转化为复数,re为复数的实部,Im为复数的虚部。im 默认为0

    c.conjugate()

    c 复数的共轭

    divmod(x, y)

    (x // y, x % y)

    pow(x, y)

    x 的y 次幂

    x ** y

    x 的y 次幂

    2、整数类型的相关函数

    在Python程序中,int类型提供了如下所示的内置函数。

    (1)int.bit_length():返回表示二进制整数所需的位数,不包括符号和前置零。

    (2)int.to_bytes(length, byteorder, *, signed=False):返回一个表示整数的字节数组。

    1.length:数组的长度,如果整数转换出的字节数组长度超过了该长度,则产生OverflowError;

    2.byteorder:字节序;值为"big"或者"little","big"表示最有意义的字节放在字节数组的开头,"little"表示最有意义的字节放在字节数组的结尾。在sys.byteorder保存了主机系统的字节序;

    3.signed:确定是否使用补码来表示整数,如果值为false且是负数,则产生OverflowError。默认值为False。

    (3)int.from_bytes(bytes, byteorder, *, signed=False):返回由给定的字节数组表示的整数。

    1.bytes:字节数组或者是一个iterable;

    2.byteorder:同函数to_bytes()相同;

    3.signed:同函数to_bytes()相同。

    例如在下面的实例文件Linux公社.py中,演示了使用整数类型的相关函数的过程。

    #使用bit_length()返回表示二进制整数所需的位数,不包括符号和前导零:

    n = -37

    print(bin(n))

    print(n.bit_length())

    #使用函数to_bytes()返回一个表示整数的字节数组。

    print((1024).to_bytes(2, byteorder='big'))

    print((1024).to_bytes(10, byteorder='big'))

    print((-1024).to_bytes(10, byteorder='big', signed=True))

    x = 1000

    print(x.to_bytes((x.bit_length() // 8) + 1, byteorder='little'))

    #使用函数from_bytes()返回由给定的字节数组表示的整数。

    print(int.from_bytes(b'\x00\x10', byteorder='big'))

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

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

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

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

    执行后会输出如下:

    -0b100101

    6

    b'\x04\x00'

    b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'

    b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'

    b'\xe8\x03'

    16

    4096

    -1024

    64512

    16711680

    3、浮点类型的相关函数

    在Python程序中,float类型提供了如下所示的内置函数。

    (1)float.as_integer_ratio():返回一对整数(2元组),它们的比例准确地等于浮点数的原始值,且分母为正数。无穷会引发ValueError错误,NaNs会引发OverflowError错误。

    (2)float.is_integer():如果浮点数实例是整数值,则返回True,否则返回False。

    上面的两个方法(as_integer_ratio()和is_integer())都支持与十六进制字符串的相互转换。由于Python的浮点数内部存储为二进制数,浮点数和十进制字符串通之间的相互转化通常会有一个小的舍入误差。与此相反的是,十六进制字符串允许浮点数的精确表示和规格。这在调试时和数值工作中很有用。

    (3)float.hex():返回浮点数的十六进制字符串表示形式。对于有限的浮点数,这种表示形式总是包括一个前导的0x和尾部的p及指数。

    (4)float.fromhex(s):这是一个类方法,功能是返回由十六进制字符串s表示的float。字符串s可能有前导和尾随空格。读者需要注意,float.hex()是实例方法,而float.fromhex()是一个类方法。

    在计算机系统中,十六进制字符串的形式为:

    [sign] ['0x'] integer ['.' fraction] ['p' exponent]

    可选的exponent可以为“+”或“integer”,“sign”和“fraction”是十六进制数的字符串,“-”是带有可选的前导符号的十进制整数。大小写不敏感,且整数或小数至少有一个十六进制数字。此语法类似于C99 标准的第6.4.4.2节中指明的语法,也类似Java 1.5起使用的语法。float.hex()的输出在C或Java代码中可作为十六进制浮点数的字面值,而且C的Double.toHexString格式的十六进制字符串或Java的%a可以被float.fromhex()接受。在此需要注意的是,指数使用的是十进制数而不是十六进制表示,并且它给出用来乘系数的2的幂。例如,十六进制的字符串0x3.a7p10表示浮点数(3 + 10./16 + 7./162) * 2.010,或3740.0。

    例如在下面的实例文件Linuxidc.com.py中,演示了使用浮点类型的相关函数的过程。

    print((-2.0).is_integer())

    print((3.2).is_integer())

    print(float.fromhex('0x3.a7p10'))

    print(float.fromhex('0x3.a7p10'))

    执行后会输出如下:

    True

    False

    3740.0

    3740.0

    4  迭代器类型

    Python语言支持对容器中的内容进行迭代,允许用户定义的类支持迭代。要想使容器对象支持迭代,需要定义如下所示的方法:

    container.__iter__():返回迭代器对象��该对象必须支持如下所述的迭代器协议。如果容器支持不同类型的迭代,可以提供其他方法来专门请求这些迭代类型的迭代器。(对象支持多种迭代形式的一个示例是支持广度和深度优先遍历的树结构)。

    Python迭代器对象本身需要支持以下两种方法,它们一起形成迭代器协议。

    iterator.__iter__():返回迭代器对象本身,这是必需的,以允许容器和迭代器在for和in语句中使用。

    iterator.__next__():从容器中返回下一个元素。如果没有其他元素,则会引发StopIteration异常。

    例如在下面的实例文件diq.py中,演示了使用使用类实现__iter__()和next()函数的过程。

    class Fib(object):

    def __init__(self):

    self.a, self.b = 0, 1 # 初始化两个计数器a,b

    def __iter__(self):

    return self # 实例本身就是迭代对象,故返回自己

    def __next__(self):

    self.a, self.b = self.b, self.a + self.b # 计算下一个值

    if self.a > 10: # 退出循环的条件

    raise StopIteration();

    return self.a # 返回下一个值

    if __name__ == '__main__':

    for n in Fib():

    print(n)

    执行后会输出如下:

    1

    1

    2

    3

    5

    8

    展开全文
  • Python中的数值类型

    千次阅读 2021-09-07 15:58:27
    Python 支持三种不同的数值类型(数字数据类型): 整型(int) - 通常被称为是整型或整数,是正或负整数,不带小数点。Python3 整型是没有限制大小的,可以当作 Long 类型使用,所以 Python3 没有 Python2 的 Long ...
  • Python数值类型有哪些

    千次阅读 2021-04-27 01:52:32
    Python数值类型有哪些发布时间:2020-12-15 09:32:58来源:亿速云阅读:92作者:小新小编给大家分享一下Python数值类型有哪些,相信大部分人都还不怎么了解,因此分享这篇文章给大家参考一下,希望大家阅读完这...
  • python 基本数值类型

    千次阅读 2020-08-16 20:47:43
    1、python 数值基本类型: int : 整数类型 float : 浮点类型 bool : 布尔类型(True False) 使用的时间,我们可以直接给变量赋值,可以用 type:内置函数,来查看数据的类型 1.1 整数类型 a = 2 print(a) # 2 ...
  • python 数值类型转换

    千次阅读 2017-10-12 17:19:50
    ...因为python跟java在数据类型转换方面语法不同,所以总是搞混,特此记录下来,方便查阅: 在python中: 字符串str转换成int: int_value = int(str_value) int转换成字符串str: str_v
  • 实际开发中,我们经常需要使用数字记录游戏中用户的得分、游戏中角色的生命值、伤害值等信息,Python语言提供了数值类型用于保存这些数值。需要注意的是,Python 中这些数值类型都是不可改变的,也就是说,如果我们...
  • Python数值分成了三种:整数、浮点数(小数)、复数 数值类型特点: Python中的整数的大小没有限制,可以是一个无限大的整数 c = 999999999999999999999999999999999999999999999 ** 100 如果数字的长度过大,...
  • 实际开发中,我们经常需要使用数字记录游戏中用户的得分、游戏中角色的生命值、伤害值等信息,Python 语言提供了数值类型用于保存这些数值。需要注意的是,Python 中这些数值类型都是不可改变的,也就是说,如果我们...
  • bb = aa/100.0 #运行环境是Python2.7 其中Python2.X 与 python 3X中的除法是有区别 print bb # 输出结果是 0.2 # 小数转换位百分比 #方法一 a = 0.3214323 bb = "%.2f%%" % (a * 100) print bb # 输出结果是32.14%...
  • 13 Python数据类型显式转换及数值类型.mp4
  • python数值类型及输入输出

    万次阅读 2017-12-24 05:17:46
    pythono支持的数值类型 int, long, float, bool, complex(复数) 注:布尔值首字母必须大写 二. 操作符 1. 算术操作符 +,-,*,/,%,//,** 注:当执行from __future__ import division时,/只表示...
  • Python 基础数据类型-数值类型

    千次阅读 2021-01-13 00:00:38
    Python 基础数据类型-数值类型为什么会有数据类型?[了解]更好分配管理内存方便统一管理更贴近人类分类管理习惯数据类型种类 [熟悉]数值类型:int、bool、float、complex序列类型:不可变:str、tuple、bytes 可变:...
  • 下面小编就为大家带来一篇浅谈python 四种数值类型(int,long,float,complex)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Python 中数据类型转换

    千次阅读 2022-05-10 17:21:25
    今天是 Python 基础系列第三篇:三种数据类型转换形式(布尔值转换、字符串转换、数值转换)。 一、转为布尔值 一)数值转换为布尔值 1、运行: 2、得出: 1)数值为 0 和 0.0 转为布尔值,得到的结果都...
  • 实际开发中,我们经常需要使用数字记录游戏中用户的得分、游戏中角色的生命值、伤害值等信息,Python 语言提供了数值类型用于保存这些数值。需要注意的是,Python 中这些数值类型都是不可改变的,也就是说,如果我们...
  • Python数值分成了三种: 整数、浮点数(小数)、复数 1.int类型 在Python中所有的整数都是int类型,无大小限制,可以是一个无限大的整数 注意: 如果数字的长度过大,可以使用下划线作为分隔符 eg:c = 123_456_...
  • 为何使用Python Python是一种效率极高的语言:相比于众多的其它语言,使用Python编写时,程序包含的代码行更少。Python的语法也有助于创建整洁的代码:相比其他语言,使用Python编写的代码更容易阅读、调试和扩展。 ...
  • Python支持四种不同的数值类型,包括int(整数)long(长整数)float(浮点实际值)complex (复数),本文章向码农介绍python 四种数值类型,需要的朋友可以参考一下。数字数据类型存储数值。他们是不可改变的数据类型,这...
  • Python数值

    千次阅读 2020-12-01 03:01:31
    一、python数值类型python数值类型有以下四种:int(整数)float(浮点数)complex(复数)bool(布尔型)注意:python3取消了long型。二、python数值运算符2.1算术运算符假设a=5,b=9注意://如果其中一个操作数作为负数,...
  • Python有4种数值类型,即整数型、浮点数型、复数型和布尔型。 整数型——1、-3、42、355、888888888888888、-7777777777,整 数没有大小限制,仅受限于可用内存的大小。 浮点数型——3.0、31e12、–6e-4。 复数型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 184,289
精华内容 73,715
关键字:

python数值类型