Number数据类型转换

# ###强制类型换 Number (int float bool complex)
var1 = 68
var2 = 6.89
var3 = False
var4 = 3-4j
var5 = "12345678"
var6 = "qwe123"

#(1) int 强制转换成整型
res = int(var2)
res = int(var3)
#res = int(var4) #TypeError: can't convert complex to int
res = int(var5)
#res = int(var6) #ValueError: invalid literal for int() with base 10: 'qwe123' int只能对纯数字进行转换
print(res)

#(2) float强制转换成浮点型
res = float(var1)
res = float(var3)
#res = float(var4)  complex复数不能转化成浮点型
res = float(var5)
#res = float(var6)   不是纯数字的字符串是不能转换成浮点型 
print(res)

#(3) complex 强制转化成复数
res = complex(var1)
res = complex(var2)
res = complex(var3)
res = complex(var5)
#res = complex(var6) 报错:arg is a malformed string
print(res)

#(4)bool强制转化成布尔
res = bool(var1)
res = bool(var2)
res = bool(var4)
res = bool(var5)
res = bool(var6)
print(res)

#布尔类型为假的十种情况
# None是python的关键字 代表空什么没有 一般是作为初始化操作的；
"""
int类型：       0
float类型：      0.0
complex类型：     0j
bool类型：          False
str字符串类型：  ""
tuple类型:         ()
set类型:       set()
list类型:             []
dict类型：          {}
关键字：         None
"""
res = bool(None)
print(res)

"""
int() float() bool complex() 默认创建一个该数据类型的值
res = int()
res = float()
res = bool()
res = complex()
print(res)
"""    

容器类数据转换

#  ###强制类型转化 容器类型数据(str list tuple dict set)
listvar = ['taibai','wusir','Alex','wuchao','duidui']
tuplevar = ('taibai','wusir','Alex','wuchao','duidui')
setvar = {'taibai','wusir','Alex','wuchao','duidui'}
dictvar = {'tb':'taibai','lj':'Alex','wpq':'wusir','wc':'wuchao'}
strvar = "taibai老司机开车"
intvar = 8848

#(1) str(容器类型数据 / Number类型数据 都可以)
"""如果是字符串进行强制转化，仅仅就是在原数据类型的两边套上引号"""

#repr 可以原型化输出字符串，不转义字符，可以显示引号
res = str(listvar)
print(res,type(res))
print(repr(res),type(repr(res))) #显示引号

res = str(tuplevar)
print(res,type(res))
print(repr(res),type(repr(res)))

res = str(setvar)
print(res,type(res))
print(repr(res),type(repr(res)))

res = str(dictvar)
print(res,type(res))
print(repr(res),type(repr(res)))

res = str(dictvar)
print(res,type(res))
print(repr(res),type(repr(res)))

res  = str(intvar)
print(res,type(res))
print(repr(res),type(repr(res)))

#(2)list:强制转化成列表
"""
如果是字符串，会把每一个字符都单独作为一个元素的放到新的列表中。
如果是字典，只保留键，形成一套新的列表
如果是其它容器，只是单纯的在原数据的两边套上[]
"""
res = list(tuplevar)
print(res,type(res))

res = list(setvar)
print(res,type(res))

res = list(dictvar)
print(res,type(res))

res = list(strvar)
print(res,type(res))

#(3) tuple:强制转化成元组
"""
如果是字符串，会把没个字符都单独作为一个元素放到新的元组中
如果字典，只保留键，形成一套新的元组
如果是其它容器，只是单纯在原数据的两边加上()
"""

res = tuple(listvar)
print(res,type(res))

res = tuple(dictvar)
print(res,type(res))

res = tuple(setvar)
print(res,type(res))

res = tuple(strvar)
print(res,type(res))

#(4)set:强制转化成集合 无序 去重
"""
如果是字符串，会把每一个字符单独作为一个元素放到新的集合中[存在无序,去重的特征]
如果是字典，只保留键，形成一套新的集合。[存在无序，去重的特征]
如果是其它容器,只是单纯的在原数据的两边套上{}[存在无序，去重的特征]
"""
res = set(strvar)
print(res,type(res))

res = set(listvar)
print(res,type(res))

res = set(dictvar)
print(res,type(res))

res = set(setvar)
print(res,type(res))

#(5)给列表如何去重
lst = [22,33,44,55,66,66,55,77,88]
setvar =set(lst)
lst = list(setvar)
print(lst)

setvar = {11,22,33}
print(setvar)

#如果想要去在去重的同时，保持顺序不乱，要依靠循环。
lst = ['aa','bb','cc','dd']
res = list(set(lst))
print(res)

#终结：
#str() list() set() dict() tuple() 默认都会转化成当前数据类型；
"""
res = str()
print(res)

res  = list()
print(res)

res  = set()
print(res)

res = dict()
print(res)

res = tuple()
print(res)

"""

多级容器和dict字典的转换

#二级容器: 外层是一个容器类型数据,里面的元素还是一个容器类型数据(list tuple set dict)

#二级列表
listvar = [1,2,3,4[5,6,7]]

#二级元组
tuplevar = (8,9,10,(11,12,13))

#二级集合 必须存放可哈希数据(int float bool complex tuple str)
setvar = {'aa','bb','cc',(1,2,3)}

#二级字典
dictvar = {'aa','bb','cc',(1,2,3)}

#多级容器 获取91 一级一级寻找
container = [1,3,5,(6,7,8,[9,10,11,{"a":1,"b":[90,91,92]}])]

# (6,7,8,[9,10,11,{"a":1,"b":[90,91,92]} ])
res1 = container[-1]
print(res1)
# [9, 10, 11, {'a': 1, 'b': [90, 91, 92]}]
res2 = res1[-1]
print(res2)
# {'a': 1, 'b': [90, 91, 92]}
res3 = res2[-1]
print(res3)
# [90, 91, 92]
res4 = res3['b']
print(res4)
# 91
res5 = res4[1]
print(res5)

# 简写一行
res = container[-1][-1][-1]['b'][1]
print(res)

#元组中的列表值可以修改
tuplevar = (1,2,3,4,5,[7,8,9])
print(tuplevar[-1])
tuplevar[-1][-1] = 10
print(tuplevar)

#等长的二级容器,每一个容器里面的元素个数都是相同的叫做等长
# 等长的二级容器 每一个容器里面的元素个数都是相同的叫做等长
lst = [(1,2,3),[5,6,7]]
lst = [{"a",1},("b",2)]
# ### dict 强制转换成字典
"""强制转换成字典时,必须是等长的二级容器,并且元素个数为2个"""

# (1) 外层是列表,里面的容器可以是列表或者元组(推荐)
lst = [["a",1],("b",2)]
res = dict(lst)
print(res)

# 如果用字符串变成字典,有一定的局限性 c3456 (不推荐使用)
lst = [["a",1],("c34",56),"c3"]
res = dict(lst)
print(res)

# 如果里面是集合,语法上是允许的,但是也有局限性 (不推荐使用)
lst = [{"a",1},{"b",2}]
res = dict(lst)
print(res)


# (2) 外层是元组,里面的容器可以是列表或者元组 (推荐)
tup = (["c",3],("d",4))
res = dict(tup)
print(res)

# (3) 外层是集合,里面的容器只能是元组
setvar = { ("e",5),("f",6)}
res = dict(setvar)
print(res)