数据类型转换分为两种，一种是自动数据类型转换（隐式）和强制数据类型转换（显式）
原则上不同的数据之间无法进行运算，自动数据类型转换是程序自发的行为，比如在运算时（或判断时）。在需要的情况下进行的操作，无法干预，自动数据类型转换，会像更加精确的一方转换。
强制数据类型转换，根据程序员意愿，自己写代码操作。

int() 强制转换为整型 Int

1. 整型不需要转换
2. 浮点型转换为整型，去掉小数部分
3. 布尔值转换为整型,True转换为1, False转换为0
4. 复数无法转换为整型
5. 字符串只有纯整数的字符串可以转换，其余都不行
6. 列表不能转换
7. 元组不能转换
8. 集合不能转换
9. 字典不能转换

#1.int()    强制转换为整型  Int
#var = 88
#var = 8.9
#var = False
#var = 5 - 3j
#var = '99'#var = 'hero'
#var = [1,2,3,5,76]
#var = (1,2,3,54,6,7)
#var = {1,2,3,5,6}
#var = {'a':1,'b':2}
#打印原有数据类型和值
print(var,type(var))
#强制转换操作
newvar = int(var)
#打印转换之后的数据类型和值
print(newvar,type(newvar))

浮点型转换

1. 整型转换为浮点型，添加.0即可
2. 浮点型无需转换
3. 布尔值转换为浮点型，True转换1.0,False转换为0.0
4. 复数无法转换为浮点型
5. 字符串只要是数值类型的字符串就可以转换
6. 列表不能转换
7. 元组不能转换
8. 集合不能转换
9. 字典不能转换

#2.float()  强制转换为浮点型 Float
#var = 88
#var = 8.9
#var = True
#var = 5 - 3j
#var = '9.9'#var = 'hero'
#var = [1,2,3,5,76]
#var = (1,2,3,54,6,7)
#var = {1,2,3,5,6}
#var = {'a':1,'b':2}

#打印原有类型和值
print(var,type(var))
#强制转换过程
newvar = float(var)
#打印转换之后的类型和值
print(newvar,type(newvar))

布尔类型转换:(必须记忆转换为False情况)

1. 整型0
2. 浮点型0.0
3. 布尔值的False
4. 复数0j
5. 字符串的空字符串''
6. 空列表[]
7. 空元组()
8. 空集合set()
9. 空字典{}

#3.bool()   强制转换为布尔类型 Bool
#var = 0
#var = 0.0
#var = False
#var = 0 + 0j
#var = ''
#var = []
#var = ()
#var = set()
#var = {'a':1,'b':2}

#打印原有类型和值
print(var,type(var))
#强制转换过程
newvar = bool(var)
#打印转换之后的类型和值
print(newvar,type(newvar))

复数类型转换：

1. 整型转换为复数后面+0j
2. 浮点型转换为复数后面+0j
3. 布尔值 True -> 1+0j , False ->0j
4. 复数无需转换
5. 字符串只有纯数值的字符串可以转换，后面+0j
6. 列表不能转换
7. 元组不能转换
8. 集合不能转换
9. 字典不能转换

#4.complex()    强制转换为复数   Complex
#var = 88
#var = 8.9
#var = True
#var = 5 - 3j
#var = '9.9'#var = 'hero'
#var = [1,2,3,5,76]
#var = (1,2,3,54,6,7)
#var = {1,2,3,5,6}
#var = {'a':1,'b':2}
#打印原有数据类型和值
print(var,type(var))
#强制转换操作
newvar = complex(var)
#打印转换之后的数据类型和值
print(newvar,type(newvar))

字符串数据类型转换：

1. 所有数据转换为字符串都是变成字符格式的内容而已。

#5.str()    强制转换为字符串  Str

#var = 19
#var = 7.8
#var = False
#var = 9 + 2j
#var = '小飞机'
#var = [1,2,3,5,67]
#var = (1,2,3,5,7) #-> '(1,2,3,5,7)'
#var = {1,2,3,5,6}
#var = {'a':1,'b':2}
#打印原有数据的类型和值
print(var,type(var))
#强制类型转换
newvar = str(var)
#打印转换之后的类型和值
print(newvar,type(newvar))

列表类型转换：

1. 整型不可以转换
2. 浮点型不可以转换
3. 布尔值不可转换
4. 复数不可以转换
5. 字符串转换为列表，每个字符变成列表中的每个值
6. 列表类型不需要转换
7. 元组转换为列表，类型改变，内容不变
8. 集合转换为列表，类型改变，内容不变，顺序随机
9. 字典转换为列表仅保留键，舍弃值

#6.list()   强制转换为列表   List

#var = '唧唧复唧唧，木兰当户织'
#var = [2,3,5,6,7]
#var = (1,2,3,4,5,6,7,8,9)
#var = {1,2,3,5,6,8,9}
var = {'a':1,'b':2,'c':3}
#打印原有数据的类型和值
print(var,type(var))
#强制类型转换
newvar = list(var)
#打印转换之后的类型和值
print(newvar,type(newvar))

元组类型转换

1. 整型不可以转换
2. 浮点型不可以转换
3. 布尔值不可转换
4. 复数不可以转换
5. 字符串转换为元组，每个字符变成元组中的每个值
6. 列表转换为元组，内容和顺序不变，类型改变
7. 元组无需转换
8. 集合转换为元组，类型改变，内容不变，顺序随机
9. 字典转换为元组仅保留键，舍弃值

#7.tuple()  强制转换为元组  Tuple
#var = '唧唧复唧唧，木兰当户织'
#var = [2,3,5,6,7]
#var = (1,2,3,4,5,6,7,8,9)
#var = {1,2,3,5,6,8,9}
#var = {'a':1,'b':2,'c':3}
#打印原有数据的类型和值
print(var,type(var))
#强制类型转换
newvar = tuple(var)
#打印转换之后的类型和值
print(newvar,type(newvar))

集合类型转换

1. 整型不可以转换
2. 浮点型不可以转换
3. 布尔值不可转换
4. 复数不可以转换
5. 字符串转换为集合，去掉重复的数据，每个字符变成集合的每个值，顺序随机
6. 列表转换为集合，去掉重复的数据，剩下的值变成集合的值，顺序随机
7. 元组转换为集合，去掉重复的数据，剩下的值变成集合的值，顺序随机
8. 集合无需转换
9. 字典转换为集合，将字典的键变成集合的值，字典的值舍弃

#8.set()    强制转换为集合   Set

#var = '唧唧复唧唧，木兰当户织'
#var = [2,3,5,6,7,2,3,5,6,7]
#var = (1,2,3,4,5,6,7,8,9,8,8,8,8)
#var = {1,2,3,5,6,8,9}
var = {'a':1,'b':2,'c':3}
#打印原有数据的类型和值
print(var,type(var))
#强制类型转换
newvar = set(var)
#打印转换之后的类型和值
print(newvar,type(newvar))

字典类型转换

1. 整型不可以转换
2. 浮点型不可以转换
3. 布尔值不可转换
4. 复数不可以转换
5. 字符串不可以转换
6. 列表必须是二级列表，并且第二级只有2个数据的列表可以转换
7. 元组必须是二级元组，并且第二级只有2个数据的元组可以转换
8. 集合必须是二级容器，并且第二级只有2个数据的集合可以转换
9. 字典无需转换

#9.dict()   强制转换为字典   Dict
#var = 9.9
#var = '唧唧复唧唧，木兰当户织'
"""
var = [
    ['A',1],
    ['B',2],
    ['C',3],
    ['D',4]
]#二级列表

var = (
    (1,1.1),
    (2,2.2),
    (3,3.3)
)#二级元组
"""
var = {
    (1,2),
    (3,4)
}#二级容器
#var = {'a':1,'b':2,'c':3}
#打印原有数据的类型和值
print(var,type(var))
#强制类型转换
newvar = dict(var)
#打印转换之后的类型和值
print(newvar,type(newvar))

容器类数据：

1. 字符串
2. 列表
3. 元组
4. 集合
5. 字典

只有容器类数据才能转换为容器类数据,字符串除外