2024年09月21日玄貓（BlackCat）

Python字典TupleRange與流程控制詳解

本文探討 Python 的字典、Tuple、Range 等重要資料結構，以及流程控制機制，包含條件判斷與迴圈。涵蓋字典的建立、索引、修改、巢狀結構，以及常用內建函式如 fromkeys、get、update 等。同時，也詳細介紹 Tuple 的特性、建立方式、索引、巢狀結構和內建函式。此外，文章也說明 Range

Python 程式語言

字典 Tuple Range 流程控制迴圈條件判斷

Python 的字典、Tuple 和 Range 是程式開發中常用的資料結構，理解它們的特性和操作方法至關重要。字典以鍵值對儲存資料，支援快速查詢和修改。Tuple 則是一種不可變的資料結構，適用於儲存固定資料。Range 可產生數列，方便迴圈迭代。此外，Python 的流程控制包含條件判斷和迴圈，能根據不同情況執行不同程式碼，或重複執行特定程式碼區塊。這些機制共同構成了 Python 程式語言的核心基礎，熟練掌握這些知識有助於提升程式開發效率和程式碼品質。

Python字典詳解

字典是一種可變的資料結構，用於儲存鍵值對。它支援多種操作，包括索引、修改、新增和巢狀結構。

建立字典

可以使用大括號 {} 或 dict() 建構函式來建立字典。

d = {}
print(type(d))   # 輸出：<class 'dict'>

d = {'x':4 ,   , 'p':   ,   :8}
print(d)   # 輸出：{'x':8,,   }

dic   ,   }
dic   
dic   
print( dic )   # 輸出：{'argentina':,,   }

在字典中，鍵必須是唯一的，重複的鍵會被最後賦予的值所覆寫。

索引與修改

字典支援透過鍵來存取其對應的值，並可對現有的鍵進行修改。

d   
print   
# 輸出：

dic   
dic   
dic   
print( dic )
# 輸出：{'argentina':,,   }

透過指定鍵來存取或修改對應的值，是字典操作中的基本用法。

###巢狀字典

字典可以巢狀使用，即一個字典的值可以是另一個字典。這使得資料結構更加靈活。

dic   
print   
# 輸出：{'argentina':,,   }

di   
c   
print   
# 輸出：
c   
print   
# 輸出：

巢狀字典允許我們透過多層鍵來存取內層的資料。需根據巢狀層級使用相應數量的索引來存取資料。

Python 字典內建函式詳解

Python 的字典（Dictionary）物件具備多種內建函式，能夠大幅簡化資料操作與管理的複雜度。以下將探討這些內建函式的使用方法，並透過具體範例進行詳細解說。

2.8.2.1 fromkeys：建立字典的便捷方式

fromkeys 函式允許我們使用一個可迭代物件來建立字典，並為每個元素指定一個初始值。其基本語法為 dic.fromkeys(iter_obj, obj)，其中 iter_obj 是可迭代物件，而 obj 是要賦予每個元素的值。

d = dict()
s = 'are'
c = d.fromkeys(s, 12)
print(c)  # 輸出：{'a': 12, 'r': 12, 'e': 12}
c = d.fromkeys(s, ['c'])
print(c)  # 輸出：{'a': ['c'], 'r': ['c'], 'e': ['c']}

內容解密：

首先建立一個空字典 d 和一個字串 s = 'are'。
使用 d.fromkeys(s, 12)，將字串 s 中的每個字元作為鍵，12 作為值，建立一個新的字典 c。
第二個範例中，將 ['c'] 作為值賦予每個鍵。

2.8.2.2 get：安全地檢索字典中的值

get 函式用於檢索字典中的值，若鍵不存在，則傳回 None 或指定的預設值。其語法為 dic.get(key, obj)。

dic = {'argentina': 1, 'france': 2}
c = dic.get('brazil', {89: 'p'})
print(c)  # 輸出：{89: 'p'}
c = dic.get('france', 8)
print(c)  # 輸出：2

內容解密：

在第一個範例中，由於 'brazil' 不存在於字典 dic 中，因此傳回指定的預設值 {89: 'p'}。
在第二個範例中，由於 'france' 存在於字典中，因此傳回其對應的值 2。

2.8.2.3 update：更新字典內容

update 函式用於將新的鍵值對更新到現有的字典中，若鍵已存在，則更新其值。

dic = {'argentina': 1, 'france': 2}
dic.update(c=[98])
print(dic)  # 輸出：{'argentina': 1, 'france': 2, 'c': [98]}

內容解密：

將新的鍵值對 c=[98] 更新到字典 dic 中。

2.8.2.4 clear：清空字典內容

clear 函式用於清空字典中的所有內容，使其變為空字典。

dic = {'argentina': 1, 'france': 2}
dic.clear()
print(dic)  # 輸出：{}

內容解密：

清空字典 dic 中的所有內容。

2.8.2.5 items、values、keys：存取字典的內容

這些函式分別用於傳回字典中的鍵值對、值和鍵。

dic = {'argentina': 1, 'france': 2}
print(list(dic.items()))  # 輸出：[('argentina', 1), ('france', 2)]
print(list(dic.values()))  # 輸出：[1, 2]
print(list(dic.keys()))    # 輸出：['argentina', 'france']

內容解密：

items() 傳回字典中的所有鍵值對。
values() 傳回字典中的所有值。
keys() 傳回字典中的所有鍵。

2.8.2.8 pop 與 2.8.2.9 popitem：刪除字典中的元素

pop 用於刪除指定鍵的元素，而 popitem 用於刪除並傳回最後一個插入的鍵值對。

dic = {'argentina': 1, 'france': 2}
print(dic.pop('france'))    # 輸出：2
print(dic.popitem())        # 輸出：('argentina', 1)

內容解密：

pop('france') 刪除鍵為 'france' 的元素並傳回其值。
popitem() 刪除並傳回最後一個插入的鍵值對。

Python 基礎：Tuple 與 Range 的應用

在 Python 中，Tuple（元組）是一種不可變的資料結構，用於儲存多個元素。Tuple 的特性包括可索引、不可變、允許重複元素以及可巢狀結構。

Tuple 的基本特性

可索引：可以透過索引存取 Tuple 中的元素。
不可變：Tuple 中的元素無法被修改或刪除，也無法插入新元素。
可重複：Tuple 允許包含重複的元素。
可巢狀：Tuple 可以包含其他 Tuple，形成巢狀結構。

建立 Tuple

在 Python 中，可以使用小括號 () 或 tuple() 函式來建立 Tuple。

# 建立空 Tuple
t = ()
print(type(t))  # 輸出: <class 'tuple'>

# 建立包含多個元素的 Tuple
t = ('x', 4, 1, '9', 'p', 'o', 'x', 9, 7, 'x', 8)
print(t)  # 輸出: ('x', 4, 1, '9', 'p', 'o', 'x', 9, 7, 'x', 8)

不使用括號建立 Tuple

在 Python 中，可以不使用括號來建立 Tuple，只要元素之間以逗號分隔即可。

t = 'argentina', 1, 'france', 2, 'Croatia', 3, 'morocco', 4
print(t)  # 輸出: ('argentina', 1, 'france', 2, 'Croatia', 3, 'morocco', 4)

索引存取 Tuple 元素

可以透過索引來存取 Tuple 中的元素。

t = ('argentina', 1, 'france', 2, 'Croatia', 3, 'morocco', 4)
print(t[0])  # 輸出: argentina
print(t[3])  # 輸出: 2

巢狀 Tuple

巢狀 Tuple 是指 Tuple 中包含其他 Tuple。存取巢狀 Tuple 中的元素需要使用多個索引。

t = ('argentina', 1, 'france', ('gold', 'silver', (2, 4)))
ind = t[3][2][1]
print(ind)  # 輸出: 4

Tuple 的內建函式

Tuple 有一些內建函式，例如 count() 和 index()。

Count

count() 函式用於計算指定元素在 Tuple 中出現的次數。

t = ('argentina', 1, 'france', [99], 1)
y = t.count(1)
print(y)  # 輸出: 2

Index

index() 函式用於找出指定元素在 Tuple 中第一次出現的索引。

Tuple 建構函式

tuple() 函式用於將其他可迭代物件轉換為 Tuple。

t = tuple('abcs=d')
print(t)  # 輸出: ('a', 'b', 'c', 's', '=', 'd')

t = tuple([7, 6, 3, 0])
print(t)  # 輸出: (7, 6, 3, 0)

t = tuple({'x': 1, 'y': 2})
print(t)  # 輸出: ('x', 'y')

t = tuple({'x', 'y'})
print(t)  # 輸出: ('x', 'y') 或 ('y', 'x')，順序可能不同

Range 型別

Range 型別用於產生一系列整數，通常用於迴圈迭代。

建立 Range 物件

Range 物件可以透過 range() 函式建立，該函式接受起始值、結束值和步長等引數。

x = range(10)
print(type(x))  # 輸出: <class 'range'>

將 Range 物件轉換為其他資料結構

預設情況下，Range 物件中的數字不會直接顯示，需要將其轉換為 List、Tuple 或 Set 等資料結構才能檢視其內容。

x = list(range(10))
print(x)  # 輸出: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

x = set(range(10))
print(x)  # 輸出: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

x = tuple(range(10))
print(x)  # 輸出: (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

指定起始值、結束值和步長

可以透過指定起始值、結束值和步長來建立具有特定範圍和間隔的 Range 物件。

x = list(range(10, 17))
print(x)   # 輸出: [10,11 ,12 ,13 ,14 ,15 ,16]

x = list(range(10 ,17 ,2))
print(x)   # 輸出: [10 ,12 ,14 ,16]

x = list(range(10 ,17 ,3))
print(x)   # 輸出: [10 ,13 ,16]

也可以建立遞減的 Range 物件。

x = list(range(17 ,10 ,−1))
print(x)   # 輸出: [17 ,16 ,15 ,14 ,13 ,12 ,11]

x = list(range(17 ,10 ,−2))
print(x)   # 輸出: [17 ,15 ,13 ,11]

陳述式（Statements）

在 Python 中，陳述式是指示直譯器執行的指令。簡單陳述式通常寫在一行中，但也可以跨越多行。

物理行與邏輯行

Python 中的「行」有兩種解釋：物理行和邏輯行。物理行是指程式碼中可見的行，而邏輯行是指直譯器對陳述式的解讀結果。一個邏輯行可以由一個或多個物理行組成。

Python 程式基礎：陳述式與控制結構

在 Python 程式語言中，陳述式（statements）是程式的基本組成單位。簡單陳述式可以寫在一行中，只要使用分號（;）分隔即可。然而，為了提高程式碼的可讀性和維護性，通常不建議將多個陳述式寫在同一行中。以下範例展示了簡單陳述式和複合陳述式的寫法。

簡單陳述式與物理行、邏輯行

a = 10  # 這是一個簡單陳述式，同時是物理行和邏輯行
b = 13; a = 34  # 這是一行包含兩個邏輯行的物理行

內容解密：

a = 10 是一個簡單陳述式，代表將數值 10 指定給變數 a。
b = 13; a = 34 展示瞭如何在同一物理行中使用分號分隔多個邏輯行。

複合陳述式與縮排

Python 使用縮排來定義程式碼區塊，而不是像其他語言使用大括號 {}。複合陳述式通常由一個包含關鍵字和表示式的標頭開始，並以冒號（:）結束。後續的陳述式必須保持相同的縮排層級，以表示它們屬於同一個程式碼區塊。

if 陳述式範例

if 20 > 18:  # 標頭由 if 關鍵字和表示式組成，以冒號結束
    x = 0
    x = x + 1
    print('greater')  # 這些陳述式相對於標頭具有相同的縮排

內容解密：

if 20 > 18: 是標頭，檢查條件 20 > 18 是否為真。
後續的 x = 0、x = x + 1 和 print('greater') 陳述式都具有相同的縮排，表示它們屬於 if 陳述式的程式碼區塊。

while 迴圈範例

x = 0
n = 20
while x <= n:  # while 迴圈的標頭
    x = x + 1
    print(n)  # 後續陳述式保持相同縮排

內容解密：

while x <= n: 是 while 迴圈的標頭，檢查條件 x <= n。
x = x + 1 和 print(n) 是迴圈體內的陳述式，具有相同的縮排。

for 迴圈範例

lst = [2, 5, 7, 9, 3]
for i in lst:  # for 迴圈的標頭，使用 in 關鍵字遍歷序列
    x = 0
    print(i)  # 後續陳述式保持相同縮排

內容解密：

for i in lst: 是 for 迴圈的標頭，用於遍歷串列 lst 中的元素。
x = 0 和 print(i) 是迴圈體內的陳述式，具有相同的縮排。

Python 中的條件判斷

在程式設計中，經常需要根據特定條件執行不同的操作。Python 中的 if 結構用於實作條件分支。

if 結構範例

x = 431
y = 238
z = 437
maximum = 0
if x > y and x > z:  # 第一個條件檢查
    maximum = x
elif y > x and y > z:  # 第二個條件檢查
    maximum = y
elif z > x and z > y:  # 第三個條件檢查
    maximum = z
print('The maximum number is', maximum)

內容解密：

程式首先檢查 x 是否大於 y 和 z，如果是，則將 maximum 設定為 x。
如果第一個條件不滿足，則檢查 y 是否大於 x 和 z，依此類別推。
最後輸出最大值。

型別檢查範例

x = 'learn'
if type(x) == int:  
    print('the type is integer')
elif type(x) == float:  
    print('the type is float')
else:  
    print('the type is string')

內容解密：

程式檢查變數 x 的型別。
如果 x 是整數，則輸出 “the type is integer”。
否則，檢查是否為浮點數或字串，並輸出對應的型別資訊。

Python 中的迴圈結構

迴圈用於重複執行某段程式碼，直到滿足特定條件。Python 主要支援兩種迴圈：while 和 for。

for 迴圈結構

x = [1, 5, 8, 9, 109]
for i in x:
    if i % 2 == 0:
        print('the number', i, 'is even')
    else:
        print('the number', i, 'is odd')

內容解密：

程式遍歷串列 x 中的每個元素 i。
使用條件判斷檢查 i 是否為偶數，並輸出對應的結果。

2.12 迴圈結構

在Python中，迴圈是一種控制結構，允許程式重複執行某段程式碼。主要的迴圈型別有for迴圈和while迴圈。

2.12.1 For 迴圈

for迴圈用於遍歷可迭代物件（如串列、元組、字典等）。在每次迭代中，迴圈變數會被賦予可迭代物件中的下一個元素。

單變數 For 迴圈

for i in range(10):
    if i % 2 == 0:
        print(f"the number {i} is even")
    else:
        print(f"the number {i} is odd")

多變數 For 迴圈

在for迴圈中，變數部分的變數數量可以多於一個，只要可迭代物件中的元素數量與變數數量相符即可。

for i, j in [(1, 9), (8, 9), (7, 6), (7, 6)]:
    print(i, j)

輸出結果：

For 迴圈與字典

dic = {'cs': 10, 'ds': 13, 'phd': 4, 'ms': 10}
for i, j in dic.items():
    print(i, j)

輸出結果：

cs 10
ds 13
phd 4
ms 10

####巢狀 For 迴圈

mat = []
for i in range(5):
    row = []
    for j in range(6):
        row.append(0)
    mat.append(row)
print(mat)

輸出結果：

[[0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0]]

#### 程式碼詳解：

此段程式碼建立了一個5x6的矩陣，並將所有元素初始化為0。

外層迴圈for i in range(5):控制矩陣的行數。
內層迴圈for j in range(6):控制每一行的元素數量。
row.append(0)將0新增到當前行中。
mat.append(row)將完成的行新增到矩陣中。

####2.12.2 Comprehensions（解析式） Comprehensions是用於快速建立序列（如串列、集合、字典）的一種簡潔語法。

#####串列解析式（List Comprehension）

lst = [x for x in range(6)]
print(lst) 
# 輸出：[0, 1, 2, 3, 4, 5]

#####集合解析式（Set Comprehension）

u = {x**2 for x in range(7)}
print(u) 
# 輸出：{0, 1, 4, 9, 16, 25, 36}

#####字典解析式（Dictionary Comprehension）

u = {x: x-1 for x in range(7)}
print(u) 
# 輸出：{0: -1, 1: 0, 2: 1, 3: 2, 4: 3, 5: 4, 6:5}

###2.13 Functions（函式）函式是一段可重複使用的程式碼，用於執行特定的任務。Python中的函式分為內建函式和使用者自定義函式。

####內建函式 Python提供了許多內建函式，例如max()、sum()、abs()等。

#####max()函式用於取得可迭代物件中的最大值。

t = [4,7,9,3]
m = max(t)
print(m) 
# 輸出：9

#####sum()函式用於計算可迭代物件中所有元素的總和。

t = [4,7,9,3]
s = sum(t)
print(s) 
# 輸出：23

#####abs()函式用於取得數值的絕對值。

t = abs(-81)
print(t) 
# 輸出：81

#####enumerate()函式用於遍歷可迭代物件並追蹤元素的索引。

l1 = ['x',1 ,9 ,'cs']
enum = list(enumerate(l1))
print(enum) 
# 輸出：[(0,'x'), (1,1), (2,9), (3,'cs')]