7.2_python_lx_day3

一.强制类型转换 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的关键字,代表空的,什么也没有,一般用来做初始化操作
a1 = None
b1 = None
&总结:
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 都可以转换)

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

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

(2) list : 强制转换成列表

①规则:如果是字符串,会把每一个字符单独的作为一个元素放到列表中

            如果是字典,只保留键,形成一套新的列表
            如果是其他的容器,只是单纯的在原有数据的基础上换上[]

(3) tuple : 强制转换成元组

①规则:如果是字符串,会把每一个字符单独的作为一个元素放到元组中

　　　 如果是字典,只保留键,形成一套新的元组
　　　 如果是其他的容器,只是单纯的在原有数据的基础上换上()

(4) set : 强制转换成集合

①规则:如果是字符串,会把每一个字符单独的作为一个元素放到集合中(无序,自动去重)

            如果是字典,只保留键,形成一套新的集合
            如果是其他的容器,只是单纯的在原有数据的基础上换上{}

(5)dict : 强制转换成字典

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

②使用:外层是列表或者元组或者集合,里面的容器是元组或者列表(推荐)

            如何里面是集合,语法上允许,但是有局限性(不推荐)                        因为集合无序,不符合定义的本意,不推荐使用

             如果使用字符串,语法上允许,但是有局限性(不推荐)                       因为字符串长度只能2个

四.二级容器 (list tuple set dict)

① 二级列表            lst = [1,2,[3,4]]

②二级元组             tup = (5,6,7,(8,9))

③二级集合             setvar = {10,11,(12,13)}

④二级字典             dic ={"a":1,"b":{"c":3,"d":4}}

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

res2 = res["d"]
print(res2)------>4

<2>简写一步    res = dic["b"]["d"]        print(res)

⑤五级容器
container = [100,200,300,(1,2,3,4,{"a":1,"b":{"c":15,"d":[11,12,"bingo"]}})]
<1>获取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)----->'bingo'

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

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

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

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

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

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

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

var1 = 3+4j
var2 = 3+4j
var1 = 90j
var2 = 90j
print( id(var1) , id(var2) )

②容器类型部分

(1)字符串 和 空元组 相同的情况下，地址相同

var1 = "你"
var2 = "你"
var1 = ()
var2 = ()
print( id(var1) , id(var2) )

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