一：自动类型转换
自动类型转换注意针对Number数据类型来说的
当2个不同类型的数据进行运算的时候,默认向更高精度转换
数据类型精度从低到高:bool int float complex
#关于bool类型的两个值：True 转化成整型是1 False 转化成整型是0
#bool + int
res = True + 2
print(res)
# bool + float
res = True + 4.45
print(res)
#bool + complex
res = False + 5j
print(res)
# int + float
# 3.14 15~18 本质上存在精度消耗 因为小数的二进制在内存中是无限循环没有#终止 一般截取15~18位
res = 5 + 3.56
print(res)
# int + complex
res = 2 + (4-5j)
print(res)
#float + complex
res = 3.67 + (-5+4j)
print(res)
二：强制类型转换
1.Number 强制类型转换(int float complex bool)
Number 部分：
int : 整型 浮点型 布尔类型 纯数字字符串
float: 整型 浮点型 布尔类型 纯数字字符串
complex: 整型 浮点型 布尔类型 纯数字字符串 (复数)
bool: ( 容器类型数据 / Number类型数据 都可以 )
var1 = 5
var2 = 4.85
var3 = True
var3_2 = False
var4 = 3+9j
var5 = "88777"
var6 = "dasa33"
(1)int 强制类型转换成整型
res = int(var2)
res = int(var3) #Ture =>1
res = int(var3_2) #False =>0
#res = int(var4) error
res = int(var5)
#res = int(var6) #error
print(res)
(2) float 强制类型转换成浮点型
res = float(var1)
res = float(var3)
res = float(False)
# res = float(var4) #error
res = float(var5)
print(res)
(3)complex 强制类型转换成复数
res = complex(var1)
res = complex(var2)
res = complex(var3)
res = complex(False)
res = complex(var5)
print(res)
(4) bool 强制类型转换成布尔类型 结果只有两种要么Ture 要么 False
bool 可以转换所有的数据类型everything
res = bool(var1)
res = bool(var2)
res = bool(var6)
res = bool(None)
print(res)
布尔类型为假的十种情况(重要)：
0
0.0
0j
False
'' 空字符串
() 空元组
[] 空列表
set() 空集合
{} 空字典
None
#系统关键字 None代表什么也没有 ，一般用于初始化变量的时候用
res = None
print(None)
2.容器类型数据强制转换(str list tuple set dict )
容器类型部分
str: ( 容器类型数据 / Number类型数据 都可以 )
list: 字符串 列表 元组 集合 字典
tuple: 字符串 列表 元组 集合 字典
set: 字符串 列表 元组 集合 字典 (注意:相同的值,只会保留一份)
dict: 使用 二级列表 或 二级元组 (二级集合语法上不错,但是无序,不建议使用)
var1 = "今天天气好晴朗"
var2 = [1,2,3,4]
var3 = ("黄盖","黄雄","派大星")
var4 = {"盖伦","压缩","剑圣"}
var5 = {'wfd':"闪现加大","wer":"从来不死"}
var6 = 3+6j
(1) str 所有的数据类型都可以转成字符串str
规律：基于原有类型，在外面套一层引号
res = str(var2)
print(res,type(res))
res = str(var3)
res = str(var5)
res = str(var6)
print(res,type(res))
print(repr(res)) #打印出字符串类型的那个引号 <原型化输出>
(2)list
规律：
如果是字符串，把字符擦混当中的每一个字符当成列表中的新元素
其他的都是在原有数据类型的基础上，套一个[]标识符即可转化
res = list(var1)
res = list(var3)
res = list(var5) #把字典强转成列表时，只获取键，忽略值
# list(var6) #error
print(res,type(res))
(3)tuple
规律：
如果是字符串，把字符擦混当中的每一个字符当成列表中的新元素
其他的都是在原有数据类型的基础上，套一个()标识符即可转化
res = tuple(var1)
res = tuple(var2)
res = tuple(var5) #把字典强转成元组时，只获取键，忽略值
res = tuple(var4)
print(res)
#print({1,2,3,4,"2323","111"})
(4)set
规律：
如果是字符串，把字符擦混当中的每一个字符当成列表中的新元素
其他的都是在原有数据类型的基础上，套一个{}即可转化集合
res = set(var1)
res = set(var5) #把字典强转成集合时，只获取键，忽略值
print(res)
#去掉列表当中的重复元素
listvar = ["周杰伦","周星驰","周星驰","王文","州路费"]
res = set(listvar)
print(res)
res = list(res)
print(res)
#简写
res = list(set(listvar))
print(res)
(5)强制转换成字典类型
# 多级容器数据：该数据是容器数据，并且里面的元素还是容器类型数据
# ##二级容器
#二级列表
listvar = [1,2,3,4,5,[6,7,8,9]]
res = listvar[-1][3]
print(listvar)
print(res)
# 二级元组
tuplevar = (1,2,3,4,5,(6,7,8,9))
# 二级集合 （只能在里面放元组作为集合里面的容器数据）
setvar = {1,2,3,(4,5,6)}
#setvar = {1,2,3(4,5,6,{'a':1,'b':2})} #error 必须是可哈希不可变的数据
# setvar = {1,2,3,[4,5,6]} #error
print(setvar)
#二级字典
dictvar = {"a":{"c":3},"b":2}
res = dictvar["a"]
print(res)
#输出a相对应的值{"c":3}
print(res['c'])
#输出c相对应的值3 ，属于子字典中的值
#简写
print(dictvar["a"]['c'])
# 四级容器
content = [1,2,3,4,(4,5,{'a':{4,5,6,88},"b":2},7),5]
print(content[4])
print(content[4][2])
#获取集合
print(content[4][2]['a'])
# 等长的二级容器
首先容器是2个，代表二级容器
每一个容器元素个数都是一样的叫做等长
listvar = [(1,2,3,4),(5,6,7,8)]
tuplevar = ([1,2],[3,4],[5,6])
# ## dict强制转换成字典 ：(里面的元素只能是2个)
(1) 外面是列表，里面是列表或元组或字符串
'''字符串元素的个数只能是2个有它的局限性，不推荐使用'''
'''[["a",[1,2,3,4]] ]'''
listvar = [['a',1],('b',2),"c3"] #c33
res = dict(listvar)
print(res,type(res))
#特殊注意：
res = dict( [ ["a",[1,2,3,4]] , ("b",[5,6,6,7]) ] )
print(res,"<============>")
'''
#会产生意想不到的结果，不推荐使用
listvar = [{'c',1},{'d',2}]
res = dict(listvar)
print(res,type(res))
'''
(2) 外面是元组，里面是列表 或元组或字符串
'''字符串元素的个数只能是2个，有它的局限性，不推荐使用'''
tuplevar = (["c",3],("d",33),"f2")
res = dict(tuplevar)
print(res,type(res))
(3)外面是集合，里面是元组或字符串
setvar = {('a',1),('b',2)}
res = dict(setvar)
print(res,type(res))
总结:
关于容器类型数据的强转一共如下：
str() list() set() tuple() dict() 都可以转换成对应的数据类型
关于Number数据类型的强转一共如下：
int() bool() float() complex() 都可以转换成对应的数数据类型
可以用强转函数对值进行初始化
res = str()
print(repr(res))
res = bool()
print(res)
print('--------------------')
#TypeError: unhashable type: 'list'
#res = set((1,2,3,4,[4,5,6,6,2],{3,4,5,6}))
#print(res)
#元组不能改变它的儿子，但是可以改变它的孙子
#元组第一级的所有元素不能修改，但是如果该元素是列表，通过列表本身，可以修改它自己的值
tup = (1,2,3,[4,5,(9,2,[99,88],1),6],{11,22,3})
#tup[3] = 90 #元组不能修改
#tup[3][2][-1] = 18 #在里层是一个元组的元素不能修改
print(tup)
#print(tup[3])
#tup[3][-1] = 7 #元组中的列表里的值可以修改
#print(tup)
（2）字典的键和集合当中的值有要求，必须可哈希不可变数据，字典的值不要求
#一般在进行容器类型强转时，说的是tuple list set dict 字符串比较特殊不包含在内
#强转成字典的条件是：
（1）等长的二级容器
（2）内层容器内里面的元素只能是2个