day3. 六大标准数据类型的类型转换

一、强制类型转换Number

1、int  强制转换成整型

var1 = 13
var2 = 13.789
var3 = True
var4 = 5-7j
var5 = ""
var6 = "abcd4567"

res = int(var2) #
res = int(var3) # False => 0 True => 1
# res = int(var4) error
res = int(var5) #
# res = int(var6) error
print(res , type(res))

强转成整形

2、float 强制转换成浮点型

var1 = 13
var2 = 13.789
var3 = True
var4 = 5-7j
var5 = ""
var6 = "abcd4567"

res = float(var1) # 13.0
res = float(var3) # True => 1.0 False => 0.0
res = float(var5) # 9988.0
print(res , type(res))

强转成浮点型

3、complex 强制转换成复数

var1 = 13
var2 = 13.789
var3 = True
var4 = 5-7j
var5 = ""
var6 = "abcd4567"

res = complex(var1) # 13 + 0j
res = complex(var2) # 13.789 + 0j
res = complex(var3) # False => 0j True => 1+0j
res = complex(var5) # 9988 + 0j
# res = complex(var6) error
print(res , type(res))

强转成复数

4、bool 强制转换成布尔型

 bool类型为假的十种情况
 0 , 0.0 , False , 0j , '',[],(),set(),{},None

二、自动类型转换 Number

 精度从低向高进行转换 : bool -> int -> float -> complex
 自动类型转换,默认从低精度向高精度进行转换(从低到高)

# 1.bool + int
res = True + 100 # 1 + 100
print(res)

# 2.bool + float
res = True + 4.15 # 1.0 + 4.15
print(res)

# 3.bool + complex
res = True + 3-6j # 1+0j + 3 - 6j
print(res)

# 4.int + float
res = 5 + 3.48 # 5.0 + 3.48
print(res)

# 5.int + complex
res = 10 + 4-3j # 10 + 0j + 4 - 3j
print(res)

# 6.float + complex
res = 5.68 + 5-100j # 5.68+0j + 5 - 100j
print(res)

三、容器类型的强制转换(str list tuple set dict)

定义容器类型变量

strvar = '雷霆嘎巴,无情哈拉少,ZBCCCCCCCCCC'
listvar = ["list1","list2","list3"]
tuplevar = ("tuple1","tuple2","tuple3","tuple4")
setvar = {"set1","set2","set3"}
# 推荐大家使用变量命名的字符串作为字典的键;
dictvar = {"name":"kxq","age":"","passwd":""}

1、强制转换成str

"""强转成字符串,无非就是在原有的数据的基础上两边套上引号"""
res = str(listvar)
res = str(intvar)
print(res , type(res))

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

2、强制转换成列表list

"""
如果是字符串,会把每一个字符单独的作为一个元素放到列表中
如果是字典,只保留键,形成一套新的列表
如果是其他的容器,只是单纯的在原有数据的基础上换上[]
"""
res = list(strvar)
res = list(tuplevar)
res = list(setvar)
res = list(dictvar)
print(res , type(res))

3、强制转换成元组tuple

"""
如果是字符串,会把每一个字符单独的作为一个元素放到元组中
如果是字典,只保留键,形成一套新的元组
如果是其他的容器,只是单纯的在原有数据的基础上换上()
"""
res = tuple(strvar)
res = tuple(listvar)
res = tuple(setvar)
res = tuple(dictvar)
print(res , type(res))

4、强制转换成集合set

"""
如果是字符串,会把每一个字符单独的作为一个元素放到集合中(无序,自动去重)
如果是字典,只保留键,形成一套新的集合
如果是其他的容器,只是单纯的在原有数据的基础上换上{}
"""
res = set(strvar)
res = set(listvar)
res = set(dictvar)
print(res)

四、字典强转

1、二级容器

# 二级列表
lst = [1,2,[3,4]]
# 二级元组
tup = (5,6,7,(8,9))
# 二级集合
setvar = {10,11,(12,13)}
# 二级字典
dic ={"a":1,"b":{"c":3,"d":4}}

例：获取字典中4的元素

# 获取4这个元素
res = dic["b"]
print(res) # {'c': 3, 'd': 4}

res2 = res["d"]
print(res2)

# 简写一步
res = dic["b"]["d"]
print(res)

1.1五级容器

container = [100,200,300,(1,2,3,4,{"a":1,"b":{"c":15,"d":[11,12,"bingo"]}})]
# 获取bingo
res1 = container[-1]
print(res1) # (1, 2, 3, 4, {'a': 1, 'b': {'c': 15, 'd': [11, 12, 'bingo']}})

res2 = res1[-1]
print(res2) # {'a': 1, 'b': {'c': 15, 'd': [11, 12, 'bingo']}}

res3 = res2["b"]
print(res3) # {'c': 15, 'd': [11, 12, 'bingo']}

res4 = res3["d"]
print(res4) # [11, 12, 'bingo']

res5 = res4[-1]
print(res5)

# 简写一步
res = container[-1][-1]["b"]["d"][-1]
print(res) # bingo

获取五级容器中的值

1.2等长的二级容器

 里面的元素都是容器,并且容器里面的元素个数都相同

lst = [(1,2,3) , [4,5,6]]
lst = [(1,2) , [4,5]]

2、强制转换字典

 强转成字典时 , 必须是等长的二级容器,里面的元素个数是2个

1.1、外层是列表或者元组或者集合,里面的容器是元组或者列表(推荐)

lst = [("a",1),["b",2]]
tup = (("c",3),["d",4],)
setvar = {(1,2),(3,4),("f3",3),("f4",4)}
res = dict(lst) # {'a': 1, 'b': 2}
res = dict(tup) # {'c': 3, 'd': 4}
# res = dict(setvar) # {1: 2, 'f3': 3, 3: 4, 'f4': 4}
print(res) 

1.2、如果里面是集合,语法上允许,但是有局限性(不推荐)

lst = [{"a",333},{"zz",5}] # 因为集合无序,不符合定义的本意,不推荐使用
print(dict(lst))

1.3、如果使用字符串,语法上正确,但是有局限性(不推荐)

lst = [("a",1),"b2"] # 字符串长度只能2个
# lst = [("a",1),"b23"] error
print(  dict(lst)  )

五、变量的缓存机制（针对python3.6版本）

1、对于Number

1.1、int整型

# 1.对于整型而言，-5~正无穷范围内的相同值 id一致
var1 = 100
var2 = 100
var1 = -6
var2 = -6
var1 = var2 = -100 # 相同的地址
print(id(var1)   , id(var2))

1.2、float浮点型

# 2.对于浮点数而言，非负数范围内的相同值 id一致
var1 = -5.76
var2 = -5.76
print( id(var1) , id(var2) )

1.3、布尔型

# 3.布尔值而言,值相同情况下，id一致
var1 = True
var2 = False
print( id(var1) , id(var2) )

1.4、复数类型

# 4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
var1 = 3+4j
var2 = 3+4j
var1 = 90j
var2 = 90j
print( id(var1) , id(var2) )

2、容器类型

2.1、对于字符串和空元组

# 字符串 和 空元组 相同的情况下，地址相同
var1 = "你"
var2 = "你"
var1 = ()
var2 = ()
print( id(var1) , id(var2) )

2.2、对于列表、元组、字典

# 列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]
var1 = (1,2,3)
var2 = (1,2,3)
print( id(var1) , id(var2) )