五、六大数据类型之数字

Python3 六大基本数据类型之数字

一、四种数字数值类型

    python3 支持四种数字数值类型

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点
• 浮点型(float) - 浮点型由整数部分与小数部分组成
• 复数( (complex)) - 复数由实数部分和虚数部分构成
• 布尔类型(bool) True = 1 False=0

# python中创建一个变量。不需要指定数据类型。直接赋具体的值即可。（这点和Java完全不一样）
a = 2
b = 2.0
c = 2+3j
d = True

print(type(a))
print(type(b))
print(type(c))
print(type(d))

打印结果如下

<class 'int'>
<class 'float'>
<class 'complex'>
<class 'bool'>

2、数值类型之间的转换

     把浮点、布尔类型转化成整型数字 。以及其他进制的整型数字转换成十进制的整数。使用函数int(x,base=10)

• x 为纯数字的时候。即为浮点 布尔类型的时候。直接转换成int类型。
• 当x 为进制整数 要转换成 十进制。x必须以字符串类型传参。base默认传入的参数是十进制格式。

a = int(2.6) # 浮点类型转整数
b = int(True) # 布尔类型转整数
c = int('1011011',base=2)  # 二进制整数 转化成 十进制整数
d = int('10',base=10)
e = int('a',base=16) # 十六进制整数 转化成 十进制整数

print(type(a),a)
print(type(b),b)
print(type(c),c)
print(type(d),d)
print(type(e),d)

打印结果如下：

<class 'int'> 2
<class 'int'> 1
<class 'int'> 91
<class 'int'> 10
<class 'int'> 10

把int bool 类型数字转换成 folat 。 使用folat() 函数

a = float(1)
b = float(False) 

print(type(a),a)
print(type(b),b)

打印结果：

<class 'float'> 1.0
<class 'float'> 0.0

把整型、浮点、布尔类型 转换成 复数。使用complex() 函数

a = complex(1)
b = complex(2.2)
c = complex(True)

print(type(a), a)
print(type(b), b)
print(type(c), c)

打印结果：

<class 'complex'> (1+0j)
<class 'complex'> (2.2+0j)
<class 'complex'> (1+0j)

ps: python不支持直接把复数转化成整型 浮点 布尔类型

3、运算符的使用

    算术运算符的使用

•  加减乘除. 复数可以相加减，但是不能乘除运算。

# 数字的运算和数学上的是一致的。但是整数型和浮点数不管是加减乘除之后一定都是浮点数
print(1+2)
print(1+2.2,type(1+2.2))
print(1-2.3,type(1-2.3))
print(1.2*0,type(1.2*0))
print(1*2.2,type(1*2.2))
print(-1*2.3)
print(2 ** 3) # 2的3次方
print(1+True)
print(1+False)
print(11/3) # 数学除法
print(11//3) # 只保留整数部分
print(11%3) # 取余数
print(1+(2+3j)+True+3.33,type(1+(2+3j)+True+3.33)) # 4种类型相加等于一个复数

打印结果：

3
3.2 <class 'float'>
-1.2999999999999998 <class 'float'>
0.0 <class 'float'>
2.2 <class 'float'>
-2.3
8
2
1
3.6666666666666665
3
2
(7.33+3j) <class 'complex'>

    比较运算符的使用

• 4种数字类型直接是可以比较值的。

a = 1
b = 1.0
c = True
d = 1 + 0j

print(a == b)
print(a == c)
print(a == d)
print(b == c)
print(b == d)
print(c == d)

打印结果：

True
True
True
True
True
True

• 特殊情况

e = 3.3
f = 1.1 + 2.2
print(e == f)

打印结果：

False

原因和python以及运算没有任何关系。这是计算机浮点数存储的问题。因为不轮我们用什么语言编写代码来运算。最终都是转换成二进制数据来处理。

我们编程使用的都是十进制数据。十进制转换成二进制如下。

整数部分都要以2的0次方（20）到2的无穷次方（2∞）表示，这没有问题，只要长度足够就能表示出所有奇数和偶数。2 = 1 * 21 + 0 * 20 = 10

小数部分都要以2的-1次方（2-1）到2的负无穷次方（2-∞）表示，这就有问题，因为比如2-1...2-∞不管怎么组合都不能完全等于0.2。0.2 = 0 * 2-1 + 0 * 2-2 + 1 * 2-3 ...

所以一旦涉及的小数不能完全由二进制通过加权法得到。那么系统会用一个近视值来替代。所以出现了1.1+2.2=3.3000000000000003

其他类型的运算符使用在学习运算符的时候基本都过了，此处不再详记

4、数字的存储原理

• 分别创建2个数字值相等的变量。

a, b = 1000, 1000
print(a is b, id(a), id(b))

打印结果：

False 4439607600 4433529104  

2个变量赋值的原理：分别给 a b 2个变量开辟一个值为1000的内存,并分别指向对应的内存区域。所以虽然他们值一致。但是他们引用的对象不是同一个。（因为他们指向的内存区域ID不同）

• 先创建一个变量。在把值赋给一个新的变量。

a = 1000
b = a
print(a is b, id(a), id(b))
a = 1001
print(a is b, id(a), id(b))

打印结果：

True 4533156144 4533156144
False 4537417360 4533156144

代码执行逻辑。 a = 1000   首先为1000这个值开辟一块内存，然后变量a指向这块内存区域 ，b = a  因为a的值已经有一块内存，所以直接让变量b也指向这块内存区域   ， a is b 结果为True。2个变量指向的内存地址也是同一个。

当a的值发生变化时，相当于重新为新的值开辟一块内存。变量a重新指向新的内存区域，但是b的值未变化，所以指向的内存区域不变，引用的内存地址也不会变，最终 a is b 结果为False

• 特殊机制

如上面代码所示

为什么2个值赋予1 和 2个值赋予1000。结果居然是不一样的？

这个是python的机制。对于-5～256 之间的整数。为了优化性能在启动的时候就已经分配给这些值一块内存。所以a=1和 b=1的过程。并不是像上面说的。先给值1开辟一块内存。而是这个值的内存区域已经存在。所以当变量的值等于这个范围的时候。是直接指向同一块内存区域。1000不属于这个范围。所以还是按正常的机制。分别开辟了2个值为1000的内存。所以他们的内存地址也是不一致的

当我们判断2个变量是不是同一个对象。我们不必在于它是否已经存在的还是缓存过的。我们直接看2个数字存储的id是否一致。如果是一致。说明指向的内存是同一个。

5、数字的常用函数

print(abs(-10))  # 返回数字的绝对值
print(pow(3,4))  # 计算3^4
print(round(3.335,2)) # 按照四舍大于五入保留2位小数
print(round(3.3351,2)) # 按照四舍大于五入保留2位小数

打印结果如下：

10
81
3.33
3.34

还有些数字计算的内置库。有兴趣的可以去看math模块