08 - 類型轉換＆深淺拷貝

返回主頁

📄目錄

• 08 - 類型轉換＆深淺拷貝

  • 📄目錄

• 1. 類型轉換

  • 1.1 int(x)：轉換為一個整數，只能轉換由純數字組成的字符串

    • 1.1.1 float -> int

    • 1.1.2 str -> int

    • 1.1.3 案例：用戶從控制台輸入，判斷年齡

  • 1.2 float()：轉換為一個小數

  • 1.3 str()：轉換為字符串類型，任何類型都可以轉換

  • 1.4 eval(str)：用於執行一個字符串表達式並返回表達式的值

    • 1.4.1 str -> list

    • 1.4.2 str -> dict

  • 1.5 list()：將可迭代對象轉換成列表

    • 1.5.1 str -> list

    • 1.5.2 tuple -> list

    • 1.5.3 dict -> list

    • 1.5.3 set -> list

• 2. 深淺拷貝

  • 2.1 賦值：賦值過的對象會隨原對象一起變化

  • 2.2 淺拷貝（數據半共享）

  • 2.3 深拷貝（數據完全不共享）

• 3. 可變對象

  • 3.1 list

  • 3.2 dict

  • 3.3 set

• 4. 不可變對象

  • 4.1 數值類型

  • 4.2 字符串

  • 4.3 元組

• 導航連結：

1. 類型轉換

💡 常見類型：

1. int(x)：將x轉換為一個整數

2. float(x)：將x轉換為一個浮點數

3. str(x)：將x轉換為字符串

4. eval(str)：用來計算在字符串中的有效Python表達式，並返回一個對象

5. tuple(s)：將序列s轉換為一個元組

6. list(s)：將序列s轉換為一個列表

7. chr(x)：將一個整數轉換為一個字符

1.1 int(x)：轉換為一個整數，只能轉換由純數字組成的字符串

1.1.1 float -> int

xxxxxxxxxx
a = 1.2
print(type(a))
b = int(a)
print(b, type(b))
print(int(1.8)) # 浮點型強轉換會去掉小數點及後面的數值，只保留整數部分

輸出結果：

xxxxxxxxxx
<class 'float'>
1 <class 'int'>
1

1.1.2 str -> int

xxxxxxxxxx
a = int('123')
print(a, type(a))
# print(int('myname'))    # 報錯，只能轉純數字
print(int('-123'), type(int('-123')))
# print(int('1.23'))  # 除非字符串有正負號（寫在最前面）以外的字符，否則報錯，如小數點

輸出結果：

xxxxxxxxxx
123 <class 'int'>
-123 <class 'int'>

1.1.3 案例：用戶從控制台輸入，判斷年齡

xxxxxxxxxx
age = input('請輸入你的年齡：')
if int(age) >= 18:
    print('成年了！')
# 輸入內容為字符串，因此需要強制轉換為int再比較

1.2 float()：轉換為一個小數

xxxxxxxxxx
print(float(11))    # int轉換為float，會自動添加一位小數
print(float(-11))
print(float('+11.345'))
# print(float('10-')) # 如果字符串中有正負號（不在最前面），數字和小數點以外的字符，就不支持轉換

輸出結果：

xxxxxxxxxx
11.0
-11.0
11.345

1.3 str()：轉換為字符串類型，任何類型都可以轉換

xxxxxxxxxx
n = 100
print(n, type(n))
n2 = str(n)
print(n2, type(n2))
st = str(-1.80)
print(st, type(st)) # 浮點型轉換字符串類型的話會去除末位為0的小數部分
li = [1,2,3]
st = str(li)
print(st, type(st))

輸出結果：

xxxxxxxxxx
100 <class 'int'>
100 <class 'str'>
-1.8 <class 'str'>
[1, 2, 3] <class 'str'>

1.4 eval(str)：用於執行一個字符串表達式並返回表達式的值

xxxxxxxxxx
print(10 + 10)
print('10 + 10')
print(eval('10 + 10'))  # 執行運算，並返回運算的值
print(eval('10' + '10'))

輸出結果：

xxxxxxxxxx
20
10 + 10
20
1010

💡 eval()可以實現list、dict、tuple和str之間的轉換

1.4.1 str -> list

xxxxxxxxxx
st1 = '[[1,2],[3,4],[5,6]]'
print(type(st1))
li = eval(st1)
print(li, type(li))

輸出結果：

xxxxxxxxxx
<class 'str'>
[[1, 2], [3, 4], [5, 6]] <class 'list'>

1.4.2 str -> dict

xxxxxxxxxx
st2 = "{'name':'Victoria','age':18}"
dic = eval(st2)
print(dic, type(dic))

輸出結果：

xxxxxxxxxx
{'name': 'Victoria', 'age': 18} <class 'dict'>

❗ eval功能強大，但是不夠安全，容易被惡意修改數據，不建議使用

1.5 list()：將可迭代對象轉換成列表

支持轉換為list的類型：str、tuple、dict、set

1.5.1 str -> list

xxxxxxxxxx
print(list('abcdefg'))
# print(list(12345))  # 報錯

輸出結果：

xxxxxxxxxx
['a', 'b', 'c', 'd', 'e', 'f', 'g']

1.5.2 tuple -> list

xxxxxxxxxx
print(list((1,2,3,4)))

輸出結果：

xxxxxxxxxx
[1, 2, 3, 4]

1.5.3 dict -> list

xxxxxxxxxx
print(list({'name':'Victoria','age':18}))
# 字典轉換成列表，會取鍵名作為列表的值

輸出結果：

xxxxxxxxxx
['name', 'age']

1.5.3 set -> list

xxxxxxxxxx
print(list({1,2,3,4,5}))
print(list({'a','b','c','d','b','c'}))  # 轉換時先去重、再轉換

輸出結果：

xxxxxxxxxx
[1, 2, 3, 4, 5]
['c', 'd', 'a', 'b']

2. 深淺拷貝

2.1 賦值：賦值過的對象會隨原對象一起變化

xxxxxxxxxx
li = [1, 2, 3, 4, 5]
print(li)
li2 = li
print('li', li)
print('li2', li2)
li.append(6)    # 給li列表新增元素
print('新增後的li', li, 'li內存地址：', id(li))
print('新增後的li2', li2, 'li2內存地址：', id(li2))   # 兩個是一樣的

輸出結果：

xxxxxxxxxx
[1, 2, 3, 4, 5]
li [1, 2, 3, 4, 5]
li2 [1, 2, 3, 4, 5]
新增後的li [1, 2, 3, 4, 5, 6] li內存地址： 4345661952
新增後的li2 [1, 2, 3, 4, 5, 6] li2內存地址： 4345661952

💡 賦值：等於完全共享資源，一個值的改變會完全被另一個值共享。

2.2 淺拷貝（數據半共享）

💡 會創建新的對象，拷貝第一層的數據，嵌套層會指向原來的內存地址

xxxxxxxxxx
import copy # 導入copy模塊
li3 = [1, 2, 3, [4, 5, 6]]  # 定義一個嵌套列表
li4 = copy.copy(li3)    # 淺拷貝
print('li3', li3)
print('li4', li4)
# 查看內存地址
print('li3內存地址：', id(li3))
print('li4內存地址：', id(li4))
# 內存地址不一樣，說明是不同對象
li3.append(8)
print('li3', li3)
print('li4', li4)
# 往嵌套列表添加元素
li3[3].append(7)
print('li3', li3)
print('li4', li4)
print('li3[3]內存地址：',id(li3[3]))
print('li4[3]內存地址：',id(li4[3]))

輸出結果：

xxxxxxxxxx
li3 [1, 2, 3, [4, 5, 6]]
li4 [1, 2, 3, [4, 5, 6]]
li3內存地址： 4352916032
li4內存地址： 4352915968
li3 [1, 2, 3, [4, 5, 6], 8]
li4 [1, 2, 3, [4, 5, 6]]
li3 [1, 2, 3, [4, 5, 6, 7], 8]
li4 [1, 2, 3, [4, 5, 6, 7]]
li3[3]內存地址： 4352912384
li4[3]內存地址： 4352912384

💡 外層的內存地址不同，但是內層地址還是相同的

優點：拷貝速度快，佔用空間少，拷貝效率高

2.3 深拷貝（數據完全不共享）

💡 外層的對象和內部的元素都拷貝了一遍

❗ 深拷貝數據變化只影響自己本身，跟原來的對象沒有關聯

xxxxxxxxxx
import copy # 導入copy模塊
li5 = [1, 2, 3, [4, 5, 6]]
li6 = copy.deepcopy(li5)
print('li5', li5, id(li5))
print('li6', li6, id(li6))
li5.append(8)
print(li5)
print(li6)
# 在嵌套列表添加元素
li5[3].append(7)
print(li5, 'li5[3]內存地址：', id(li5[3]))
print(li6, 'li6[3]內存地址：', id(li6[3]))

輸出結果：

xxxxxxxxxx
li5 [1, 2, 3, [4, 5, 6]] 4352916992
li6 [1, 2, 3, [4, 5, 6]] 4352916928
[1, 2, 3, [4, 5, 6], 8]
[1, 2, 3, [4, 5, 6]]
[1, 2, 3, [4, 5, 6, 7], 8] li5[3]內存地址： 4352916544
[1, 2, 3, [4, 5, 6]] li6[3]內存地址： 4348554176

3. 可變對象

💡 含義：存儲空間保存的數據允許被修改，但是內存地址不會發生改變，這種數據就是可變類型

常見的可變類型：列表list、字典dict、集合set

3.1 list

xxxxxxxxxx
# list
li7 = [1, 2, 3, 4]
print('li7的內存地址：', id(li7))
li7.append(5)
print(li7)
print('li7的現內存地址：', id(li7))

輸出結果：

xxxxxxxxxx
li7的內存地址： 4352916736
[1, 2, 3, 4, 5]
li7的現內存地址： 4352916736

3.2 dict

xxxxxxxxxx
# dict
dic = {'name':'Victoria','age':18}
print(dic, id(dic))
dic['name'] = 'Valentine'   # 修改值
print(dic, id(dic))

輸出結果：

xxxxxxxxxx
{'name': 'Victoria', 'age': 18} 4347777856
{'name': 'Valentine', 'age': 18} 4347777856

3.3 set

xxxxxxxxxx
# set
st = {1,2,3,4,5}
print(st, id(st))
st.remove(3)    # 刪除元素
print(st, id(st))

輸出結果：

xxxxxxxxxx
{1, 2, 3, 4, 5} 4348189312
{1, 2, 4, 5} 4348189312

4. 不可變對象

💡 含義：變量對應的值不允許被修改，如果修改就會生成新的值從而分配新的內存空間

常見的可變類型：

1. 數值類型：int, bool, float, complex

2. 字符串：str

3. 元組：tuple

❗ 注意：前面所說的深淺拷貝只針對可變對象，不可變對象是沒有這個說法的

4.1 數值類型

xxxxxxxxxx
# 整型
n = 10
print(n, '原地址：', id(n))
n = 15
print(n, '修改後：', id(n))
# 內存地址不一樣：修改n的值就會生成新的值，重新賦值給變量n

輸出結果：

xxxxxxxxxx
10 原地址： 4366202544
15 修改後： 4366202704

4.2 字符串

xxxxxxxxxx
# 字符串
st = 'hello'
print(st, id(st))
st = 'welcome'
print(st, id(st))

輸出結果：

xxxxxxxxxx
hello 4348553200
welcome 4348552944

4.3 元組

xxxxxxxxxx
# 元組
tua = (1, 2, 3)
print(tua, id(tua))
tua = ('a', 'b', 'c')
print(tua, id(tua))

輸出結果：

xxxxxxxxxx
(1, 2, 3) 4348506816
('a', 'b', 'c') 4348985088

導航連結：