# 3.2 数值类型

在数值类型方面，Python不仅仅提供了传统类型，如“整型”，“浮点型”以及“多进制数”等。还还提供复数、分数、小数等类型。不同于其他编程语言，只要有内存空间足够大，Python中的整数的位数可以随意增长。

### 3.2.1 基本数值类型

#### 整数

**整数概念**

整数类型，与数学中整数的概念相同。整数包括了正整数、负整数和零。我们日常生活中使用的是十进制数。Python默认采用十进制来显示整数数值，无需增加**引导符号**。如果要使用其他进制数，则必须在这些数之前加上引导符号。表\[]是进制数的引导符号，以及使用方式。

表

| 进制                | 引导符号  | 构造             | 对应十进制数 | 描述                  |
| ----------------- | ----- | -------------- | ------ | ------------------- |
| 十进制（Decimal）      | 无     | 100            | 100    | 由字符0\~9组成           |
| 二进制（Binary ）      | 0b或0B | 0b1011或 0B1011 | 11     | 由字符0\~1组成           |
| 八进制（Octal）        | 0o或0O | 0o701或0O701    | 449    | 由字符0\~7组成           |
| 十六进制（Hexadecimal） | 0x或0X | 0xFA1或0XFA1    | 4001   | 由字符0\~9，a到f（或A到F）组成 |

在Python描述器中输入不同的进制数，Python描述器会自动将其转换为十进制数。

\>>>0xFA1

4001

**进制转换**

在实际问题中，我们有时需要对不同进制的整数进行转换。表\[]列举了进制转中常用的四种函数。

表

| 函数  | 构造             | 对应进制数                    | 描述            |
| --- | -------------- | ------------------------ | ------------- |
| bin | bin(1024)      | 0b10000000000            | 将十进制数转换为二进制数  |
| oct | oct(1024)      | 0o2000                   | 将十进制数转换为八进制数  |
| hex | hex(1024)      | 0x400                    | 将十进制数转换为十六进制数 |
| int | int(‘1024’, n) | 139（以n=5,将1024转换为五进制数为例） | 将进制数转换为十进制数   |

bin，oct，hex函数的传入参数为数值类型，bin的第一个传输参数为整数对应的字符类型，第二个参数为需要转换的数字的进制。

例：将1024分别转为二进制数，八进制数，十六进制数和五进制数

\>>> bin(1024), oct(1024), hex(1024), int('1024', 5)

('0b10000000000', '0o2000', '0x400', 139)

#### 浮点数

\*\*浮点类型(float)\*\*是含有小数部分的数值。浮点数可以带一个小数点，也可以加上一个科学计数符e或者E。Python使用双精度浮点数，有效数字16位。

科学记数法是一种记数的方法。把一个大于10（或者小于1）的数表示成a与10的n次幂相乘的形式（1≤a<10，n为整数），这种记数法叫做\*\*科学记数法。\*\*以python浮点数表示为例，2.77E-3转换为数学符号为，即0.00277；3.11E4转换为数学符号为，即3110。

当浮点数与整数进行算数运算时，运算结果是什么类型？答案是浮点型。在混合类属性表达式中，Python总是将参与运算的数据对象转换成最复杂的对象类型，然后使用此对象类型下定义的运算方法对数据对象进行处理。

我们使用python中的type函数，可以查看对象的类型。

\>>>x=3

\>>>y=0.14

\>>>type(x), type(y)

(\<class 'int'>, \<class 'float'>)

\>>>type(x+y)

\<class 'float'>

由上例，我们可以看到x是整型类型，y是浮点类型，当x与y进行运算后，结果是浮点类型，与y的类型保持一致。

这种使用相同运算符对不同对象类型进行不同运算的操作，称为**运算符重载**。这种特性被称为**多态**。

我们还可以人工对整数或浮点数等进行强制类型转换：

\>>>int(x+y)

3

\>>>type(int(x+y))

\<class 'int'>

\>>>float(x)

3.0

\>>>type(float(x))

\<class 'float'>

#### 小数

\*\*小数（Fraction）\*\*是一种较新的数值类型。小数与浮点数很相像，不同的是，小数是拥有固定精度的浮点数。因此，小数对象拥有固定的位数和小数点。我们通过调用decimal模块，而不是通过字面量表达式来创建。通过使用小数对象，我们可以得到保留两位小数的浮点数。

小数对象的创建方法如下：

\>>>from decimal import Decimal

\>>>Decimal(‘0.1’) #我们使用Decimal函数创建了小数0.1

当有不同位数的小数在表达式中混编时，python可以将运算结果的位数保留为精度最高的位数。

\>>>Decimal('0.1')+Decimal('0.01')+Decimal('0.001')+Decimal('0.0001')

Decimal('0.1111')

\>>>print(Decimal('0.1111')) #使用print函数显示

0.1111

因为计算机中用来存储数值的空间有限，所以浮点数缺乏精确性。我们使用小数可以避免浮点数运算在精度方面存在的问题。

分别使用浮点数和小数对表达式进行计算

\>>>0.1+0.3+0.2-0.6 #使用浮点数进行计算

1.1102230246251565e-16

\>>>Decimal(‘0.1’)+Decimal(‘0.3’)+Decimal(‘0.2’)-Decimal(‘0.6’)

Decimal('0.0')

值得注意的是，Decimal函数的传入参数为小数对应的字符串，这也就意味着，需要对传入的小数加引号或使用**str函数**将其转为字符串，如果不这样做就会出现拥有超长位数的小数。

\>>> Decimal(0.1)+Decimal(0.3)+Decimal(0.2)-Decimal(0.6)

Decimal('2.775557561570313080847263336E-17')

我们通过对decimal.getcontext().prec的值进行修改，来获取我们希望得到的特定位数的小数。

\>>>import decimal

\>>>decimal.Decimal(3)/decimal.Decinal(11)

Decimal('0.2727272727272727272727272727')

\>>>decimal.getcontext() #获取当前环境

Context(prec=28, rounding=ROUND\_HALF\_EVEN, Emin=-999999, Emax=999999, capitals=1,

clamp=0, flags=\[Inexact, FloatOperation, Rounded], traps=\[InvalidOperation, DivisionByZero,

Overflow])

\>>> decimal.getcontext().prec=3 #设定保留位数3位

\>>> decimal.Decimal(3)/decimal.Decinal(11)

Decimal('0.273')

\>>> Decimal(0.1)+Decimal(0.3)+Decimal(0.2)-Decimal(0.6)

Decimal('2.22E-17')

#### 分数

\*\*分数（Fraction）\*\*是一种较新的数值类型。Python中的分数，显示了一个分数的分子和分母。这样做的好处也是显然的：分数的使用避免了浮点数运算的局限性。虽然和小数一样，它们都不像浮点数那样接近于计算机的底层硬件，因此执行效率无法达到浮点数的水平。但是它们却能提供比浮点数更加精确的计算结果。特别是分数的出现，既保证了计算的准确性，又简化了计算结果，可以为Python代码的编写带来极大的便利。

使用分数对象需要导入Fraction模块。

分数对象的创建方式如下：

\>>>from fractions import Fraction

\>>>x=Fraction(1, 3) #Fraction的第一个参数为分子，第二个参数为分母

\>>>x

Fraction(1, 3)

\>>>print(x)

1/3

还可以使用浮点数字符串来创建分数对象，创建方式如下：

\>>>Fraction(‘.33’) #创建值为0.32的分数

Fraction(33, 100)

例：计算：

\>>>sum= Fraction(1, 3)+ Fraction(1, 3)+ Fraction(1, 3)

\>>>sum

Fraction(1, 1)

\>>>float(sum)

1.0

#### 复数

复数类型，与数学中的复数类型概念保持一致。在数学上，我们把形如的数称为复数，其中a和b均为实数，a称为实部，b称为虚部，虚部后以i结尾。不同于数学上虚部的表示法，在Python中，虚部以j或者J结尾。

分数对象的创建方式有两种，一种是直接键入a+bj，另一种是借助complex函数对复数进行创建。

complex函数的使用方法如下：

complex(\[real\[, imag]])

complex函数的第一个参数位复数的实部， 第二个参数为复数的虚部。

下面让我们来创建复数3+4i：

\>>>3+4j

(3+4j)

\>>>complex(3, 4)

(3+4j)

例：计算(1+1i-3+5i)\*4+(4\*3i)\*5i 的运算结果

\>>> (1+1j-3+5j)\*4+(4\*3j)\*5j

(-68+24j)

### 3.2.2 表达式运算符

#### 表达式运算符

| 类别    | 表达式运算符       | 描述                     |
| ----- | ------------ | ---------------------- |
| 算术运算符 | +, -, \*, /  | 加减乘除四则运算符              |
|       | \*\*         | 幂运算                    |
|       | //           | 向下取整                   |
|       | %            | 模（取余）运算                |
| 关系运算符 | >, >=, <, <= | 大小比较，集合的子集和超集          |
|       | ==,!=        | 值等价运算                  |
| 赋值运算符 | =            | 赋值                     |
|       | <算数运算符]>=    | 对x与y执行算数运算x=x<算数运算符> y |
| 位运算符  | &，\|，^，\~    | 位与、位或、按位异或、按位取反运算      |
|       | <<，>>        | 左移，右移运算                |
| 逻辑运算符 | and, or, not | 与、或、非运算                |
| 身份运算符 | is, is not   | 检测两个对象是否相同             |
| 成员运算符 | in ,not in   | 检测对象是否在序列类型中           |

#### 运算符优先级

| 优先级 | 运算符                               | 描述         |
| --- | --------------------------------- | ---------- |
| 1   | \*\*                              | 指数运算       |
| 2   | \~，+，-                            | 按位取反，取正，取负 |
| 3   | \*，/，%，//                         | 乘，除，模，整除   |
| 4   | <<，>>                             | 左移，右移      |
| 5   | &                                 | 位与运算       |
| 6   | ^，\|                              | 位异或，位或运算   |
| 7   | <=，>=，<，>                         | 比较运算       |
| 8   | < >， == ，!=                       | 等价运算       |
| 9   | =， %=， /=， //=， -=， += \*=， \*\*= | 赋值运算       |
| 10  | is，is not                         | 身份运算       |
| 11  | in， not in                        | 成员运算       |
| 12  | not， or， and                      | 逻辑运算       |

### 3.2.3 内置数学函数

表是抄来的 需要重修排序，改说法

| abs(x)                         | 求绝对值 1、参数可以是整型，也可以是复数 2、若参数是复数，则返回复数的模 |
| ------------------------------ | -------------------------------------- |
| divmod(a, b)                   | 分别取商和余数 注意：整型、浮点型都可以                   |
| float(\[x])                    | 将一个字符串或数转换为浮点数。如果无参数将返回0.0             |
| int(\[x\[, base]])             | 将一个字符转换为int类型，base表示进制                 |
| long(\[x\[, base]])            | 将一个字符转换为long类型                         |
| pow(x, y\[, z])                | 返回x的y次幂                                |
| range(\[start], stop\[, step]) | 产生一个序列，默认从0开始                          |
| round(x\[, n])                 | 四舍五入                                   |
| sum(iterable\[, start])        | 对集合求和                                  |
| bool(\[x])                     | 将x转换为Boolean类型                         |

**内置函数**

1.数学运算

1. abs:求数值的绝对值

\>>>abs(-5)

5

1. divmod:返回两个数值的商和余数

\>>> divmod(3,2)

(1, 1)

1. max:返回可迭代对象中元素的最大值或者所有参数的最大值

\>>> max(1,4,7)

7

\>>> max('1234')

'4'

1. min: 返回可迭代对象中元素的最小值或者所有参数的最小值

\>>> min(1,4,7)

1

\>>> min('1234')

'1'

1. pow:返回两个数值的幂运算

\>>> pow(2,3)

8

1. round:对浮点数进行四舍五入运算

\>>> round(3.1515926,4)

3.1416

1. sum:对元素类型是数值的可迭代对象中的元素进行求和

\>>>sum((2,2.5,3,3.5)) #元素类型必须是数值型

11

2.类型转换

（1）int:将传入的参数转换成整数类型

\>>> int() #不传入参数时，返回0

0

\>>> int(5)

5

\>>> int(2.5)

2

（2）float:将传入的参数转换成浮点数类型

\>>> float() #不传入参数时，返回0.0

0.0

\>>> float(5)

5.0

\>>> float('5')

5.0

（3）bool:将传入的参数转换成布尔类型

\>>> bool() #不传入参数时，返回False

False

\>>> bool(0) #数值0、空序列等返回False

False

\>>> bool(1)

True