python 資料型別強制轉換的總結
阿新 • • 發佈：2021-06-21
如果要將一個數據轉換成另一個數據型別，只需要將其放入相應型別的函式中去。
Number型別的資料轉換
強制轉換為int
-
int 整型
-
float 浮點型
-
bool 布林型
-
str 字串（整型）
資料轉換
# 整型（整型轉換是原封不動的）
print(int(10))
# 浮點型（浮點型轉成整型按照退一法）
print(int(10.999))
# 布林型（布林型只有兩種值，轉換成為整型也只有兩種，True=1，False=0）
print(int(True))
print(int(False))
# 字串（字串只有去掉引號是整型的才能轉換）
print(int('-123'))
print(int('123'))
強制轉換為float
可以轉換的資料型別
-
int 整型
-
float 浮點型
-
bool 布林型
-
str 字串（整型、浮點型）
資料轉換
# 整型（整型轉換是新增一位小數，小數位為0）
print(float(10))
# 浮點型（浮點型轉換原封不動）
print(float(10.999))
# 布林型（布林型只有兩種值，轉換成為整型也只有兩種，True=1.0，False=0.0）
print(float(True))
print(float(False))
# 字串（字串只有去掉引號是整型和浮點型的才能轉換）
print(float('-123'))
print(float('1234.134'))
強制轉換為bool
可以轉換的資料型別 python中所有的資料型別都可以轉換成為布林型，但是結果只有兩種，True 和 False
資料轉換 在python中，只有十種情況下的資料轉換成為bool的值是False，其餘皆為True。
# 就是說，python中一切為空的資料都為False
# 1、整型 （0）
print(bool(0))
# 2、浮點型（0.0）
print(bool(0.0))
# 3、布林型（False）
print(bool(False))
# 4、複數（0j）
print(bool(0j))
# 5、字串（空字串）
print(bool(''))
# 6、列表（空列表）
print(bool([]))
# 7、元組（空元組）
print(bool(()))
# 8、集合（空集合）
print(bool(set()))
# 9、字典（空字典）
print(bool({}))
# 10、None（python關鍵字，表示什麼也沒有）
print(bool(None))
強制轉換為complex
可以轉換的資料型別
-
int 整型
-
float 浮點型
-
bool 布林型
-
complex 複數
-
str 字串（整型、浮點型、複數）
資料轉換
# 整型（整型轉換是原數+0j）
print(complex(10))
# 浮點型（浮點型轉換是原數+0j）
print(complex(10.999))
# 布林型（布林型只有兩種值，轉換成為整型也只有兩種，True=1+0j，False=0j）
print(complex(True))
print(complex(False))
# 複數（複數轉換原封不動，0+0j=0j）
print(complex(1234+341j))
print(complex(0+0j))
# 字串（字串只有去掉引號是整型、浮點型和複數的才能轉換）
print(complex('-123'))
print(complex('1234.134'))
print(complex('1234+0j'))
數字型別的自動轉換
不同型別的數字在一起運算時，結果會按照精度從低到高自動的進行轉換。當低精度的數與高精度的數進行運算，最後會變為高精度數型別
精度從低到高排序：
bool -----> int -----> float ------> complex
-
bool和除了bool之外的任何資料型別運算結果都不會是bool
-
complex 與任何型別的資料進行運算都會變成complex
# 例如低精度的bool和高精度的int進行運算，其結果會自動的轉變成為高精度的int
# bool + int
res = True + 100
print(res, type(res))
# bool + float
res = True + 100.11
print(res, type(res))
# bool + complex
res = True + 0j
print(res, type(res))
# int + float
res = 123 + 100.9
print(res, type(res))
# int + complex
res = 123 + 0j
print(res, type(res))
# float + complex
res = 100.0000 + 0j
print(res, type(res))
container型別的強制轉換
容器型別的轉換，使用相應容器的函式進行轉換。
轉換為字串
支援轉換的資料型別 所有的資料型別
# 方法1、直接加引號
print('[1, 2, 3]')
# 方法2、使用str函式
print(str([1, 2, 3]))
# [1, 2, 3]
# 方法3、使用repr函式
print(repr([1, 2, 3]))
# [1, 2, 3]
# repr函式的作用：原型化輸出字串，不轉義字元（顯示出引號）
lstvar = [1, 2, 3]
res = str(lstvar)
print(repr(res))
# '[1, 2, 3]'
轉換為列表
支援轉換的資料型別 僅容器
注意要點
如果是字串，會把每一個字串單獨的作為一個元素放到列表中； 如果是字典，只保留鍵，形成一套新的列表； 如果是其它的容器，只是單純的在原有資料的基礎上換上[]；
# 1、字串
# 字串中的每一個字元都視為一個元素
var = 'hello motherland'
print(list(var))
# ['h', 'e', 'l', 'l', 'o', ' ', 'm', 'o', 't', 'h', 'e', 'r', 'l', 'a', 'n', 'd']
# 2、字典
var = {'one': 1, 'two': 2, 'three': 3}
print(list(var))
# ['one', 'two', 'three']
# 3、其它的資料型別
var = (1, 3, 4, 5, 6)
print(list(var))
# [1, 3, 4, 5, 6]
var = {1, 3, 4, 5, 6}
print(list(var))
# [1, 3, 4, 5, 6]
轉換為元組
支援轉換的資料型別 僅容器
注意要點
如果是字串，會把每一個字串單獨的作為一個元素放到列表中 如果是字典，只保留鍵，形成一套新的列表 如果是其它的容器，只是單純的在原有資料的基礎上換上()
和list是一樣的
# 1、字串
# 字串中的每一個字元都視為一個元素
var = 'hello motherland'
print(tuple(var))
# ('h', 'e', 'l', 'l', 'o', ' ', 'm', 'o', 't', 'h', 'e', 'r', 'l', 'a', 'n', 'd')
# 2、字典
var = {'one': 1, 'two': 2, 'three': 3}
print(tuple(var))
# ('one', 'two', 'three')
# 3、其它的資料型別
var = [1, 3, 4, 5, 6]
print(tuple(var))
# (1, 3, 4, 5, 6)
var = {1, 3, 4, 5, 6}
print(tuple(var))
# (1, 3, 4, 5, 6)
轉換為集合
支援的資料型別 僅容器
注意要點
集合的變化和列表、元組都是一樣的，只是單純的在原有資料的基礎上換上{}；
但是集合是無序的，返回的結果中的元素的順序是不固定的
# 1、字串
# 字串中的每一個字元都視為一個元素
var = 'hello motherland'
print(set(var))
# {'d', 'r', ' ', 'h', 'n', 'e', 't', 'm', 'a', 'o', 'l'}
# 2、字典
var = {'one': 1, 'two': 2, 'three': 3}
print(set(var))
# {'two', 'one', 'three'}
# 3、其它的資料型別
var = ['1', '3', '4', '5', '6']
print(set(var))
# {'5', '4', '6', '1', '3'}
var = ('1', '3', '4', '5', '6')
print(set(var))
# {'5', '4', '6', '1', '3'}
多級容器
-
在一個容器當中巢狀一個容器，這個容器就叫做二級容器；在被巢狀的容器當中再巢狀一個容器，最外層的容器就叫做三級容器；以此類推，有四級、五級……
-
容器的型別取決於最外層的容器，不同的型別容器可以相互巢狀，但是，集合和字典除外；因為字典的鍵和集合中的值必須是可雜湊的型別，可雜湊的資料型別Number、str、tuple；
-
多級容器不包括字串，字串是特殊的容器，任何字元在字串中都是字串的一個單獨元素；
# 二級容器
# 比如列表中巢狀一個列表
var = [1, 2, [1, 2, 3]]
# 三級容器
# 比如列表中巢狀一個列表，被巢狀的列表中還有一個元組
var = [1, 2, [3, 4, (5, 6)]]
# ……
# 二級字典
# 字典是用鍵來儲存資料的，所以被巢狀的容器要放在鍵下
var = {'1': 1, '2': 2, '666': {'3': 3, '4': 4}}
獲取多級容器中的值
# 獲取被巢狀的容器中的資料要通過下標索引、鍵一層一層的將資料獲取出來
# 練習：獲取四級容器當中的值！！！如何獲取10
No1_level4_container = [1, 2, 3, 4, (1, 2, 3, 4, {1: 1, 2: 2, "msr": [1, 2, 3, 4, 10]})]
print("---原四級容器")
print(No1_level4_container)
# 在這個多級容器當中，所有的容器都是最後一個，所以利用python特有的逆向下標，來逐一獲取出來
# 1、先獲取元組。也就是第二級容器
res = No1_level4_container[-1] # 釋放一級 也就是通過列表的下標-1來選擇出來
print("---釋放一級")
print(res)
# 2、在獲取字典
res = res[-1]
res1 = No1_level4_container[-1][-1]
print("---剝奪二級")
print(res)
print(res1)
# 3、在獲取鍵值msr對應的值
res = res['msr']
print("---獲取msr")
print(res)
# 4、在獲取數值10 下標-1或者4
res1 = res[-1]
res2 = res[4]
print('---最終結果')
print(res1, res2)
# 簡寫
res = No1_level4_container[-1][-1]['msr'][-1]
print('---簡寫結果')
print(res)
等長的多級容器
-
外層容器中的元素都是容器
-
被巢狀容器中的元素個數相同
# 等長的二級容器
var = [(1, 2, 3,), (4, 5, 6,)]
字典的強轉
要求 必須是等長的二級容器，且裡面的元素個數必須是兩個。
容器的轉換
# 使用dict函式進行轉換
var = [('one', 1), ('two', 2)]
dctvar = dict(var)
print(dctvar)
print(type(dctvar))
# {'one': 1, 'two': 2}
# <class 'dict'>
注意點 推薦使用列表、元組，不推薦使用集合和字串
# 1、外層是列表或者元組、集合，裡面的容器推薦是元組或者列表
var = [(1, 2), [3, 4]]
res = dict(var)
print(res, type(res))
# 2、不推薦使用集合
# 如果裡面是集合，語法上雖然允許，但是有侷限性。因為集合無序，往往不符合定義的本意，也就是說往往二級容器當中的第一個元素可能不會成為鍵。
var = [{'1', 2}, {'2', 3}]
res = dict(var)
print(res)
# 3、不推薦使用字串
# 如果使用字串，語法上正確，但是也有侷限性。因為字串中的一個字元就視為一個元素，所以字串的長度不能超過兩個字元，不然就不滿足強轉字典的要求了。
var = [[1, 2], "ab"]
print(dict(var))
var = [[1, 2], "abc"]
print(dict(var)) # error
各資料型別的函式的作用
# 直接使用建立一個同類型的空值，也就是轉成布林都是false
print(int()) # 0
print(float()) # 0.0
print(bool()) # false
print(complex()) # 0j
print(str()) # ''
print(list()) # []
print(tuple()) # ()
print(set()) # set()
print(dict()) # {}