版权声明：转载请注明来源及作者，谢谢！ https://blog.csdn.net/qq_42442369/article/details/84310372
content
- 整数型int
- 布尔型bool
- 浮点型float
- 复数型complex
- 以及上述类型的转化
一、数值类型
1. 整数型int
（1）整数的定义
# 数学上定义的整数 1 2 -50
# 变量名 = 整数数值
a = 10
print(type(a))
# int
（2）取值范围
"""
python底层是c语言 int long
python 2.2版本之后，就取消long，直接将整型归结int
"""
（3）四种进制
"""
N进制，逢N进1
1. 二进制（使用 0b或者0B做前缀）
2. 八进制（使用0o或者0O做前缀）
3. 十进制
4. 十六进制（使用0x或者0X做前缀）
"""
x=0b10001100
print(type(x))
print(x)
# <class 'int'>
# 140
（4）四种进制之间的转换
"""
1) 十进制转换成其他进制
将x转换成2进制？
x=25
使用下除法
被除数：十进制的数
除数：要转换成的进制
取商和余数，方向，从下往上
"""
"""
2) 其他进制转换成十进制
乘幂法
将y转换成十进制
y=0b1100
底数：当前的进制
幂：从右到左，从0开始计位，当前的位
练习：
（1）x=58 转换成8进制，16进制
（2）y=0b1010，转换成10进制 1*2**3+1*2**1=10
底数：当前的进制 2
幂：从右到左，从0开始计位，当前的位 3 1
"""
"""
3) 其他进制之间转换
*手算法*
二进制和八进制：二进制的三位对应八进制的一位
z=0o765
111110101
z=0b10101111111
0o2577
二进制和十六进制：二进制的四位对应十六进制的一位
z=0x765
011101100101
z=0b10101111111
57f
"""
# *引用函数*
# bin():将数值转换成二进制
z=0o765
print(bin(z),type(bin(z)))
# z结果：0b111110101 <class 'str'>
# 注意：python中对于进制转换使用的函数，只有int的返回值是数值类型，其他都是str类型
# int():将数值转换成十进制
z=0b10101111111
print(int(z),type(int(z)))
# oct():将数值转换成八进制
print(oct(z),type(oct(z)))
# hex():将数值转换成十六进制
z=0b10101111111
print(hex(z),type(hex(z)))
# 注意：进制转换后type是str，str只能和str进行计算
x=101
print(x+1)
# 102
print(bin(101)+1)
# TypeError: must be str, not int
print(bin(101)+bin(1))
# 0b11001010b1
# *关于int的进制用法print(int(字符串,n))*
# 关于int的进制用法print(int(字符串,n))
# 就是将字符串看成n进制的数，进行int转换
print(int("100",8)) # 可以 将100看成8进制，做int转换
print(int("9800",2)) # ValueError: invalid literal for int() with base 2: '9800'
print(int("100")) # 100 因为默认就是十进制
2. 布尔型 bool
# 布尔类型是整数类型的子类型
# True False
# 整数类型 0（False） 1（True）
# 定义布尔类型
# 变量名=变量值
# 在实际的开发中不要这样
x=True
print(x,type(x))
print(x+1)
# bool主要的应用：
a=3
b=5
print(a<b)
浮点型 float
（1）浮点的定义
"""
小数 0.1 2.2
python的浮点类型只支持十进制
变量名=浮点数
# 浮点类型定义时，前面可以加0，整数类型不可以
"""
f=01.1
print(f,type(f))
# 1.1 <class 'float'>
（2）浮点类型的科学计数法
print(1.2E8)
print(1.2e-8)
# 1.2*10**8 120000000.0
# 1.2e-08
（3）取值范围
# 浮点数是有范围的
import sys
print(sys.float_info.max)
print(sys.float_info.min)
print(1.2e1001)
# 1.7976931348623157e+308
# 2.2250738585072014e-308
# inf
（4）特殊的浮点数
"""
# inf： 无穷 +inf 无穷大 -inf 无穷小
# nan : 不是一个数字,表示一个数，但是是一个无效的数字
"""
# nan的应用
print(float("inf"),type(float("inf")))
print(float("nan"),type(float("nan")))
a=float("inf")
print(a*0)
print(a/a)
# inf <class 'float'>
# nan <class 'float'>
# nan
# nan
# nan跟谁都不相等
a=float("nan")
b=float("nan")
print(a==b) # False
# math模块中isnan函数可以判断对象是否是nan
import math
c=1
print(math.isnan(c))
# False
（5）浮点类型的不精确性
# 浮点类型在计算机中是近似存储
print(1/3)
print(10/3)
# 0.3333333333333333
# 3.3333333333333335
# 为什么浮点类型不精确？二进制
# 小数的二进制规则 ：小数位*2，取整数位，从上到下
# 例子
"""
0.1
0.1*2=0.2 0
0.2*2=0.4 0
0.4*2=0.8 0
0.8*2=1.6 1
0.6*2=1.2 1
0.2*2=0.4 0
原因：小数在计算机中真实的存储，有可能是无限的二进制小数。
0.25
0.25*2=0.5 0
0.5*2=1.0 1
"""
# 使用浮点数的时候要注意：
# (1)避免数量级相差很大的浮点数之间进行运算
# 运算的时候无法跨越到下一个数量级
f1=5e20
f2=1
print(f1+f2)
#（2）浮点数避免进行等量判断
f1=0.1
f2=0.2
print(f1+f2==0.3)
# print(f1+f2)
# 解决浮点类型的不精确性
print(f1)
# 需要使用decimal模块显示浮点类型的原型
import decimal
print(decimal.Decimal(0.1))
print(decimal.Decimal("inf"))
print(decimal.Decimal("nan"))
print(decimal.Decimal(0.25))
# 0.1000000000000000055511151231257827021181583404541015625
# Infinity
# NaN
# 0.25
# 希望数学0.1+0.2
# 使用字符串传入浮点类型，使得浮点类型变得精确
x=decimal.Decimal("0.1")
y=decimal.Decimal("0.2")
print(x+y)
print(x+y==0.3)
print(x+y==decimal.Decimal("0.3"))
# 0.3
# False
# True
# 慎用，需要占用内存
print(decimal.Decimal(0.1))
#获得浮点数保留的位数
print(decimal.getcontext().prec)
# 永远是28位
# 可以自行设置decimal.getcontext().prec保留位数
import decimal
decimal.getcontext().prec=5
x=decimal.Decimal(0.1)
print(x)
# 0.1000000000000000055511151231257827021181583404541015625
y=decimal.Decimal(0.2)
print(y)
# 0.200000000000000011102230246251565404236316680908203125
# 特别注意：只有在参与运算之后才生效。
print(x+y)
# 0.30000
4. 复数型 complex
# 4 === 2**2
# 数学上 实部+虚部 a+bi
# python 实部+虚部j
# 定义： 变量名= 复数
c=2+1j
print(c,type(c))
# (2+1j) <class 'complex'>
# 复数中的实部和虚部都是使用浮点数表示
print(c.real)
print(c.imag)
# 2.0
# 1.0
import cmath
print(cmath.sqrt(-4))
# import math
# print(math.sqrt(-1))
5. 类型转换
"""
int(value)-----将value转换成整数类型
float(value)---将value转换成浮点类型
bool(value)---将value转换成布尔类型
complex(value)---将value转换成复数类型
"""
i=2
f=-2.0
c=0j
b=True
# (1) int(value)-----将value转换成整数类型
print(int()) # value如果不写参数，默认会得到0
print(int(f)) # -2 将浮点类型中的小数部分去掉
# print(int(c)) # 不能将个复数类型转换成整数类型
print(int(b)) # 1
# (2)float(value)---将value转换成浮点类型
print(float()) # value如果不写参数 ，默认得到0.0
print(float(i)) # 2.0
# print(float(c)) # 复数类型也不能转换成浮点类型
print(float(b)) # 1.0
#（3）bool(value)---将value转换成布尔类型
# 任何一种数据类型都可以转换成布尔类型
# 整数0、浮点0.0、复数0j 对应的布尔类型都是False，除此之外都是True
print(bool()) # value如果不写参数，默认得到False
print(bool(i)) # True
print(bool(c)) # False
print(bool(f)) # True
#（4）complex(value)---将value转换成复数类型
print(complex()) # 如果value不写，默认返回是0j
print(complex(i)) # (2+0j)
print(complex(f)) # (-2+0j)
print(complex(b)) # (1+0j)
# 两种类型之间做运算，结果取级别高的进行存储
# 复数类型 > 浮点类型> 整数
i=3
f=-2.0
c=0j
b=True
print(i+f) # 1.0
print(c+f) # (-2+0j)