python數據類型的強制轉換

數據類型的強制轉換

若是要將一個數據轉換成另外一個數據類型，只須要將其放入相應類型的函數中去。

Number類型的數據轉換

強制轉換爲int

能夠轉換的數據類型

1. int 整型
2. float 浮點型
3. bool 布爾型
4. 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

能夠轉換的數據類型

1. int 整型
2. float 浮點型
3. bool 布爾型
4. 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

# 一、整型 （0）
print(bool(0))

# 二、浮點型（0.0）
print(bool(0.0))

# 三、布爾型（False）
print(bool(False))

# 四、複數（0j）
print(bool(0j))

# 五、字符串（空字符串）
print(bool(''))

# 六、列表（空列表）
print(bool([]))

# 七、元組（空元組）
print(bool(()))

# 八、集合（空集合）
print(bool(set()))

# 九、字典（空字典）
print(bool({}))

# 十、None（python關鍵字，表示什麼也沒有）
print(bool(None))

強制轉換爲complex

能夠轉換的數據類型

1. int 整型
2. float 浮點型
3. bool 布爾型
4. complex 複數
5. 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

1. bool和除了bool以外的任何數據類型運算結果都不會是bool
2. 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類型的強制轉換

容器類型的轉換，使用相應容器的函數進行轉換。

轉換爲字符串

支持轉換的數據類型

全部的數據類型

# 方法一、直接加引號
print('[1, 2, 3]')

# 方法二、使用str函數
print(str([1, 2, 3]))
# [1, 2, 3]

# 方法三、使用repr函數
print(repr([1, 2, 3]))
# [1, 2, 3]

# repr函數的做用：原型化輸出字符串，不轉義字符（顯示出引號）
lstvar = [1, 2, 3]
res =  str(lstvar)
print(repr(res))
# '[1, 2, 3]'

轉換爲列表

支持轉換的數據類型

僅容器

注意要點

若是是字符串，會把每個字符串單獨的做爲一個元素放到列表中；
若是是字典，只保留鍵，造成一套新的列表；
若是是其它的容器，只是單純的在原有數據的基礎上換上[]；

# 一、字符串
# 字符串中的每個字符都視爲一個元素
var = 'hello motherland'
print(list(var))
# ['h', 'e', 'l', 'l', 'o', ' ', 'm', 'o', 't', 'h', 'e', 'r', 'l', 'a', 'n', 'd']

# 二、字典
var = {'one': 1, 'two': 2, 'three': 3}
print(list(var))
# ['one', 'two', 'three']

# 三、其它的數據類型
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是同樣的

# 一、字符串
# 字符串中的每個字符都視爲一個元素
var = 'hello motherland'
print(tuple(var))
# ('h', 'e', 'l', 'l', 'o', ' ', 'm', 'o', 't', 'h', 'e', 'r', 'l', 'a', 'n', 'd')

# 二、字典
var = {'one': 1, 'two': 2, 'three': 3}
print(tuple(var))
# ('one', 'two', 'three')

# 三、其它的數據類型
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)

轉換爲集合

支持的數據類型

僅容器

注意要點

集合的變化和列表、元組都是同樣的，只是單純的在原有數據的基礎上換上{}；

可是集合是無序的，返回的結果中的元素的順序是不固定的

# 一、字符串
# 字符串中的每個字符都視爲一個元素
var = 'hello motherland'
print(set(var))
# {'d', 'r', ' ', 'h', 'n', 'e', 't', 'm', 'a', 'o', 'l'}

# 二、字典
var = {'one': 1, 'two': 2, 'three': 3}
print(set(var))
# {'two', 'one', 'three'}

# 三、其它的數據類型
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'}

多級容器

1. 在一個容器當中嵌套一個容器，這個容器就叫作二級容器；在被嵌套的容器當中再嵌套一個容器，最外層的容器就叫作三級容器；以此類推，有四級、五級……
2. 容器的類型取決於最外層的容器，不一樣的類型容器能夠相互嵌套，可是，集合和字典除外；由於字典的鍵和集合中的值必須是可哈希的類型，可哈希的數據類型Number、str、tuple；
3. 多級容器不包括字符串，字符串是特殊的容器，任何字符在字符串中都是字符串的一個單獨元素；

# 二級容器
# 好比列表中嵌套一個列表
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特有的逆向下標，來逐一獲取出來

# 一、先獲取元組。也就是第二級容器
res = No1_level4_container[-1]  # 釋放一級 也就是經過列表的下標-1來選擇出來
print("---釋放一級")
print(res)

# 二、在獲取字典
res = res[-1]
res1 = No1_level4_container[-1][-1]
print("---剝奪二級")
print(res)
print(res1)

# 三、在獲取鍵值msr對應的值
res = res['msr']
print("---獲取msr")
print(res)

# 四、在獲取數值10 下標-1或者4
res1 = res[-1]
res2 = res[4]
print('---最終結果')
print(res1, res2)

# 簡寫
res = No1_level4_container[-1][-1]['msr'][-1]
print('---簡寫結果')
print(res)

等長的多級容器

1. 外層容器中的元素都是容器
2. 被嵌套容器中的元素個數相同

# 等長的二級容器
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'>

注意點

推薦使用列表、元組，不推薦使用集合和字符串

# 一、外層是列表或者元組、集合，裏面的容器推薦是元組或者列表
var = [(1, 2), [3, 4]]
res = dict(var)
print(res, type(res))

# 二、不推薦使用集合
# 若是裏面是集合，語法上雖然容許，可是有侷限性。由於集合無序，每每不符合定義的本意，也就是說每每二級容器當中的第一個元素可能不會成爲鍵。
var = [{'1', 2}, {'2', 3}]
res = dict(var)
print(res)

# 三、不推薦使用字符串
# 若是使用字符串，語法上正確，可是也有侷限性。由於字符串中的一個字符就視爲一個元素，因此字符串的長度不能超過兩個字符，否則就不知足強轉字典的要求了。
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())		# {}