Python基础知识：数据类型--数值型

数值型

数值型包含了整数(int)、浮点数(float)、小数(decimal)、分数、复数(complex)这几种类型，常用类型为整数和浮点数。

整数（int）

​ 整数包括正整数、负整数和零，整数常量是不带小数点的数。Python 3.x和其他语言不同，不区别长整型和整型，只要计算机内存空间足够大，整数理论上可以是无穷大。整数的数据类型为int，可以使用type()函数对创建的变量进行类型的测试，示例如下：

>>> a = 100
>>> print(type(a))
<class 'int'>

​ 整数类型除了上述方式可以创建外，Python还提供了int()函数，可以将其他类型的变量转化为整数类型，int()函数对转换的值有严格的限制，必须是转换以后能够成为整数的变量才可以正常运行，否则会引起报错，示例如下：

>>> a = '100' # a为字符串类型，但是内部是一个整数
>>> print(a)
100
>>> print(type(a))
<class 'str'>
>>> b = int(a)
>>> print(b)

>>> a = '100.0' # a为字符串类型，但是内部是一个整数
>>> print(a)
100
>>> print(type(a))
<class 'str'>
>>> b = int(a)
ValueError: invalid literal for int() with base 10: '100.0'
# 变量a为字符串类型，但是内部数值带了小数点，int()函数无法将这种转为整数，会报错

>>> a = 100.50
>>> print(a)
100.05
>>> print(type(a))
<class 'float'>
>>> b = int(a) # a为浮点型，int()函数只取到整数部分，小数部分全部舍去
>>> print(b)
100
>>> print(type(b))
<class 'int'>

浮点数(float)

​ 浮点数为带小数点的数值型，浮点类型的名称为float，浮点类型取值范围为-10³⁰⁸~10³⁰⁸，超过取值范围会报错（OverflowError），示例如下：

>>> print(10.0 ** 308)
1e+308 # 科学计数法
>>> print(-10.0 ** 309)
Traceback (most recent call last):
  File "test.py", line 1, in <module>
    print(-10.0**309)
OverflowError: (34, 'Result too large')

​ Python中提供了float()函数，可以把其他类型的数据转为浮点类型的，同int()函数一样，float()函数也对需要转化的值有严格的限制，必须内部是属于数值型的才可以进行转化，示例如下：

>>> a = '100.50' # 内部为整数或者浮点数的字符串可以使用float()转换为浮点数
>>> print(a)
100.50
>>> print(type(a))
<class 'str'>
>>> b = float(a) # 将数值的字符串转为浮点型
>>> print(b)
100.5
>>> print(type(b))
<class 'float'>
>>> c = 'abc'
>>> d = float(c) # 内部为字母和文字的字符串无法使用float()转换，会报错
Traceback (most recent call last):
  File "test.py", line 2, in <module>
    d = float(c)
ValueError: could not convert string to float: 'abc'

复数（complex）

​ 形如 z=a+bi（a、b均为实数）的数称为复数。其中，a 称为实部，b 称为虚部，i 称为虚数单位。复数类型的名称为complex，Python提供了complex()函数创建复数，语法如下：

complex(实部,虚部)

示例如下：

>>> print(complex(2, 3))
(2+3j)

复数在实际项目中涉及到的比较少，在此处仅做了解即可。

小数

首先来看一个示例：

>>> print(0.05 + 0.01)
0.060000000000000005 # 结果并不是0.06

​ 使用计算机计算浮点数运算时会发现一个问题，在数学运算中0.05+0.01=0.06，但是使用计算机输出的结果为：0.060000000000000005。虽然现在的CPU都支持浮点运算，但是CPU在处理运算时，需要先把浮点数转换成二进制，然后再进行运算，运算完成后再将二进制转换成浮点数输出，这个过程会导致计算机不能对浮点数执行精确运算。

​ 因此Python提供了小数这种数值类型来解决这个问题，小数可以看作是固定精度的浮点数，小数包含了固定的位数和小数点，能够满足规定精度的计算，示例如下：

>>> from decimal import Decimal
>>> Decimal('0.05') + Decimal('0.01')
0.6

​ 小数的全局精度默认为28位有效数字，可以使用decimal模块中的getcontext()创建当前上下文对象，通过调用当前上下文对象的prec属性设置精度范围，示例如下：

>>> from decimal import * # 导入decimal模块
>>> Decimal('1')/Decimal('3')
0.3333333333333333333333333333
>>> context = getcontext() # 获得上下文对象
>>> context.prec = 3 # 修改上下文对象的prec属性值
>>> Decimal('1')/Decimal('3')
0.333

分数

​ 除以上几种数值类型外，Python还提供了分数类型，分数对象由分子和分母构成，和数学中的形式一致。使用分数可以避免运算过程中浮点数精准度问题。调用fractions模块中的Fraction()函数可以实现创建分数对象，会自动计算为最简化的分数，示例如下：

>>> from fractions import Fraction
>>> a = Fraction(3, 9)
>>> print(a)
1/3

可以使用Fraction.from_flaot()函数将浮点数转化为分数，示例如下：

>>> from fractions import Fraction
>>> print(Fraction.from_float(0.25))
1/4

布尔类型（bool）

​ 布尔类型（bool）是一种特殊的数字类型，布尔类型的值只有两个真值（True）和假值（False），其中True可以用1表示，False可以用0表示，除此以外bool()函数可以将其他类型的值转换成为布尔值，示例如下：

>>> x = 10
>>> print(bool(x))
True
>>> y = 0
>>> print(bool(y))
False

​ 布尔值常为比较运算、逻辑运算、成员运算、身份运算的返回值，也经常作为程序流程控制结构中的条件使用。需要注意的是Python中的数据结构如字符串、列表、元组、字典、集合，如果为空的状态，使用bool()函数转换以后的值均为False，非空状态使用bool()函数转换后的值均为True。

数值运算

算术运算

算术运算是数学中常用到的加减乘除的运算，Python中常用的算术运算符如表所示：

# 以下均假设变量x,y
x = 10
y = 21

运算符	说明	示例
**	幂 - 返回x的y次幂	x**y 为10的21次方
*	乘 - 两个数相乘	x * y 输出结果 210
/	除 - x 除以 y	y/x 输出结果 2.1
//	取整除 - 向下取接近商的整数	y//x 输出结果2
%	取模 - 返回除法的余数	y%x 输出结果1
+	加 - 两个对象相加	x + y 输出结果31
-	减 - 得到负数或是一个数减去另一个数	x - y 输出结果-11

​ 算术运算符的优先级完全符合数学中的优先级，如果有小括号，需要先计算括号内的，接下来是幂运算，然后是乘、除、整除、取余，最后是加、减。算术运算返回值均为数值型。

赋值运算

​ Python还支持赋值运算，赋值运算也可以叫增强运算，赋值运算不仅进行算术运算，还会把运算结果重新赋值给参与运算的其中一个值，就是我们在数学中的累加、累减、累乘、累除的运算。赋值运算符如表所示：

运算符	描述	示例
=	简单的赋值运算符	z = x + y 将 x + y 的运算结果赋值为 z
+=	加法赋值运算符	x += y 等效于 x = x + y
-=	减法赋值运算符	x -= y 等效于 x = x - y
*=	乘法赋值运算符	x *= y 等效于 x = x * y
/=	除法赋值运算符	x /= y 等效于 x = x / y
%=	取模赋值运算符	x %= y 等效于 x = x % y
**=	幂赋值运算符	x *= y 等效于 x = x ** y
//=	取整除赋值运算符	x //= y 等效于 x = x // y

​ 赋值运算常用在需要累加、累减的情况，赋值运算返回值为数值型，示例如下：

>>> x = 10 
>>> y = 21
>>> x = x + y # 正常语法
print(x)
31

>>> x = 10 
>>> y = 21
>>> x += y # 使用+=赋值运算符
print(x)
31

在循环中会经常使用到赋值运算符，后面的章节中会有示例讲解。

比较运算

比较运算的结果为布尔类型的值（True、False）,比较运算符如表所示：

比较运算符：

运算符	描述	示例
==	等于 - 比较对象是否相等	x == y 返回False
!=	不等于 - 比较两个对象是否不相等	x != y 返回 True
>	大于 - 返回x是否大于y	x > y 返回 False
<	小于 - 返回x是否小于y	x < y 返回 True
>=	大于等于 - 返回x是否大于等于y	x >= y 返回 Flase
<=	小于等于 - 返回x是否小于等于y	x <= y 返回 True

Python中允许连续的多个比较运算符进行缩写，完全符合数学中的用法，示例如下：

>>> a = 10
>>> b = 20
>>> c = 30 
>>> print(a<b<c) # 即 a<b and b<c
True

>>> a = 10
>>> b = 20
>>> c = 30 
>>> print(a==b<c) # 即 a==b and b<c
False

>>> a = 10
>>> b = 20
>>> c = 30 
>>> print(a>b<c) # 即 a>b and b<c
False

逻辑运算

Python支持逻辑运算，即与、或、非的关系，逻辑运算返回值为布尔类型值（True或False），逻辑运算符如表所示：

逻辑运算符：

运算符	逻辑表达式	描述
and	x and y	“与”关系，两真才真，一假俱假
or	x or y	“或”关系，两假才假，一真就真
not	not x	“非”关系，取反

（1）、逻辑与’and’

and前后的条件都为True时逻辑与的返回值才是True，只要其中有一个条件为False，逻辑与的返回值就为False。示例如下：

>>> print(True and True) # 两真才真
True
>>> print(True and False) # 一假俱假
False
>>> print(False and True) # 一假俱假
False
>>> print(False and False) # 一假俱假
False

（2）、逻辑或’or’

or前后的条件都为False时逻辑或的返回值才是False，只要其中有一个条件为True，逻辑或的返回值就为True。示例如下：

>>> print(True or True) # 一真即真
True
>>> print(True or False) # 一真即真
True
>>> print(False or True) # 一真即真
True
>>> print(False or False)  # 两假俱假
False

以上几种运算算术运算和赋值运算的返回值均为数值型。比较运算和逻辑运算的返回值均为布尔类型的值，比较运算和逻辑运算常被用做条件，放在if条件语句和while循环中充当判断条件从而控制程序运行的流程，本书后面的程序控制结构章节会常用到这两种运算作为条件。

数学函数

Python提供了用于处理数值运算的内置模块和内置函数

1.math模块

​ Python在math模块中提供了常用的数学常量和数学函数，使用模块时需要使用import math先进行导入，math模块中提供了表示函数、幂函数、对数函数、三角函数、双曲线函数、特殊函数以及一些常量，可以登录math库的中文官方文档地址：https://docs.python.org/zh-cn/3/library/math.html进行学习。此处列举一些常用的math库函数，如表所示：

math模块常见函数

import math # 导入math模块

函数	描述
math.ceil(x)	返回 x 的上限，即大于或者等于 x 的最小整数
math.fabs(x)	返回 x 的绝对值
math.floor(x)	返回 x 的向下取整，小于或等于 x 的最大整数
math.isinf(x)	如果 x 是正或负无穷大，则返回 True ，否则返回 False
math.isnan(x)	如果 x 是 NaN（不是数字），则返回 True，否则返回 False
math.exp(x)	返回 e 次 x 幂，其中 e = 2.718281… 是自然对数的基数
math.log(x[,base])	返回给定的 base 的对数 x
math.pi	数学常数 π = 3.141592…，精确到可用精度
math.e	数学常数 e = 2.718281…，精确到可用精度

示例代码如下：

>>> import math

>>> x = 2.78
>>> print(math.ceil(x))
3
>>> print(math.fabs(x))
2.78
>>> print(math.floor(x))
2
>>> print(math.isinf(x))
False
>>> print(math.isnan(x))
False
>>> print(math.exp(x))
16.119020948027543
>>> print(math.log(x, 5))
0.6352844802544756
>>> print(math.pi) # 数学常量π
3.141592653589793
>>> print(math.e) # 数学常数e
2.718281828459045

2.Python内置数学函数

​ 除math模块以外，Python也定义了一些内置的数学函数可以直接使用，这些函数实现的功能和math模块中函数的功能大同小异，常用内置数学函数如表所示：

函数	描述
abs(x)	返回数字的绝对值
ceil(x)	返回数字的上入整数
exp(x)	返回e的x次幂(ex)
fabs(x)	返回数字的绝对值
floor(x)	返回数字的下舍整数
log(x)	计算对数函数
log10(x)	返回以10为基数的x的对数
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	幂运算同x ** y
round(x [,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根。

内建三角函数，如表所示：

函数	描述
acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)。
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

数学常量，如表所示：

常量	描述
pi	数学常量 pi（圆周率，以π来表示）
e	数学常量 e

随机数函数，如表所示：

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

​ 随机数经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性，除了Python内置的随机数函数以外还有random模块可以选择，该模块实现了各种分布的伪随机数生成器，具体内容可以参考Python官方文档中的random，官方文档网址：https://docs.python.org/zh-cn/3.9/library/random.html，常用的random模块函数如表所示：

函数	描述
random.seed(a=None, version=2)	初始化随机数生成器
random.randrange(start, stop[, step])	返回一个随机选择的元素
random.randint(a, b)	返回随机整数 N 满足 a <= N <= b
random.choice(seq)	从非空序列 seq 返回一个随机元素
random.shuffle(x[, random])	将序列 x 随机打乱位置
random.sample(population, k, *, counts=None)	返回从总体序列或集合中选择的唯一元素的 k 长度列表
random.random()	返回 [0.0, 1.0) 范围内的下一个随机浮点数
random.uniform(a, b)	返回一个随机浮点数 N ，当 a <= b时 a <= N <= b，当 b < a时 b <= N <= a