0701Python总结-自动和强制类型转换及变量的缓存机制

一.强制类型转换 Number (int float bool complex)

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

1.int: 强制转换成整型

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

2.float: 强制转换成浮点型

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: 强制转换成复数

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
"""
res = bool(None)
print(res , type(res))

None是python的关键词,代表空的,什么也没有,一般用来做初始化操作
总结:
int() float() bool() complex()
默认创建一个该数据类型的值
res = int()
res = float()
res = bool()
res = complex()
print(res)

二.自动类型转换 Number(int float bool complex)

精度从低向高进行转换: 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)

1.str (容器 / Number 都可以转换)

强转成字符串,无非就是在原有的数据基础上两边套上引号
repe 可以原型化输出字符串,不转义字符(显示出引号)

2.list: 强制转换成列表

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

3.tuple: 强制转换成元组

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

4.set 强制转换成集合

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

去掉列表中所有重复的数据
lst = [‘a’, ‘b’, ‘c’, ‘d’, ‘d’, ‘d’, 100, 200]
res = list(set(lst))
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这个元素
简写一步
res = dic["b"]["d"]
print(res)
五级容器
container = [100, 200, 300, (1, 2, 3, 4, {"a":1, "b":{"c":15, "d":[11, 12,"bingo"]}})]
获取bingo
简写一步
res = container[-1][-1]["b"]["d"][-1]
print(res)

等长的二级容器: 里面的元素都是容器,并且容器里面的元素个数都相同
lst = [(1, 2, 3), [4, 5, 6]]
lst = [(1, 2), [4, 5]]

2.dict 强制转换成字典

强转成字典时,必须是等长的二级容器,里面的元素个数是2个
外层是列表或者元组或者集合,里面的容器是元组或者列表(推荐)
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) 

总结:
str() list() tuple() dict() set()
默认创建一个该数据类型的值

5.变量的缓存机制(仅对python3.6版本负责)

机制:只有两个值相同,就只开辟一个空间

1. Number 部分

对于整型而言,-5~正无穷范围内的相同值 id一致
对于浮点数而言,非负数范围内的相同值 id一致
布尔值而言,值相同情况下，id一致
复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)

2.容器类型部分

字符串 和 空元组 相同的情况下，地址相同
列表,元组,字典,集合无论什么情况 id标识都不同 [空元组例外]