python 基礎之自動類型轉換和強制類型轉換


一:自動類型轉換

自動類型轉換注意針對Number數據類型來說的

2個不同類型的數據進行運算的時候,默認向更高精度轉換

數據類型精度從低到高:bool int float complex

#關於bool類型的兩個值:True 轉化成整型是1 False 轉化成整型是0
#bool + int
res = True + 2
print(res)

# bool + float
res = True + 4.45
print(res)

#bool + complex
res = False + 5j
print(res)

# int + float
# 3.14 15~18 本質上存在精度消耗 因為小數的二進制在內存中是無限循環沒有#終止 一般截取15~18
res = 5 + 3.56
print(res)

# int + complex
res = 2 + (4-5j)
print(res)

#float + complex
res = 3.67 + (-5+4j)
print(res)

二:強制類型轉換

 

1.Number 強制類型轉換(int float complex bool)

Number 部分:

int :     整型   浮點型 布爾類型  純數字字符串

float:    整型   浮點型 布爾類型  純數字字符串

complex:  整型   浮點型 布爾類型  純數字字符串 (復數)

bool:   ( 容器類型數據  /  Number類型數據 都可以 )

 

 


var1 = 5
var2 = 4.85
var3 = True
var3_2 = False
var4 = 3+9j
var5 = "88777"
var6 = "dasa33"

(1)int 強制類型轉換成整型

res = int(var2)
res = int(var3) #Ture =>1
res = int(var3_2) #False =>0
#res = int(var4)  error
res = int(var5)
#res = int(var6) #error
print(res)

(2) float 強制類型轉換成浮點型

res = float(var1)
res = float(var3)
res = float(False)
# res = float(var4) #error
res = float(var5)
print(res)

(3)complex 強制類型轉換成復數

res = complex(var1)
res = complex(var2)
res = complex(var3)
res = complex(False)
res = complex(var5)
print(res)

(4) bool 強制類型轉換成布爾類型 結果只有兩種要么Ture 要么 False

bool 可以轉換所有的數據類型everything

res = bool(var1)
res = bool(var2)
res = bool(var6)
res = bool(None)
print(res)


布爾類型為假的十種情況:
0  

0.0  

0j  

False  

''    字符串 

()    空元組

[]    空列表

set()  空集合

{}    空字典

None
#系統關鍵字 None代表什么也沒有 ,一般用於初始化變量的時候用
res = None
print(None)

 

2.容器類型數據強制轉換(str list tuple set dict)

容器類型部分

str:  ( 容器類型數據  /  Number類型數據 都可以 )

list:    字符串 列表 元組 集合 字典

tuple:   字符串 列表 元組 集合 字典

set:     字符串 列表 元組 集合 字典  (注意:相同的值,只會保留一份)

dict:  使用 二級列表 二級元組   (二級集合語法上不錯,但是無序,不建議使用)

 

var1 = "今天天氣好晴朗"
var2 = [1,2,3,4]
var3 = ("黃蓋","黃雄","派大星")
var4 = {"蓋倫","壓縮","劍聖"}
var5 = {'wfd':"閃現加大","wer":"從來不死"}
var6 = 3+6j

(1)str 所有的數據類型都可以轉成字符串str

規律:基於原有類型,在外面套一層引號

res = str(var2)
print(res,type(res))
res = str(var3)
res = str(var5)
res = str(var6)
print(res,type(res))
print(repr(res))  #打印出字符串類型的那個引號 <原型化輸出>

(2)list

規律:
如果是字符串,把字符擦混當中的每一個字符當成列表中的新元素
其他的都是在原有數據類型的基礎上,套一個[]標識符即可轉化
'''
res = list(var1)
res = list(var3)
res = list(var5)  #把字典強轉成列表時,只獲取鍵,忽略值
# list(var6) #error
print(res,type(res))

(3)tuple

規律:
如果是字符串,把字符擦混當中的每一個字符當成列表中的新元素
其他的都是在原有數據類型的基礎上,套一個()標識符即可轉化
'''
res = tuple(var1)
res = tuple(var2)
res = tuple(var5)  #把字典強轉成元組時,只獲取鍵,忽略值
res = tuple(var4)
print(res)

#print({1,2,3,4,"2323","111"})

(4)set

規律:
如果是字符串,把字符擦混當中的每一個字符當成列表中的新元素
其他的都是在原有數據類型的基礎上,套一個{}即可轉化集合
例:
res = set(var1)
res = set(var5) #把字典強轉成集合時,只獲取鍵,忽略值
print(res)

#去掉列表當中的重復元素
listvar = ["周傑倫","周星馳","周星馳","王文","州路費"]
res = set(listvar)
print(res)
res = list(res)
print(res)

#簡寫
res = list(set(listvar))
print(res)

 

(5)強制轉換成字典類型

# 多級容器數據:該數據是容器數據,並且里面的元素還是容器類型數據

# ##二級容器
#二級列表

listvar = [1,2,3,4,5,[6,7,8,9]]
res = listvar[-1][3]
print(listvar)
print(res)

# 二級元組
tuplevar = (1,2,3,4,5,(6,7,8,9))
# 二級集合 (只能在里面放元組作為集合里面的容器數據)
setvar = {1,2,3,(4,5,6)}
#setvar = {1,2,3(4,5,6,{'a':1,'b':2})} #error 必須是可哈希不可變的數據
# setvar = {1,2,3,[4,5,6]} #error

print(setvar)
#二級字典
dictvar = {"a":{"c":3},"b":2}
res = dictvar["a"]
print(res)
#輸出a相對應的值{"c":3}

print(res['c'])
#輸出c相對應的值3 ,屬於子字典中的值

#簡寫
print(dictvar["a"]['c'])

# 四級容器
content = [1,2,3,4,(4,5,{'a':{4,5,6,88},"b":2},7),5]
print(content[4])
print(content[4][2])

#獲取集合
print(content[4][2]['a'])

# 等長的二級容器
首先容器是2個,代表二級容器
每一個容器元素個數都是一樣的叫做等長

listvar = [(1,2,3,4),(5,6,7,8)]
tuplevar = ([1,2],[3,4],[5,6])

# ## dict強制轉換成字典 :(里面的元素只能是2)
(1) 外面是列表,里面是列表或元組或字符串
'''字符串元素的個數只能是2個有它的局限性,不推薦使用'''
'''[["a",[1,2,3,4]]   ]'''
listvar = [['a',1],('b',2),"c3"] #c33
res = dict(listvar)
print(res,type(res))

#特殊注意:
res = dict(   [   ["a",[1,2,3,4]]  , ("b",[5,6,6,7]) ]   )
print(res,"<============>")
'''
#會產生意想不到的結果,不推薦使用
listvar = [{'c',1},{'d',2}]
res = dict(listvar)
print(res,type(res))
'''

(2) 外面是元組,里面是列表 或元組或字符串
'''字符串元素的個數只能是2個,有它的局限性,不推薦使用'''
tuplevar = (["c",3],("d",33),"f2")
res = dict(tuplevar)
print(res,type(res))

 (3)外面是集合,里面是元組或字符串
setvar = {('a',1),('b',2)}
res = dict(setvar)
print(res,type(res))

總結:
關於容器類型數據的強轉一共如下:
str() list() set() tuple() dict() 都可以轉換成對應的數據類型
關於Number數據類型的強轉一共如下:
int() bool() float() complex() 都可以轉換成對應的數數據類型
可以用強轉函數對值進行初始化
res = str()
print(repr(res))
res = bool()
print(res)

print('--------------------')
#TypeError: unhashable type: 'list'
#res = set((1,2,3,4,[4,5,6,6,2],{3,4,5,6}))
#print(res)

#元組不能改變它的兒子,但是可以改變它的孫子
#元組第一級的所有元素不能修改,但是如果該元素是列表,通過列表本身,可以修改它自己的值
tup = (1,2,3,[4,5,(9,2,[99,88],1),6],{11,22,3})
#tup[3] = 90  #元組不能修改
#tup[3][2][-1] = 18  #在里層是一個元組的元素不能修改

print(tup)
#print(tup[3])
#tup[3][-1] = 7  #元組中的列表里的值可以修改
#print(tup)  

2字典的鍵和集合當中的值有要求,必須可哈希不可變數據,字典的值不要求
#一般在進行容器類型強轉時,說的是tuple list set dict 字符串比較特殊不包含在內

#強轉成字典的條件是:

(1)等長的二級容器

(2)內層容器內里面的元素只能是2

 


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2021 ITdaan.com