3.0 Python 数字类型常用操作

1. Numbers 数字类型

Python 有四种数字类型 int, float, bool, complex(复数).
1

1.1 int 整型

整型: 不包含小数部分的数字, 包含正整数与负整数和0.
Python 中整数类型的取值范围无限的, 但实际受限于计算机内存的大小.
1
2

num = 1

print(num)  # 1
print(type(num))  # 

1
2
3
4
5

1.2 float 浮点型

1. 浮点型

浮点型: 带小数点的数字.
浮点型的取值范围及小数精度都存在限制, 但实际使用过程中可以忽略不计.
浮点型数据占用的字节小, 计算结果过大存在溢出问题.

浮点型除了可以使用小数点格式外还可以用科学计算法表示.
在科学计数法中, 为了使公式简便, 可以用带 'E'的格式表示, 'E' 是 exponent(指数)的缩写.
例如: 1.03乘10的8次方, 可简写为 1.03E+08 的形式.
1
2
3
4
5
6
7

f1 = 1.1

print(f1)  # 1.1
print(type(f1))  # 

# 科学计数法
f2 = 1.03e8
print(f2)  # 103000000.0
print(type(f2))  # 

1
2
3
4
5
6
7
8
9
10

2. 尾数问题

浮点数之间进行计算时会存在不确定尾数的情况, 这个是计算机内部运算产生的.
1

# 尾数问题
f1 = 0.1 + 0.2
print(f1)  # 0.30000000000000004

print(f1 == 0.3)  # False

1
2
3
4
5
6

3. 溢出问题

print(10 ** 1000) 
print(10.0 ** 1000)

1
2
3

运行工具窗口显示:
10000000000000000000000000000000000000....
Traceback (most recent call last):
  File "C:\Users\13600\PycharmProjects\test\test.py", line 3, in <module>
    print(10.0 ** 1000)
    
# 溢出错误: (34, "结果太大")
OverflowError: (34, 'Result too large')
1
2
3
4
5
6
7
8

4. 高精度计算模块

decimal 高精度计算模块, 官网: https://docs.python.org/zh-cn/3/library/decimal.html

优点:
* 1. Decimal 所表示的数是完全精确的.
* 2. Decimal类包含有效位的概念, 保留尾随零以表示有效位, 例如: 1.30 + 1.20的结果是2.50.
* 3. Decimal具有可更改的精度(默认为28位).

使用方法: 
* 1. 导入模块
from decimal import Decimal
* 2. 使用Decimal将浮点型数据进行转换, 要求输入的必须是字符串, 则不会使用 decimal 模块的运算．
对象(十进制浮点数类型) = Decimal('0.10')  
* 3. 使用转换之后的十进制类型对象参与计算
1
2
3
4
5
6
7
8
9
10
11
12
13

# 使用Decimal避免尾数问题.
from decimal import Decimal

# 类型转换在计算
f1 = Decimal('0.10') + Decimal('0.20')
print(f1, type(f1))  # 0.30 

f2 = 0.30
print(f1 == f2)  # False

# 将 转为字符串
f2 = str(f2)

# 将字符串类型纯数字转为十进制类型
print(f1 == Decimal(f2))  # True

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 解决溢出问题
from decimal import Decimal

# 类型转换在计算
f1 = Decimal('10.0') ** Decimal('1000')
print(f1)  # 1.000000000000000000000000000E+100000

1
2
3
4
5
6
7

1.3 complex 复数

复数是由'实部'与'虚部'构成. Python 中, 复数以j或J为后缀.
1

c1 = 0.5j

print(c1)  # 0.5j
print(type(c1))  # 

1
2
3
4
5

1.4 bool 布尔值

布尔值只有 True'真' 与 False'假', (首字母大写). 
布尔值常用条件判断表达式.
1
2

Python 中的'真'与'假'的值:
假：False, None,  0,  0.0,  '',  [],  {},  (,) ··· 所有为空的元素···
真: 除上之后都为真.
1
2
3

Python 中 布尔值是属于数字类型, bool 类 继承 int 类.
isinstance(值, 类型) 函数判断某个值是否属于否个类型.
1
2

2. 运算符

2.1 算术运算符

算术运算符: +  -  *  /  %  //  **

* 整数与浮点数计算的话会结果是浮点型, 整数做除法运算时结果为浮点型.
* 浮点数之间进行计算时会存在不确定尾数的情况.
  这个是计算机内部运算产生的, 在使用浮点数的时候, 最后设置保留的小数尾数, 以免出现意外.
1
2
3
4
5

num_0 = 3
num_1 = 7

num = num_0 + num_1 
print(num)  # 10

num = num_1 - num_0
print(num)  # 4

num = num_1 * num_0
print(num)  # 21

num = num_1 / num_0
print(num, type(num))  # 2.3333333333333335 

num = num_1 // num_0
print(num)  # 2

num = num_1 % num_0
print(num)  # 1

num = num_1 ** num_0
print(num)  # 343

print(9 // 4)  # 9 / 4 = 2.25   向下取整  为 2
print(-9 // 4)  # -9 / 4 =-2.25 向下取整  为-3 ，负数向下-3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

2.2 增值运算符

增值运算符: +=  -=  *=  /=  %=  //=  **=
1

num = 3
num_0 = 5
num_1 = 7

num += num_1  # 10 等同于  num = num + num_1
print(num)

num -= num_1  # 3 等同于  num = num - num_1
print(num)

num *= num_1  # 21 等同于  num = num * num_1
print(num)

num /= num_1  # 3.0 等同于  num = num / num_1
print(num)

num **= num_1  # 2187.0 等同于  num = num ** num_1
print(num)

num %= num_1  # 3.0 等同于  num = num % num_1
print(num)

num_1 //= num_0  # 5 等同于  num = num // num_1
print(num_0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

3. 类型转换

3.1 转换为整型

Python 内置 int() 函数将括号内的数据转为整型.
并是不所有数值都可以转换为整型. 
支持:
浮点型, 浮点型转整型舍去小数部分数据.
纯整型字符串, 不能是浮点型字符串, 否则会报错: TypeError:int () 无法转换...
1
2
3
4
5

i1 = 18

print(i1, type(i1))  # 18 

# 将纯整型字符串转为整型
i1 = int('123') 
print(int(i1), type(i1))   # 123 

# 将浮点型转为整型
i2 = int(1.2)
print(i2, type(i2))  # 1 

1
2
3
4
5
6
7
8
9
10
11
12

3.2 转为浮点型

Python 内置 float() 函数将括号内的数据转为浮点型.
并是不所有数值都可以转换为浮点型. 支持整型, 纯整型/纯浮点型字符串.
否则会报错: ValueError: 无法将xxx转为浮点型...
1
2
3

f1 = 123.4

print(f1, type(f1))  # 123.4 

# 整数类型转浮点型
print(float(123))  # 123.0

# 纯整型字符串转浮点型
print(float('123'))  # 123.0

# 将浮点型字符串转为浮点型
print(float('123.4'))  # 123.4

1
2
3
4
5
6
7
8
9
10
11
12
13

4. 进制转换

* 结果是字符串类型
1

4.1 十进制转二进制

bin() 十进制转二进制,   使用 ( 0b ) 开头表示二进制数.
1

b1 = bin(100)
print(b1, type(b1))  # 0b1100100 

1
2
3

4.2 十进制转二进制

oct() 十进制转八进制,   使用( 0o ) 开头表示十进制数.
1

o1 = oct(100)
print(o1, type(o1))  # 0o144 

1
2
3

4.3 十进制转十六进制

hex() 十进制转十六进制, 使用( 0x ) 开头表示十六进制数
1

h1 = hex(100)
print(h1, type(h1))  # 0x64 

1
2
3

4.4 转为十进制

int() 函数支持将二进制, 八进制, 十六进制数转为十进制整数.

使用格式: int('各进制字符串', 进制)
第一个参数: 需要将进制数用单引号扩起来.
第二个参数: 写现在是多少位的进制数.
1
2
3
4
5

# 二进制转十进制
i1 = int('0101010101', 2)
print(i1, type(i1))  # 341 

1
2
3
4

# 八进制转十进制
i2 = int('   7654321', 8)
print(i2, type(i2))  # 2054353 

1
2
3
4

# 十六进制转十进制
i3 = int('   A6B4321', 16)
print(i3, type(i3))  # 174801697 

1
2
3
4

5. 常用函数

5.1 绝对值

Python 内置 abs() 函数计算数字的绝对值.
1

print(abs(-10.1))  # 10.1

1
2

5.2 商余

Python 内置divmod() 函数把除数和余数运算结果结合起来, 返回一个包含商和余数的元组(a // b, a % b).
1

print(divmod(7, 2))  # (3, 1)

1
2

5.3 幂余

Python 内置 pow() 函数计算的次方及计算此方的余数.
pow(x, y)    计算x的y次方.
pow(x, y, z) 计算x的y次方再对z求余.
1
2
3

print(pow(2, 4))  # 16
print(pow(2, 4, 3))  # 1

1
2
3

5.4 四舍五入

Python 内置 round() 函数按指定的小数位进行四舍五入运算, 默认不保留小数部分.
1

print(round(9.4545))  # 9
print(round(9.4545, 2))  # 9.45

1
2
3

5.5 求最大值

Python 内置 max() 函数返回给定参数的最大值, 参数可以为序列.
1

# 生成一个整型序列
print(max(range(4)))  # 3

print(max([1, 2, 3]))  # 3

print(max(1, 2, 3))  # 3

print(max('abc'))  # c

1
2
3
4
5
6
7
8
9

5.5 求最小值

Python 内置 min() 函数返回给定参数的最小值, 参数可以为序列.
1

# 生成一个整型序列
print(min(range(4)))  # 0

print(min([1, 2, 3]))  # 1

print(min(1, 2, 3))  # 1

print(min('abc'))  # a

1
2
3
4
5
6
7
8
9

---

文章的段落全是代码块包裹的, 留言0是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言1是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言2是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言3是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言4是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言5是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言6是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言7是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言8是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言9是为了避免文章提示质量低.

---