返回文章列表
玄貓（BlackCat）

Python 字串與列表操作應用

本文探討 Python 中字串和列表的操作技巧，涵蓋字串索引、周遊、方法、列表建立、存取、切片、內建函式、運算元以及列表推導式等核心概念，並輔以程式碼範例和圖表說明，幫助讀者全面理解並應用 Python 字串和列表的特性。

程式語言 資料結構
Python 字串 列表 List 資料結構 字串處理

Python 的字串和列表是程式開發中常用的資料結構。字串是不可變序列，透過索引操作個別字元，並可運用內建方法進行大小寫轉換、搜尋和替換等操作。列表則為可變序列，允許修改元素，並提供豐富的內建函式和運算元，例如新增、刪除、排序、反轉等。理解字串的不可變特性和列表的可變特性，對於程式設計至關重要。Python 也提供列表推導式，簡化列表的建立和操作，提升程式碼的簡潔性和效率。掌握這些技巧有助於提升 Python 程式開發的效率和程式碼品質。

字串處理與操作

在Python程式設計中，字串是一種基本且重要的資料型態。字串是不可變的（immutable），這意味著一旦建立了一個字串，就不能更改其內容。

存取字串中的字元

可以使用索引運算元 [] 來存取字串中的個別字元。索引從0開始，表示字串的第一個字元。

my_string = "Hello, World!"
print(my_string[0])  # 輸出：H

內容解密：

  1. my_string 是一個字串物件。
  2. 使用索引運算元 [] 來存取第一個字元。
  3. 索引從0開始，因此 my_string[0] 傳回第一個字元 “H”。

周遊字串內容

可以使用 for 迴圈或 while 迴圈來周遊字串中的所有字元。

my_string = "Python"
for char in my_string:
    print(char)

# 使用 while 迴圈
i = 0
while i < len(my_string):
    print(my_string[i])
    i += 1

內容解密：

  1. for 迴圈直接迭代字串中的每個字元。
  2. while 迴圈透過索引來存取每個字元，len(my_string) 傳回字串的長度。

字串方法與操作

Python提供了多種字串方法來操作和處理字串，如大小寫轉換、搜尋、替換等。

my_string = "hello"
print(my_string.upper())  # 輸出：HELLO
print(my_string.replace("h", "j"))  # 輸出：jello

內容解密：

  1. upper() 方法將字串轉換為大寫。
  2. replace() 方法替換字串中的指定子串。

練習題與程式設計作業

  1. 編寫一個程式，讀取一個字串並顯示其中大寫和小寫字母的總數。
  2. 編寫一個函式 Echo_Word(word)，該函式接受一個單詞作為引數，並傳回一個重複自身的單詞，重複次數等於單詞中的字母數量。
  3. 編寫一個函式 Reverse_Word(word)，傳回單詞的反向排序。

這些練習旨在幫助您更好地理解和掌握Python中的字串處理技術。

Python 列表的介紹與應用

在程式設計中，經常需要儲存相同資料型態的多個變數。舉例來說，日常生活中使用的貨幣面額有 5, 10, 20, 100, 500 和 2000。如果程式設計師想要顯示這六種貨幣面額，可以使用不同的變數來儲存和列印它們。然而，透過列表（List），程式設計師可以使用單一變數來儲存所有相同或不同資料型態的元素，並且可以輕鬆地列印它們。

建立列表

Python 中的列表是一種序列值，稱為專案或元素。這些元素可以是任何資料型態。列表的結構與字串的結構相似。

使用列表建構函式建立列表

以下是一些例子：

  • 建立一個空列表：L1 = list()
  • 建立一個包含三個整數元素的列表：L2 = list([10,20,30])
  • 建立一個包含三個字串元素的列表：L3 = list(["Apple","Banana","Grapes"])
  • 使用內建的 range() 函式建立列表：L4 = list(range(0,6)) # 建立一個包含元素從 0 到 5 的列表
  • 建立一個包含內建字元 X、Y 和 Z 的列表：L5 = list("xyz")

不使用列表建構函式建立列表

以下是一些例子：

  • 建立一個包含三個整數元素的列表：L1 = [10,20,30]
  • 建立一個包含三個字串元素的列表：L2 = ["Apple", "Banana", "Grapes"]

存取列表元素

列表中的元素可以透過其位置來識別。因此，可以使用索引 [] 運算元來存取它們。語法如下：

Name_of_Variable_of_a_List[index]

範例

>>> L1 = ([10,20,30,40,50]) # 建立一個包含 5 個不同元素的列表
>>> L1 # 列印完整的列表
[10, 20, 30, 40, 50]
>>> L1[0] # 列印列表的第一個元素
10

負索引

負索引允許從列表的末尾開始計數存取元素。最後一個元素的索引始終是 -1。

範例

>>> List1 = [10,20,30,40,50,60] # 建立一個列表
>>> List1[-1] # 存取列表的最後一個元素
60
>>> List1[-2] # 存取列表的倒數第二個元素
50

列表切片

切片運算元可以透過指定兩個索引（起始和結束）來傳回列表的子集。語法如下：

Name_of_Variable_of_a_List[Start_Index: End_Index]

範例

>>> L1 = ([10,20,30,40,50]) # 建立一個包含 5 個不同元素的列表
>>> L1[1:4]
[20, 30, 40]

使用步長的列表切片

語法如下：

List_Name[Start_Index:End_Index:Step_Size]

範例

>>> MyList1 = ["Hello",1,"Monkey",2,"Dog",3,"Donkey"]
>>> New_List1 = MyList1[0:6:2]
>>> print(New_List1)
['Hello', 'Monkey', 'Dog']

Python 內建的列表函式

Python 提供了多種內建函式，可以與列表一起使用。這些函式在表 8.1 中列出。

更多範例

>>> List1 = [1,2,3,4] # 包含四個元素的列表
>>> List1[:2] # 存取列表的前兩個元素
[1, 2]
>>> List1[::-1] # 以反向順序顯示列表
[4, 3, 2, 1]
>>> List1[-1:0:-1] # 從索引 -1 開始，到索引 0 結束，步長為 -1
[4, 3, 2]

Python 串列（List）內建函式與運算元詳解

Python 的串列（List）是一種強大且靈活的資料結構，用於儲存多個元素。本文將探討串列的內建函式和運算元，並提供實際範例來展示其用法。

串列內建函式

Python 提供多種內建函式來操作串列，以下是一些常用的函式：

  1. len()：傳回串列中的元素數量。

    List1 = ["Red", "Orange", "Pink", "Green"]
print(len(List1))  # 輸出：4

  2. max() 和 min()：傳回串列中的最大值和最小值。

    List2 = [10, 20, 30, 50, 60]
print(max(List2))  # 輸出：60
print(min(List2))  # 輸出：10

  3. sum()：傳回串列中所有元素的總和。

    List2 = [10, 20, 30, 50, 60]
print(sum(List2))  # 輸出：170

  4. random.shuffle()：隨機打亂串列中的元素順序。

    import random
List2 = [10, 20, 30, 50, 60]
random.shuffle(List2)
print(List2)  # 輸出可能為 [30, 10, 20, 50, 60] 或其他順序

內容解密：

  • len() 用於取得串列的大小，即元素數量。
  • max() 和 min() 分別用於找出串列中的最大值和最小值，適用於數字型別的串列。
  • sum() 用於計算串列中所有數字的總和。
  • random.shuffle() 用於將串列中的元素隨機排列，需先匯入 random 模組。

串列運算元

Python 提供多種運算元來操作串列，包括連線、重複、成員檢查等。

  1. 連線運算元（+）：用於將兩個串列連線成一個新的串列。

    a = [1, 2, 3]
b = [4, 5, 6]
print(a + b)  # 輸出：[1, 2, 3, 4, 5, 6]

  2. 重複運算元（*）：用於將串列中的元素重複指定的次數。

    List1 = [10, 20]
List3 = 2 * List1
print(List3)  # 輸出：[10, 20, 10, 20]

  3. 成員檢查運算元（in）：用於檢查某個元素是否存在於串列中。

    List1 = [10, 20]
print(10 in List1)  # 輸出：True
print(40 in List1)  # 輸出：False

  4. is 運算元：用於檢查兩個變數是否指向同一個物件。

    A = 'Microsoft'
B = 'Microsoft'
print(A is B)  # 輸出：True

A = ['A', 'B', 'C']
B = ['A', 'B', 'C']
print(A is B)  # 輸出：False

  5. del 運算元：用於刪除串列中的元素或整個串列。

    Lst = [10, 20, 30, 40, 50, 60, 70]
del Lst[2]  # 刪除索引位置為2的元素
print(Lst)  # 輸出：[10, 20, 40, 50, 60, 70]

del Lst[-1]  # 刪除最後一個元素
print(Lst)  # 輸出：[10, 20, 40, 50, 60]

del Lst[1:3]  # 刪除索引位置1到2的元素
print(Lst)  # 輸出：[10, 50, 60]

del Lst[:]  # 清空串列
print(Lst)  # 輸出：[]

此圖示說明 is 與 == 的差異：

此圖示呈現了兩個變數 A 和 B 分別指向不同的物件，但這些物件具有相同的值。這解釋了為什麼 A == B 為 True（因為值相同），而 A is B 為 False（因為它們不是同一個物件）。

####內容解密：

  • 連線運算元（+）用於合併兩個串列，形成一個新的串列。
  • 重複運算元（*）用於將串列內容重複多次。
  • 成員檢查運算元（in）用於檢查某個元素是否在串列中。
  • is 用於判斷兩個變數是否參考到同一個物件，注意與 == 的區別，後者比較的是值是否相等。
  • del 用於刪除指定索引的元素，或清空整個串列。

8.9 列表推導式（List Comprehensions）

列表推導式是一種用於從現有序列建立新列表的工具，能夠將一個給定的列表轉換成另一個列表。

列表推導式的基本語法

列表推導式的語法根據數學中的集合建構符號（Set Builder Notation）。其基本結構為：

[<運算式> for <元素> in <序列> if <條件>]

這段語法可以理解為：「對序列中的每個元素計算運算式，如果條件成立，則將結果包含在新列表中。」

例子：使用列表推導式

假設我們有一個列表 List1 = [10, 20, 30, 40, 50]，並希望將每個元素加 10。

未使用列表推導式

List1 = [10, 20, 30, 40, 50]
for i in range(len(List1)):
    List1[i] = List1[i] + 10
print(List1)  # 輸出：[20, 30, 40, 50, 60]

使用列表推導式

List1 = [10, 20, 30, 40, 50]
List1 = [x + 10 for x in List1]
print(List1)  # 輸出：[20, 30, 40, 50, 60]

兩種方法達到了相同的效果，但使用列表推導式的程式碼更簡潔且執行效率更高。

列表推導式的組成部分

  • 輸入序列
  • 參考輸入序列的變數
  • 可選的條件運算式
  • 輸出運算式或輸出變數

程式範例 8.1：篩選偶數

List1 = [1, 2, 3, 4, 5]
print("原始列表內容：", List1)
List1 = [x for x in List1 if x % 2 == 0]
print("篩選後的偶數：", List1)
# 輸出：
# 原始列表內容： [1, 2, 3, 4, 5]
# 篩選後的偶數： [2, 4]

更多列表推導式的例子

程式範例 8.2：計算平方、立方和篩選偶數平方

print("平方列表 A：")
A = [x**2 for x in range(11)]
print(A)

print("立方列表 B：")
B = [x**3 for x in range(11)]
print(B)

print("A 中偶數的元素：")
C = [x for x in A if x % 2 == 0]
print(C)
# 輸出：
# 平方列表 A： [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# 立方列表 B： [0, 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
# A 中偶數的元素： [0, 4, 16, 36, 64, 100]

程式範例 8.3：攝氏轉華氏

Celsius = [10, 20, 31.3, 40, 39.2]
print("攝氏溫度：", Celsius)

Fahrenheit = [((float(9)/5)*x + 32) for x in Celsius]
print("轉換後的華氏溫度：", Fahrenheit)
# 輸出：
# 攝氏溫度： [10, 20, 31.3, 40, 39.2]
# 轉換後的華氏溫度： [50.0, 68.0, 88.34, 104.0, 102.56]

程式範例 8.4：從混合列表中篩選整數

L1 = [1, 'x', 4, 5.6, 'z', 9, 'a', 0, 4]
print("原始混合列表：", L1)

L2 = [e for e in L1 if type(e) == int]
print("篩選出的整數：", L2)
# 輸出：
# 原始混合列表： [1, 'x', 4, 5.6, 'z', 9, 'a', 0, 4]
# 篩選出的整數： [1, 4, 9, 0, 4]

#### 程式碼解析：

  • 每個範例程式碼後面都有「#### 程式碼解析」的段落，用來詳細解析程式碼的作用、觀念及邏輯。
  • 在這些解析中，會逐步講解程式碼的工作原理、技術考量以及可能的改進方向。

圖表輔助說明

在某些情況下，我們可以使用 Plantuml 圖表來輔助說明複雜的邏輯或流程。

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

title Python 字串與列表操作應用

package "資料視覺化流程" {
    package "資料準備" {
        component [資料載入] as load
        component [資料清洗] as clean
        component [資料轉換] as transform
    }

    package "圖表類型" {
        component [折線圖 Line] as line
        component [長條圖 Bar] as bar
        component [散佈圖 Scatter] as scatter
        component [熱力圖 Heatmap] as heatmap
    }

    package "美化輸出" {
        component [樣式設定] as style
        component [標籤註解] as label
        component [匯出儲存] as export
    }
}

load --> clean --> transform
transform --> line
transform --> bar
transform --> scatter
transform --> heatmap
line --> style --> export
bar --> label --> export

note right of scatter
  探索變數關係
  發現異常值
end note

@enduml

此圖示說明瞭使用列表推導式的基本流程：

  • 從原始列表讀取資料。
  • 使用列表推導式對資料進行處理。
  • 輸出處理後的結果。

Python 串列（List）操作與應用

串列（List）是 Python 中一種重要的資料結構，用於儲存多個元素。本文將探討串列的操作方法及其在實際程式設計中的應用。

串列的基本操作

Python 提供了多種方法來操作串列，包括元素的新增、刪除、排序等。

1. 元素的新增

  • append(x)：在串列末尾新增一個元素。
  • extend(iterable)：將可迭代物件中的所有元素新增到串列末尾。
List1 = [1, 2, 3]
List2 = [4, 5, 6]
List1.extend(List2)
print(List1)  # 輸出：[1, 2, 3, 4, 5, 6]

2. 元素的插入與刪除

  • insert(index, x)：在指定索引位置插入一個元素。
  • remove(x)：刪除串列中第一個出現的指定元素。
  • pop(index)：刪除並傳回指定索引位置的元素，若未指定索引，則刪除並傳回最後一個元素。
Lis1 = [10, 20, 30, 40, 60]
Lis1.insert(4, 50)
print(Lis1)  # 輸出：[10, 20, 30, 40, 50, 60]
Lis1.pop(1)
print(Lis1)  # 輸出：[10, 30, 40, 50, 60]
Lis1.remove(30)
print(Lis1)  # 輸出：[10, 40, 50, 60]

3. 串列的其他操作

  • index(x)：傳回串列中第一個出現的指定元素的索引。
  • count(x)：傳回串列中指定元素出現的次數。
  • sort()：對串列進行排序。
  • reverse()：反轉串列中的元素。
List1 = ['A', 'B', 'C', 'B', 'D', 'A']
print(List1.index('B'))  # 輸出：1
print(List1.count('B'))  # 輸出：2
List1.sort()
print(List1)  # 輸出：['A', 'A', 'B', 'B', 'C', 'D']
List1.reverse()
print(List1)  # 輸出：['D', 'C', 'B', 'B', 'A', 'A']

串列與字串的轉換

串列和字串是兩種不同的資料結構，但可以透過某些方法進行轉換。

1. 字串轉串列

使用 list() 方法可以將字串轉換為字元串列。

p = 'Python'
L = list(p)
print(L)  # 輸出：['P', 'y', 't', 'h', 'o', 'n']

2. 字串分割

使用 split() 方法可以將字串按照指定的分隔符號分割成串列。

A = "Wow!!! I Love Python Programming"
B = A.split()
print(B)  # 輸出：['Wow!!!', 'I', 'Love', 'Python', 'Programming']
P = "My-Data-of-Birth-03-June-1991"
print(P.split('-'))  # 輸出：['My', 'Data', 'of', 'Birth', '03', 'June', '1991']

將串列傳遞給函式

串列是可變物件，可以將其傳遞給函式並在函式內部進行修改。

程式範例

def Print_List(Lst):
    for num in Lst:
        print(num, end=" ")

Lst = [10, 20, 30, 40, 100]
Print_List(Lst)  # 輸出：10 20 30 40 100

def Calculate_Avg(Lst):
    print('Lst = ', Lst)
    print('Sum = ', sum(Lst))
    avg = sum(Lst) / len(Lst)
    print('Average = ', avg)

Lst = [10, 20, 30, 40, 3]
Calculate_Avg(Lst)
# 輸出：
# Lst = [10, 20, 30, 40, 3]
# Sum = 103
# Average = 20.6

def Split_List(Lst, n):
    list1 = Lst[:n]
    list2 = Lst[n:]
    print('First List with ', n, ' elements')
    print(list1)
    print('Second List with ', len(Lst) - n, ' elements')
    print(list2)

Lst = [100, 22, 32, 43, 51, 64]
Split_List(Lst, 2)
# 輸出：
# First List with 2 elements
# [100, 22]
# Second List with 4 elements
# [32, 43, 51, 64]