5 数据类型的转换

5.1 isinstance函数

isinstance()用来判断一个对象是否是一个已知的类型，返回值时布尔型。若对象时已知型，那么返回True，否则返回False。语法格式为：isinstance(对象，对象类型)。（对象类型：int(整数)、float(浮点数)、bool(布尔值)、str(字符串)、list(列表)、tuple(元组)、set(集合)、dict(字典)）

a = 123
print(isinstance(a, int))  # 结果为：True
b = 123.1
print(isinstance(b, int))  # 结果为：False
print(isinstance(b, float))  # 结果为：True
print(isinstance(b, (int, float, str)))  # 只要有一个与元组(int, float, str)内对象类型符合都是True

数据类型转换的由来：由于不同的数据类型之间是不能进行运算的，所以我们需要数据类型转换。Python中的数据类型转换有两种：

• 自动类型转换，即Python在计算中会自动地将不同类型的数据转换为同类型数据来进行计算；
• 强制类型转换，即需要我们基于不同的开发需求，强制地将一个数据类型转换为另一个数据类型。

5.2 自动类型转换

当两个不同类型的数据进行运算时，结果会向更高的精度进行计算。精度等级：bool < int < float < complex。

a = 1
b = True
print(a + b)  # 结果为：2
c = 1.1
print(a + c)  # 结果为：2.1

5.3 检测数据类型的方法

type()：用来检测数据的类型，格式为：type(变量/数据)

a = 1
print(type(a))  # 结果为：<class 'int'>
print(type("123"))  # 结果为：<class 'str'>

5.4 强制类型转换

• str()：把其他类型数据转化为字符串类型，所有的类型都可以转化为字符串类型。

a = 123  # int
r1 = str(a)
print(r1, type(r1))  # 结果为：123 <class 'str'>
b = True  # bool
r2 = str(b)
print(r2, type(r2))  # 结果为：True <class 'str'>
list_1 = [1, 2, 3]  # list
r3 = str(list_1)
print(r3, type(r3))  # 结果为：[1, 2, 3] <class 'str'>
tuple_1 = (1, 2, 3)  # tuple
r4 = str(tuple_1)
print(r4, type(r4))  # 结果为：(1, 2, 3) <class 'str'>
set_1 = {1, 2, 3}  # set
r5 = str(a)  # {1, 2, 3}
print(r5, type(r5))  # 结果为：{1, 2, 3} <class 'str'>
dict_1 = {1: 'a', 2: 'b'}  # dict
r6 = str(dict_1)
print(r6, type(r6))  # {1: 'a', 2: 'b'} 结果为：<class 'str'>

•  int( )：可以把其他类型数据转化为整型，数字类型之间可以互相转换，只有字符串可以转换为数字类型并且字符串中的元素必须是纯数字才能转换。(小数点也不能有，负数也算纯数字)
•  float( )：可以把其他类型数据转化为浮点型。

a = 123  # int
r1 = float(a)
print(r1, type(r1))  # 123.0 <class 'float'>
b = True  # bool
r2 = float(b)
print(r2, type(r2))  # 1.0 <class 'float'>
c = 3.56
r3 = int(c)
print(r3, type(r3))  # 3 <class 'int'>，不遵循四舍五入
str_1 = '123'
r4 = int(str_1)
print(r4, type(r4))  # 123 <class 'int'>
str_2 = '123abc'
r5 = int(str_2)
print(r5, type(r5))  # 此时python会报错，报错类型为TypeError
list_1 = [1, 2, 3]
r6 = int(list_1)
print(r6, type(r6))  # 此时同样会报错，因为除了字符串以外的其他容器类型都不可以转换成数字类型

•  bool( )：可以把其他类型数据转化为布尔类型。1.容器类型转bool型：字符串、列表、元组、字典、集合（容器类型），数字类型、布尔类型（非容器类型）。容器中为空：False，容器中有元素：True。2.数字类型转布尔类型：int类型中，0为False，其他为True；float类型中，0.0为False，其他为True。

# ---------容器类型
str_1 = ""  # 空字符串
list_1 = []  # 空列表
tuple_1 = ()  # 空元组
set_1 = set()  # 空集合
dict_1 = {}  # 空字典
print(bool(str_1), bool(list_1),bool(tuple_1), bool(set_1), bool(dict_1))  # 结果为：False False False False False False
str_2 = "   "  # 字符串（有元素）
print(bool(str_2))  # 结果为：True
# ----------非容器类数字型
a = 0
print(bool(a))  # 结果为：False
b = 0.0
print(bool(b))  # 结果为：False
c = 1
print(bool(c))  # 结果为：True

•  list( )：可以把其他类型数据转化为列表类型。1.数字为非容器类型，不能转换为列表；2.字符串转列表时，会把字符串中的每一个字符当作列表的元素；3.元组转列表时，会把元组中的每一个字符当作列表的元素；4.字典转列表时，只保留字典中的键；5.集合转列表时，结果是无序的。

a = 123
print(list(a))  # 会报错
str_1 = "abcd123"
print(list(str_1))  # 结果为：['a', 'b', 'c', 'd', '1', '2', '3']
tuple_1 = (1, 2, 3, "abc")
print(list(tuple_1))  # 结果为：[1, 2, 3, 'abc']
dict_1 = {"name": "Emily",
          "age": 18,
          0: 1,
          (1, 2): 123}
print(list(dict_1))  # 结果为：['name', 'age', 0, (1, 2)]
set_1 = {1, "a", 3, 4, 5}
print(list(set_1))  # 结果为：[1, 3, 4, 5, 'a']

•  tuple( )：可以把其他类型数据转化为元组类型。1.数字为非容器类型，不能转换为元组；2.字符串转元组时，会把字符串中的每一个字符当作元组的元素；3.列表转元组时，会把列表中的每一个字符当作元组的元素；4.字典转元组时，只保留字典中的键；5.集合转元组时，结果是无序的。

a = 123
print(tuple(a))  # 会报错
str_2 = "abcd"
print(tuple(str_2))  # 结果为：('a', 'b', 'c', 'd')
list_2 = [1, 2, 3, 4]
print(tuple(list_2))  # 结果为：(1, 2, 3, 4)
dict_2 = {"name": "Emily",
          "age": 18,
          0: 1,
          (1, 2): 123}
print(tuple(dict_2))  # 结果为：('name', 'age', 0, (1, 2))
set_2 = {'a', 1, 2, 'b'}
print(tuple(set_2))  # 结果为：(2, 1, 'a', 'b')

• set( )：可以把其他类型数据转化为集合类型。1.数字类型为非容器类型，不能转换为结合；2.字符串转集合时，结果是无序的；3.列表转集合时，结果是无序的；4.元组集合时，结果是无序的；5.字典转集合时，只保留字典中的键，结果是无序的。

a = 123
print(set(a))  # 结果为：报错
str_3 = "abc123"
print(set(str_3))  # 结果为：{'c', '1', '3', 'b', '2', 'a'}
list_3 = [1, 2, 3, 4]
print(set(list_3))  # 结果为：{1, 2, 3, 4}
tuple_3 = (1, 2, 3, 4)
print(set(tuple_3))  # 结果为：{1, 2, 3, 4}
dict_3 = {"name": "Emily",
          "age": 18,
          0: 1,
          (1, 2): 123}
print(set(dict_3))  # 结果为：{0, (1, 2), 'name', 'age'}

• dict( )：可以把其他类型数据转化为字典类型。1.数字类型是非容器类型，不能转换为字典；2.字符串不能转字典类型，因为字符串不能生成二级容器；3.列表转字典，列表必须为等长二级容器，子容器的元素个数必须为2；4.元组转字典，元组必须为等长二级容器，子容器的元素个数必须为2；5.集合不能转字典，但集合中如果存在等长二级容器的元组元素时，可以转为字典。

a = 123
print(dict(a))  # 会报错
str_4 = "abcd123"
print(dict(str_4))  # 会报错
list_4_1 = [["name", "Emily"], ["age", 18], [1, 2]]  # 这才是二级容器
print(dict(list_4_1))  # 结果为：{'name': 'Emily', 'age': 18, 1: 2}
tuple_4 = (1, 2, 3, 4)
print(dict(tuple_4))  # 会报错
tuple_4_1 = (("name", "Emily"), ("age", 18), (1, 2))
print(dict(tuple_4_1))  # 结果为：{'name': 'Emily', 'age': 18, 1: 2}
set_4 = {1, 2, 3, 4}
print(dict(set_4))  # 会报错
set_4_1 = {{1, 2}, {"name", "Emily"}}
print(dict(set_4_1))  # 同样报错
set_4_2 = {("name", "Emily"), ("age", 18)}
print(dict(set_4_2))  # 结果为：{'name': 'Emily', 'age': 18}
set_4_3 = set(["name", "Emily"])  # 会报错