python基础——数据类型(二)数字型

¶1.整型：int

整数数据类型，简称整型，没有小数数字。

数字中的正整数、0和负整数均为整型，但只有int一种整数类型，表示为长整型

整型的长度范围不限，精度无限。

a=114514
b=0
c=-123456789000000
print(a," ",type(a))
print(b," ",type(b))
print(c," ",type(c))
#运行结果:
# 114514   <class 'int'>
# 0   <class 'int'>
# -123456789000000   <class 'int'>

另外可以用二进制、八进制或者十六进制来表示整型：

a=0x1111 #十六进制
b=0Xffff #x可以大写，后面同
c=0b01010 #二进制
d=0B101111
e=0o111 #八进制
f=0O333
print(a,b,c,d,e,f,sep="\n")
#输出结果：
# 4369 对应16^3+16^2+16^1+16^0
# 65535
# 10  对应2^3+2^1
# 47
# 73  对应8^2+8^2+8^0
# 219

各进制之间允许转换：

• 二进制：bin()

• 八进制：oct()

• 十六进制：hex()

• 十进制：int()

注意上面三个返回的是字符串，如要当整型使用请使用函数*int(对应进制字符串变量名，对应进制数)*来完成转换

print('十进制数 63 转换为二进制数为：', bin(63))
print('十进制数 63 转换为八进制数为：', oct(63))
print('十进制数 63 转换为十六进制数为：', hex(63))
# 输出结果：
# 十进制数 63 转换为二进制数为： 0b111111
# 十进制数 63 转换为八进制数为： 0o77
# 十进制数 63 转换为十六进制数为： 0x3f

a=0b111111 #a为二进制
b=bin(63)  #b为从十进制63转化而得的而得的二进制0b111111
c=int(0b111111) #c为从二进制0b111111转化得到的十进制数
d=int(b,2) #注意b为字符串，字符串的转化为传入变量和需要转化成的进制数
print(type(a))
print(type(b))
print(type(c))
print(type(d))
#输出结果：
# <class 'int'>
# <class 'str'> 得到字符串
# <class 'int'> int转化就是整型
# <class 'int'> bin()转化后的二进制字符串通过int()转化为了10进制数字

print('二进制数 0b111111 转换为十进制数为：', 0b111111)   # print() 函数输出整数默认为十进制
print('二进制数 0b111111 转换为八进制数为：', oct(0b111111))
print('二进制数 0b111111 转换为十六进制数为：', hex(0b111111))
#输出结果：
# 二进制数 0b111111 转换为十进制数为： 63
# 二进制数 0b111111 转换为八进制数为： 0o77
# 二进制数 0b111111 转换为十六进制数为： 0x3f
# 其他进制转换请自行尝试

如果数字太长，可以使用数字分隔符”_“，从右往左每三位添加一个，不会影响结果，方便阅读。

x=10_000_000_000_000_000
print(x)
#输出结果：
# 10000000000000000

¶2.浮点型：float

浮点数数据类型，简称为浮点型，专用于存储浮点小数。

python中没有double浮点数类型，只有float，但是是双精度的。

float的表示可以是十进制表示形式或者指数形式。

十进制表示方法中，float类型里必须含有小数点，但可以没有整数部分或小数部分。

a = 3.14
b = 3. #没有后面，默认为0
c = .14 #没有前面，默认为0
print(a," ",type(a))
print(b," ",type(b))
print(c," ",type(c))
运行结果：
3.14   <class 'float'>
3.0   <class 'float'>
0.14   <class 'float'>

指数形式表示时，形式为aEn或者aen 等价于a x 10ⁿ

a为尾数部分，是十进制数；n为指数部分，同为10进制数，而E或e是固定字符，表示分割尾数部分和指数部分。

值得一提的是，只要使用了指数形式来表示一个数，无论这个数的值如何，均为float类型。

a=314159.26e-5
b=1.1e4
c=3e9 #整数值，但是是浮点数
d=9e0 #浮点数
e=0e3 #0.0也是浮点数
print(a," ",type(a))
print(b," ",type(b))
print(c," ",type(c))
print(d," ",type(d))
print(e," ",type(e))
# 运行结果：
# 3.1415926   <class 'float'>
# 11000.0   <class 'float'>
# 3000000000.0   <class 'float'>
# 9.0   <class 'float'>
# 0.0   <class 'float'>

浮点数的范围极大，但是如果位数过多会导致输出可能舍去一部分数字，而数字值本身巨大时（不一定是位数多）直接采用科学计数法输出。

当然也可以直接使用格式化输出（此处略，有兴趣的可以自行测试）。

a=1.234567891011121314151617181920
b=12345678910111213141516.171819
print(a)
print(b)
# 输出结果：
# 1.2345678910111213  #舍去一部分数值输出
# 1.2345678910111212e+22 #舍去的同时因为数值太大，采用科学计数法输出。

计算机以二进制存储小数部分，会导致误差。

和十进制中1/3此类的无穷小数类似，如1.68，0.3等都是二进制中的无穷小数，所以在某些情况下，原本看似正确的小数（这个其实是计算机对原数值进行推测而显得正确的）输出实际上会产生问题：

a = 1 + 0.68
b=0.1+0.1+0.1
print(a)
print(b)
# 输出结果为
# 1.6800000000000002
# 0.30000000000000004

因此，如果需要判断两个浮点数是否相等/得到我们想要的正确值，往往需要进行取近似值的操作。

对于python来说，浮点数是64位的，54位存位数，10位存指数。我们可以不选择在54的范围内比较其正确与否，而是缩小比较位数范围，比如在8位以内比较是否相等。

a = 1.68
b = 1 + 0.68
print("a={:.20}".format(a))  #格式化输出
print("b={:.20}".format(b))
eps = 0.00000001
if abs(a - b) < eps:    #看看精度在0.00000001范围内是否相等
    print("a == b")
# 输出结果：

a=1.6799999999999999378
b=1.6800000000000001599
a == b

¶3.布尔型：bool

布尔数据类型，简称布尔型，实际上是int类的一个子类。

含有关键字True （表示真）和False（表示假）（注意要大写）

布尔型主要用于判断对错（True=1=正确，False=0=错误），布尔运算，来判断某个条件是否成立。

print(True)  # True 首字母要大写
print(False)  # False 首字母要大写
print(type(True))  # 查看 True 的类型
print(type(False))  # 查看 False 的类型
# 输出结果：
# True
# False
# <class 'bool'>
# <class 'bool'>

尽管bool类型只有True和False两个实例，但是任何对象都可以进行真假值的判断。

下面举一些特殊的例子

print(bool(1)) #True
print(bool(0)) #False 
print(bool([])) #False
print(bool(())) #False
print(bool({})) #FALSE
print(bool(-1)) #True
print(bool('')) #False
print(bool("False")) #True
print(bool("True")) #True
print(bool(0.0))  #False
print(bool(1.0))  #True
print(bool(-0.0)) #False

实际上，各种空的内容被判断为False，而非空内容被判断为True

数值类型中，只有0.0, -0.0和0是False

另外range(0) ,0j , None等也是False

布尔型参与的布尔运算中，使用的关联词是 and or not ，逻辑和一般逻辑运算相同。（不再详细介绍）

print(True and True)
print(True and False)
print(False and True)
print(False and False)
print(True or True)
print(True or False)
print(False or True)
print(False or False)
print(not True)
print(not False)
# 输出结果：
# True
# False
# False
# False
# True
# True
# True
# False
# False
# True

¶特殊类型：None

之所以放在这里，是因为None类型和布尔型的关系比较紧密。

None表示空，但是并不是空字符串、空列表等等，也不等于False（当然在条件判断中if None被认为是False），而是一个特殊的值，表示的是没有值，也就是空值，属于特殊类型NoneType，而且None是这个类型的唯一值。

None作用和其他语言中的Null，nil或者undefined类似，不过None可以赋给任何一个变量。

None实际上就是无返回值的实际返回值。

不管变量是什么值（包括空列表、空字符串等等），除非变量就是None，否则和None作相等的布尔运算时始终为False。

对于not 变量，如果变量就是None，not None被认为是True。因此，判定变量空操作时，比较建议写if not 变量

此时不论是None还是其他空值，均返回True。

a=None
b = False
c = []
d=""
print(type(a)) #输出类型
print(bool(None)) #判断None的布尔类型
if a==b or a==c or a==d:
    print("Y")
else:
    print("N")
if b is None or c is None or d is None:
    print("Y")
else:
    print("N")
# 判断None和空列表、空字符串和False是否相等
# 输出结果:
# <class 'NoneType'>
# False
# N
# N

¶4.复数类型：complex

复数数据类型，简称复数类型，和其他语言不同，python中复数类型是内置类型，是数字类型的一部分，支持直接书写，不依赖其他库。

复数由实部和虚部组成，虚部带有后缀J/j，且实部和虚部的数值均为浮点数。

具体形式为 a+bj / a+bJ，a为实部，b为虚部。

complex1=10+5j
complex2=10-5j #可以是-号
print(complex1," ",type(complex1))
# 运行结果
# (10+5j)   <class 'complex'>

python支持从复数中提取实部和虚部：

complex1=123+321j
r=complex1.real
i=complex1.imag
print(r," ",type(r))
print(i," ",type(i))
# 输出结果为：
# 123.0   <class 'float'> #实部内的数为浮点数，即使在复数中看起来是整数
# 321.0   <class 'float'> #虚部内的数为浮点数，即使在复数中看起来是整数

复数的计算：相信能看到这篇博客的你应该不能不会复数的计算😉，我就不写啦，自己去试试呗~