day3：强制类型转换&自动类型转换&变量缓存机制

1.Number的强制类型转换（int，float，bool，complex）

1.int 强制转换成整形

float可以转化成int

bool可以转化成int

str(形如"123")可以转化成int

complex不可以转化成int

str(形如"abc123")不可以转化成int

2.float 强制转换成浮点型

int可以转化成float

bool可以转化成float

str(形如"123")可以转化成float

3.complex 强制转换为复数

int可以转化成complex

float可以转化成complex

bool可以转化成complex

str(形如"123")可以转化成complex

str(形如"abc123")不可以转化成complex

4.bool 强制转换成布尔型

bool类型为假的十种情况：

0,     0.0，  False，   0j，   '',   [],   {},   (),  set(),   None

None 是python的关键字,代表空的,什么也没有,一般用来做初始化操作

5.总结:
int() float() bool() complex()
默认创建一个该数据类型的值
res = int() # 0
res = float() # 0.0
res = bool() # False
res = complex() # 0j
print(res)

---------------------------------------

2.Number的自动类型转换（int，float，bool，complex）

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

可以实现以下几种自动类型转换：

1.bool+int

2.bool+float

3.bool+complex

4.int+float

5.int+complex

6.float+complex

--------------------------------------------

3.str,list,tuple,set的强制类型转换

1.str的强制类型转换

所有容器和Number，str都可以强制转换成功

强转成字符串,无非就是在原有的数据的基础上两边套上引号

repr()作用： 可以原型化输出字符串,不转义字符(显示出引号)

2.list的强制类型转换

（1）如果是字符串,会把每一个字符单独的作为一个元素放到列表中
（2）如果是字典,只保留键,形成一套新的列表
（3）如果是其他的容器,只是单纯的在原有数据的基础上换上[]

3.tuple的强制类型转换

（1）如果是字符串,会把每一个字符单独的作为一个元素放到元组中
（2）如果是字典,只保留键,形成一套新的元组
（3）如果是其他的容器,只是单纯的在原有数据的基础上换上()

4.set的强制类型转换

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

5.思考：如何掉列表中所有重复的数据

思路：先用集合的自动去重去掉列表中重复的元素，在将集合转回列表

解法：

lst = ['a','b','c','d','d','d',1,2]
res = list(set(lst))
print(res)

-------------------------------------------

4.dict的强制类型转换

1.二级容器：包括二级列表，二级元组，二级集合，二级字典。

2.多级容器：3.4.5.6或更高级的容器，获取里面的值如下所示。

# 五级容器
container = [10,20,(1,2,3,{"a":1,"b":{"c":2,"d":[3,4,"success "]}})]
# 获取success
res1 = container[-1]
print(res1) # (1,2,3,,{"a":1,"b":{"c":2,"d":[3,4,"success "]}}

res2 = res1[-1]
print(res2) # {"a":1,"b":{"c":2,"d":[3,4,"success "]}}

res3 = res2["b"]
print(res3) # {"c":2,"d":[3,4,"success "]}

res4 = res3["d"]
print(res4) # [3,4,"success "]

res5 = res4[-1]
print(res5) # success

# 五步合成一步
res = container[-1][-1]["b"]["d"][-1]
print(res) # bingo

3.等长的二级容器：里面的元素都是容器,并且容器里面的元素个数都相同

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

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

(1) 外层是列表或者元组或者集合,里面的容器是元组或者列表(推荐)
lst = [("a",1),["b",2]]
tup = (("c",3),["d",4],)
setvar = {(1,2),(3,4),("a1",3),("b2",4)}
res = dict(lst) # {'a': 1, 'b': 2}
res = dict(tup) # {'c': 3, 'd': 4}
print(res)

(2) 如果里面是集合,语法上允许,但是有局限性(不推荐)
lst = [{"a",1},{"b",2}] # 因为集合无序,不符合定义的本意,不推荐使用
print(dict(lst))

(3) 如果使用字符串,语法上允许,但是有局限性(不推荐)
lst = [("a",1),"a2"] # 字符串长度只能2个
lst = [("a",1),"a123"] error
print(dict(lst))

-------------------------------

5.变量的缓存机制

机制: 在Python3.7和Python3.8中，只有两个值相同,就只开辟一个空间

Number部分：

1.对于整型而言，-5~正无穷范围内的相同值id一致

2.对于浮点数而言，非负数范围内的相同值id一致

3.布尔值而言,值相同情况下，id一致

4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)

容器类型部分：

5.字符串 和 空元组 相同的情况下，地址相同

6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]