6大数据类型相互转换

定义：Python中的不同数据类型是不能进行转换的，所以我们需要数据类型转换，一共分为两种类型转换

• 自动类型转换
• 强制类型转换

在Python中：

• 容器类型数据：字符串，列表，元组，字典，集合
• 非容器类型数据：数字类型，布尔类型

自动类型转换

定义：当两个不同类型的数据进行转换时，结果会进行计算

a = 10
b = True        # True 代表数字 1
print(a + b)    # 11 重点：精度等级（布尔类型  <  整形）所以最终转换为整形

c = 3.14
print(a + c)    # 13.14 重点：精度等级（整形  <  浮点类型）所以最终转换为浮点类型

精度等级：布尔类型 < 整形 < 浮点类型

强制类型转换

要进行数据类型转换，首先我们需要确定数据类型是什么，使用type（）函数

type 检测数据类型
str = "123"
print(type(str))        # <class 'str'> 字符串类型
num = 123
print(type(num))        # <class 'int'> 整形类型
l = [1, 2, 3, 4]
print(type(l))          # <class 'list'> 列表类型
t = (1, 2, 3, 4)
print(type(t))          # <class 'tuple'> 元组类型
s = {1, 2, 3, 4}
print(type(s))          # <class 'set'> 集合类型
d = {"name": "小明"}
print(type(d))          # <class 'dict'> 字典类型
b = True
print(type(b))          # <class 'bool'> 布尔类型
f = 3.1415926
print(type(f))          # <class 'float'> 浮点类型
# type() 函数也可以直接放数值检测
print(type(3.14))       # <class 'float'> 浮点类型

str（）强制类型转换

定义：所有数据类型都可以转换为字符串类型

num = 123
resNum = str(num)
print("resNum = {}，type(resNum) = {}".format(resNum, type(resNum)))   # resNum = 123，type(resNum) = <class 'str'>
f = 3.1415926
resf = str(f)
print("resf = %s，type(resf) = %s" % (f, type(resf)))    # resf = 3.1415926，type(resf) = <class 'str'>

数字类型强制转换

int和float强制类型转换

定义：

• int()：可以把其他类型数据转换为整形；
• float()：可以把其他类型数据转换为浮点类型；

注意：数字类型之间可以相互转换；只有字符串可以转换为数字类型，并且字符串中的元素必须为纯数字，否则无法转换！

a = 123
ra = float(a)   # int 数据类型强制转换为 float 数据类型
print(ra)       # 123.0

b = 3.1415926
rb = int(b)     # float 数据类型强制转换为 int 数据类型，不遵守四舍五入
print(rb)       # 3

# True 代表 1 False 代表 0
c = True
rc = int(c)     # Bool 数据类型强制转换为 int 数据类型
print(rc)       # 1
fc = float(c)   # Bool 数据类型强制转换为 float 数据类型
print(fc)       # 1.0

d = False
rd = int(d)
print(rd)       # 0
fd = float(d)
print(fd)       # 0.0

e = "345"
re = int(e)     # 字符串纯数字类型转换为 int 整形
print(re)       # 345

# 字符串转为浮点类型
f = "3.1415926"
fe = float(f)
print(fe, type(fe)) # 3.1415926 <class 'float'>

Bool类型强制转换

定义：Bool可以把其他数据类型转换为True或者False

• 容器类型转布尔类型

容器中为空 ====> False
容器中有元素 ====> True

• 数字类型转布尔类型

int 类型中 0 为 False，其他值为 True
float 类型中 0.0 为 False，其他值为 True

a = ""      # 空字符串
b = []      # 空列表
c = ()      # 空元组
d = {}      # 空字典
e = set()   # 空集合
print(bool(a), bool(b), bool(c), bool(d), bool(e))  # False False False False False

f1 = 0.0
f2 = 3.14
print(bool(f1), bool(f2))   # False True

g1 = 0
g2 = 1
print(bool(g1), bool(g2))   # False True

list强制数据类型转换

定义：

python的数据类型强制转换：list()
（1）数字类型是非容器类型，不能转换为列表；
（2）字符串转列表时，会把字符串中的每一个字符当作列表的元素；
（3）元组转列表时，会把元组中的每一个元素当作列表的元素；
（4）字典转列表时，只会保留字典中的键值；
（5）集合转列表时，结果是无序的，因为集合本身就是无序的

# a = 123
# ra = list(a)
# print(ra)     # a 是整形数字，转换为列表直接报错

# 字符串转列表时，会把字符串中的每一个字符当作列表的元素；
b = "123abc"
rb = list(b)
print(rb)       # ['1', '2', '3', 'a', 'b', 'c']

# 元组转列表时，会把元组中的每一个元素当作列表的元素；
c = (1, 2, 3, "abc")
rc = list(c)
print(rc)       # [1, 2, 3, 'abc']

# 字典转列表时，只会保留字典中的键值；
d = {
    "username": "帅帅",
    "age": 21,
    "hobby": "打羽毛球"
}
rd = list(d)
print(rd)   # ['username', 'age', 'hobby']

# 集合转列表时，结果是无序的，因为集合本身就是无序的
# 重点：【转换是随机的】
e = {1, 2, 3, "study", "python", "forever"}
re = list(e)
print(re)   # [1, 2, 3, 'study', 'forever', 'python']

Tuple强制类型转换

定义：

python的数据类型强制转换：tuple
其他类型数据类型元组类型与其他类型转元组类型的规则相同
（1）数字类型是非容器类型，不能转换为元组；
（2）字符串转元组时，会把字符串中的每一个字符当作元组的元素；
（3）列表转元组时，会把列表中的每一个元素当作元组的元素；
（4）字典转元组时，只会保留字典中的键值；
（5）集合转元组时，结果是无序的，因为集合本身就是无序的

# a = 123
# ra = tuple(a)
# print(ra)     # a 是整形数字，转换为元祖直接报错

# 字符串转元组时，会把字符串中的每一个字符当作元组的元素；
b = "123abc"
rb = tuple(b)
print(rb)       # ('1', '2', '3', 'a', 'b', 'c')

# 列表转元组时，会把列表中的每一个元素当作元组的元素；
c = [1, 2, 3, "abc"]
rc = tuple(c)
print(rc)       # (1, 2, 3, 'abc')

# 字典转元组时，只会保留字典中的键值；
d = {
    "username": "帅帅",
    "age": 21,
    "hobby": "打羽毛球"
}
rd = tuple(d)
print(rd)   # ('username', 'age', 'hobby')

# 集合转元组时，结果是无序的，因为集合本身就是无序的
# 重点：【转换是随机的】
e = {1, 2, 3, "study", "python", "forever"}
re = tuple(e)
print(re)   # (1, 2, 3, 'python', 'forever', 'study')

Set强制类型转换

定义：

python的数据类型强制转换：set()
其他类型转换为集合类型
（1）数字类型是非容器类型，不能转换为集合类型
（2）字符串类型转集合时，结果是无序的；
（3）列表转集合时，结果是无序的；
（4）元组转集合时，结果是无序的；
（5）字典转集合时，只保留字典中的键值，结果是无序的

# a = 123
# ra = set(a)
# print(ra)     # a 是整形数字，转换为元祖直接报错

# 字符串类型转集合时，结果是无序的；
b = "1233abc"
rb = set(b)
print(rb)       # {'a', '3', 'b', 'c', '1', '2'}

# 列表转集合时，结果是无序的；
c = [1, 2, 3, 2, "abc"]
rc = set(c)
print(rc)       # {1, 2, 3, 'abc'}

# 元组转集合时，结果是无序的；
e = (1, 2, 3, 1, "study", "python", "forever")
re = set(e)
print(re)   # {'forever', 'study', 1, 2, 3, 'python'}

# 字典转集合时，只保留字典中的键值，结果是无序的
d = {
    "username": "帅帅",
    "age": 21,
    "hobby": "打羽毛球",
    "phone": "12809784768"
}
rd = set(d)
print(rd)   # {'hobby', 'phone', 'username', 'age'}

Dict强制类型转换

定义：

python的数据类型强制转换：dict() 其他类型转为字典类型
（1）数字，字符串，集合 不能转换为字典类型
（2）列表类型转字典类型，列表必须为等长二级容器，子容器中的元素个数必须为 2
（3）元组类型转字典类型，元组必须为等长二级容器，子容器中的元素个数必须为 2

# a = 123
# ra = dict(a)    # 转换报错
# print(ra)

# b = "123abc"
# rb = dict(b)    # 转换报错
# print(rb)

# c = {1, 2, 3, "a", "b", "c"}
# rc = dict(c)    # 转换报错
# print(rc)

# 二级容器的长度必须为2，依次作为字典的 key - value 
d = [["name", "红烧牛肉面"], ["price", 2.58], ["stock", 100]]
rd = dict(d)
print(rd)   # {'name': '红烧牛肉面', 'price': 2.58, 'stock': 100}

e = (("length", 1.20), ("width", 1.30), ("height", 1.50))
re = dict(e)
print(re)   # {'length': 1.2, 'width': 1.3, 'height': 1.5}