第八章 字串
8-0 notepad++ 的區塊處理
在上一章介紹完 notepad++ 的設定後，再來看一下 notepad++ 對於區塊的處理有何特殊之處。
撰寫程式的過程中，經常會出現需要區塊選取複製的狀況，也就是直向的選取，而不是選取一整行，快速鍵為 alt+shift+方向鍵，這樣就可以做區塊的選取。
當選取整個區塊後，還可以對這個區塊進行縮排或減少縮排，這也非常方便。尤其是對於 python 這種注重排版的程式語言，有時想要整個區塊都往後再縮一層或者全部往前一層，都是很常見的情況。
選取區塊後，往右內縮一層為 tab 鍵，往左退一層則為 shift+tab 鍵，這樣就不需要一行一行的按了。
補充：
- 在 alt 功能表中 -> 編輯 -> 縮排內有這兩個項目，可以用選的。
- 在 alt 功能表中 -> 編輯 -> 空格處理內有對於空格與 tab 符號的轉換或處理，也相當實用。
- 像是把整個檔案的 tab 符號換成空格，或者空格換成 tab 符號，還可以去除行尾多餘的空格等等，功能很強大且完整。
8-1 前言
字串和其他三種形態不同(整數、浮點數與布林)，它是其他形態的有序集合。
雖然之前已經開始使用字串，但其實還沒有很了解它們的詳細操作。
在本章中，我們將學習操作字串的方法，也可以讓你更了解字串這個資料型態的應用。
8-2 字串是一個序列
什麼是字串？字串就是一串字元，也就是把字元串起來的意思。
字串是一個有序的字元集合，你可以使用 [ ] (中括號) ，一次只取得一個字元：
>>> fruit = 'banana'
>>> letter = fruit[1]
>>> letter
'a'上例第二個敘述中，使用中括號取得 fruit 字串內容的 1 號字元，給 letter 變數。中括號內的數字稱為 index ，也就是索引，這個數字代表有序字串的第幾個字元。但請注意上例的執行結果，你的期望可能與 python 不同：
以非程式角度來看，多數人認為 banana 中的第一個字元是 b 而不是 a。但對電腦科學家不是這樣，因為他們認為字串的第一個字元是從 0 開始編號的，所以：
>>> letter = fruit[0]
>>> letter
'b'第一個字元 b 的 index 是 0 號才對，那 a 當然就是 index = 1 了。
至於 index 索引到底要從 0 還是 1 開始，各有支持的專家，不同的語言也有所不同。至少先記住 python 的 index 是從 0 開始就好，而索引也可以是變數或其他運算式：
>>> i = 1
>>> fruit[i]
'a'
>>> fruit[i+1]
'n'如果是數字的索引，索引的值一定要是整數，否則會發生錯誤。
>>> letter = fruit[1.5]
TypeError: string indices must be integers
>>> i
1順便提醒，雖然我們在中括號裡執行 i + 1 這個算式，但實際上 i 的值沒有被改變，因為並未使用指派運算子重新賦值給 i 這個變數。
所以只能說 i + 1 這個運算式的結果是 2, 但不能說 i = 2，因為 i 還是 1。索引也可以是負整數，這部分在下一節介紹。
8-3 使用 len 函數獲得字串長度
在之前的練習中，我們已經看過這個標準的內建函數 len 了，給它一個字串作為參數，它會回傳一個整數，代表這個字串的長度。
>>> fruit = 'banana'
>>> len(fruit)
6如果想獲得字串的最後一個字母，你可能會這樣做：
>>> length = len(fruit)
>>> last = fruit[length]
IndexError: string index out of range因為 banana 雖然有 6 個字元，但 index 從 0 開始算起，所以最後一個字母的 index 是 5 才對。
上面的錯誤訊息是說，我們的 index 超過範圍，把總長度減掉一就可以了。
>>> last = fruit[length - 1]
>>> last
'a'或者可以直接使用負數的 index 值， -1 代表最後一個字元， -2 代表倒數第二個字元，以此類推。
所以 index 為正，表示從字串左邊開始往右數；反之為負，則是從右邊開始往左數取值。
>>> s = 'string'
>>> s[-1]
'g'8-4 使用 for 迴圈遍歷字串
上一章我們介紹過迭代，這裡來介紹遍歷。
很多字串的運算，都是依序一次只處理字串的一個字元。通常從字串的最左邊開始處理，一次只選擇一個字元做事，接著換下一個字元，然後再做同樣的事情。
以上不斷地循環，直到整個字串的結束，這個過程就稱為 遍歷。要操作遍歷的其中一種方法是使用 while 迴圈，我們的範例是一次印一個字母，直到全部印完：
index = 0
while index < len(fruit):
letter = fruit[index]
print(letter)
index = index + 1這個遍歷的範例是每一行印出 fruit 字串中的一個字元，直到整個字串結束。index 從 0 開始，只要小於 fruit 的字串長度就進入迴圈，每次在迴圈末尾累加 index 的值並更新它。
而當 index 的值等於 fruit 的字串長度時，條件為 False，不再進入迴圈(小於才能讓條件為真)。
剛才我們已經向各位說明，如果 fruit 的長度是 6 ，那麼它最後一個字元的 index 其實是 5, 因此上例並沒有遺漏任何字串中的字元。也就是說，一個字串最後一個字元的 index ，等於該字串的長度減一。
while 迴圈在上一個章節已經介紹過了，這邊我們做了個小小複習而已。另外一個方法是使用 for 迴圈：
for letter in fruit:
print(letter)每次迴圈執行， fruit 字串都會由左而右一次給予變數 letter 一個字元，直到整個字串結束。以程式碼的角度來看，while 在這個應用上比較複雜。
這個例子使用 for 迴圈來撰寫，會顯得簡潔很多。在不同的時機選擇更好的方式，需要長時間練習跟累積，才能獲得經驗。
接下來這個例子，是使用字串連接的方式組合成單字。這些單字的特性是，除了第一個字元外，其他字母都相同，第一個字元從 J 開始到 Q:
範例 8-1
prefixes = 'JKLMNOPQ'
suffix = 'ack'
for letter in prefixes:
print(letter + suffix)它的顯示如下：
Jack
Kack
Lack
Mack
Nack
Oack
Pack
Qack8-5 字串切片
字串的分割稱為字串切片。選擇字串的片段跟選擇字元的方式很類似，只是指定索引範圍。
>>> s = 'Monty Python'
>>> s[0:5]
'Monty'
>>> s[6:12]
'Python'[n:m] 這個運算子，表示從 index n 開始到 index m-1 這一段字串切片，乍看之下有點不直觀，但後來你會漸漸發現，這樣的設計有利於使用 index 的方式來取得字串切片。
另外，也要提醒，m 代表的不是取得的個數，這是很多人一開始容易犯的錯，它代表的是 index m-1 號字元。
省略冒號前面的數字表示從 index 0 開始，省略冒號右邊的數字表示取到最後一個字元為止。
>>> fruit = 'banana'
>>> fruit[:3]
'ban'
>>> fruit[3:]
'ana'如果冒號左邊的 index 大於或等於右邊的 index ，則會返回一個空字串，用一對空引號表示：
>>> fruit = 'banana'
>>> fruit[3:3]
''空字串是一個沒有任何字元且長度為 0 的字串，但其他性質都與一般的字串相同。
想想看，[:] 代表什麼？答案是代表整個字串，不過用索引取到的字串算是複製品，這個等下再來解釋。
使用中括號的 index 來處理字串或之後會提到的「串列(列表)」，最重要的是不要把 index 跟我們平常習慣說的「第幾個」搞混就好。
8-6 字串是不可變的
想要使用 [:] 這種運算子來變更字串的內容，是一個很誘人的想法，像這樣：
>>> greeting = 'Hello, world!'
>>> greeting[0] = 'J'
TypeError: 'str' object does not support item assignment上面的錯誤訊息是說，字串物件不支援等號來賦值。字串是一個物件，而字元是字串物件中的元素，物件則是定值的概念。
例如 a = 26, 26 是一個數值，可以讓 a 加上 30 變成 56 ，也可以將 a 指向別的值，但不能直接將 26 的 2 改成5 ，變成 56 這個數值，因為它是一個不可分割的整體。
字串是一個不可變的整體，不能去改變已經存在的字串。
如果有這個需求，最好的方法是重新建立一個新的字串，而新字串是原本字串的變體。
>>> greeting = 'Hello, world!'
>>> new_greeting = 'J' + greeting[1:]
>>> new_greeting
'Jello, world!'這個例子將字元 'J' 與 greeting 字串切片組合成一個新的字串，並沒有去變更原來的字串。
8-7 搜尋
來看看以下這個函數做了什麼：
範例 8-2
def find(word, letter):
index = 0
while index < len(word):
if word[index] == letter:
return index
index = index + 1
return -1find 函數返回 letter 字元第一次出現在 word 字串的 index 值，若在字串中沒找到該字元，就返回 -1 這個值。這種遍歷整個序列尋找的行為就稱為 搜尋。
再次提醒，return 敘述之後的程式碼不會再被執行，就算是在迴圈內，也會立刻停止程式或函數。
8-8 迴圈與計算次數
底下這個程式計算 a 字母在字串中出現的次數，像這樣的計數程式，也被稱為 計數器：
範例 8-3
word = 'banana'
count = 0
for letter in word:
if letter == 'a':
count = count + 1
print(count)在程式中，將 count 變數的初始值設定為 0，而當字串中出現 a 字母時，就將 count 的值累加一。離開迴圈後，程式結束前將 count 變數印出來，這也就是 'a' 出現的總數。
8-9 字串方法
字串有一些內建的方法，可以讓我們更方便地處理它。方法就像函數，可以擁有參數與回傳值，但使用的語法不同。
如果是函數的呼叫像這樣 upper(word), 而使用方法的語法來呼叫像這樣 word.upper(), 方法的使用範例如下：
>>> word = 'banana'
>>> new_word = word.upper()
>>> new_word
'BANANA'使用 . (小數點) 來調用方法，小數點左邊是字串，右邊是方法的名稱，我們會說調用了 word 字串的 upper 方法。空小括號表示沒有帶入參數。
在 python 中有一個名為 find 的方法，功能就像剛剛我們撰寫的同名函數那樣，以下是調用這個方法的範例：
>>> word = 'banana'
>>> index = word.find('a')
>>> index
1事實上， find 這個方法功能比之前我們自己寫的函數強，它可以搜尋字串，而不僅僅只是字元。
>>> word.find('na')
2按照預設值，find 方法會從字串的第一個字元開始查找，你可以加入第二個參數，讓它從我們指定的 index 開始搜尋：
>>> word.find('na', 3)
4雖然指定了從 index 3 開始找，但無論如何，index的值是絕對的，不會因為我們從哪個 index 開始找而有所不同。如果指定的 index 比原本要找的字串還後面，就會發生找不到的情形。
像 find 的第二個參數，這種非必要的參數稱為 可選參數。事實上，它還有第二個可選參數，也就是可以指定結束搜尋的範圍值。
>>> name = 'ben'
>>> name.find('b', 1, 2)
-1搜尋失敗的原因是指定的範圍不存在 b 這個字母，思考一下上面的運算子 [n:m] 就可以了解。
因為 index 從 1 開始是 e ，而結束的地方是 2-1 ，也就是 index = 1, 因此找不到 b 這個字母，這與字串切片運算完全一致。
關於方法的介紹，會在之後的類別章節再詳述。
8-10 in 運算子
in 這個布林運算子的左、右運算元皆為字串，如果右邊的字串包含左邊的字串就回傳 True ，否則回傳 False，所以 in 運算子也可以拿來搜尋字串，通常用於確認搜尋結果，如下：
>>> 'a' in 'banana'
True
>>> 'seed' in 'banana'
False下面這個範例遍歷了 word1 的每個字元，並判斷，如果字元也出現在 word2 中，就以一行一個的方式印出來。
def inBoth(word1, word2):
for letter in word1:
if letter in word2:
print(letter)在 for 中的 in 與 if 中的 in 是不同的， for 裡的是語法，而 if 裡的是運算子。
python 有時直接使用英文的語法理解或閱讀，對於了解其程式碼意義很有幫助。比較精通英文文法的人可以試看看，尤其變數名稱使用正確，就更明顯了，我們可以這樣讀上面的例子：
「對於 (每個) 在 (第一個) 字中的字母，如果 (該) 字母 (出現) 在 (第二個) 字中，則印出 (該) 字母」。
接下來是以上面的函數帶入 apples 與 orange 的範例：
>>> inBoth('apples', 'oranges')
a
e
s8-11 字串比較
相關的比較運算子也可以在字串上運作，例如 == 比較運算子：
if word == 'banana':
print('太棒了！相等')其他的比較運算子，對於字母順序前後關係的比較很有用：
if word < 'banana':
print('這個字 ' + word + ' 小於 banana')
elif word > 'banana':
print('這個字 ' + word + ' 大於 banana')
else:
print('太棒了！相等')python 不像人們認知的大、小寫方式處理它們，對 python 來說，大寫永遠在小寫的順序之前，所以：
'Pineapple' 這個字的順序會被認定在 'banana' 之前。順序的原理是 ascii 碼，簡單地說，就是每個字元在電腦中都有一個編碼，編碼愈前面的，順序就越前面。比較好的解決方案，是在比較前先把字串轉成同一種格式，像是全大寫或全小寫，再來比較。
另外，也要提一下，使用小於和大於的符號做字串比較的原理，之後的章節會詳述，這邊先簡單列舉：
- 兩個字串比較，同樣 index 的字元相比，只要 False 就停止
- 兩個字串比較，如果一直是 True ，會以後面的字串長度為長度來比
最後提醒一下，範例中 word 是一個變數，需要有初始值程式才能運作，例如使用 input 函數讓使用者輸入。
除錯
當你使用 index 遍歷序列時，有時想要正確地指定開始與結束點，可能會是一個困難。
下面這個函數比較兩個字串，如果這兩個字串互為顛倒，就回傳 True，但是它包含了兩個錯誤：
def isReverse(word1, word2):
if len(word1) != len(word2):
return False
i = 0
j = len(word2)
while j > 0:
if word1[i] != word2[j]:
return False
i = i+1
j = j-1
return True第一個判斷式，先比較兩個字串的長度，如果不同就回傳 False。
因此，接下來在函數中執行的過程，我們都可以假設這兩個字串的長度是相等的。
i 和 j 都是 index, i 是 word1 的索引，方向是往右遞增；j 是 word2 的索引，方向是往左遞減。
一次比較一個字元，如果兩個字串的字元不同時，則回傳 False。
假如完成了整個迴圈，就表示這兩個字串符合顛倒的規則，並且回傳 True。
現在，使用 'pots' 與 'stop' 兩個字串來測試這個函數，理論上應該得到 True, 然而卻得到一個 IndexError 錯誤：
>>> isReverse('pots', 'stop')
...
File "reverse.py", line 15, in isReverse
if word1[i] != word2[j]:
IndexError: string index out of range錯誤訊息說我們的 index 超出範圍，為了抓出錯誤，可以在錯誤行出現前，印出 index 來觀察看看，所以加了第 4 行：
...
i = 0
j = len(word2)
while j > 0:
print(i, j) # 在這裡印出 i 與 j 的值來觀察
if word1[i] != word2[j]:
return False
i = i+1
j = j-1
...現在再一次執行程式，這將讓我們得到更多的資訊，以釐清問題：
>>> isReverse('pots', 'stop')
0 4
...
IndexError: string index out of range檢查錯誤的方法，就是每一圈 while 都印出兩個 index 的值來觀察。
第一圈 while ，我們發現 j 是 4,但 stop 的最後一個字母的 index 應該是 3 才對。所以取得字串長度後，應該減一才能當作最後一個字母的 index 值。
我們修正了第一個錯誤，再執行一次看看：
>>> isReverse('pots', 'stop')
0 3
1 2
2 1
True這次我們得到了正確答案 True, 但看起來迴圈只跑了 3 次，這有點令人疑惑。
如果每一個字元都要比對到，那應該要進行 4 圈。從上面印出的 i 與 j 可以發現，當 i 是 3 而 j 是 0 的情況下，迴圈並沒有進入。
從 while 迴圈的條件可以先排除 i 的問題，因為它並沒有被拿來當作進入迴圈的條件，所以凶手不是 i。
當 j 遞減至 0 時， 0 等於 0 ，也就是 0 不會大於 0 ，所以進入迴圈的條件為 False,因此也就少跑了最後一圈。
我們將迴圈的進入條件改成 j >= 0 ，也就是當 j 是負數，才不會進入迴圈，解決了第二個問題。
請自行完成這個完整版的函數，並再次測試，以確保完全沒有問題。
動動腦
- 寫一個函數 reverse, 將字串倒過來顯示，一行一個字元，並寫一個程式來驗證它。
版本 (1)
def reverse(s):
length = len(s) - 1
for i in range(length, -1, -1):
print(s[i])
str = input('請輸入字串：')
reverse(str)版本 (2)
def reverse(s):
for i in s[::-1]:
print(i)
str = input('請輸入字串：')
reverse(str)- 上面的 範例 8-1 中，如果 oack 與 qack 是拼字錯誤，應該顯示 ouack 與 quack ，那怎麼改寫這個程式？
prefixes = 'JKLMNOPQ'
suffix = 'ack'
new_suffix = 'uck'
for letter in prefixes:
if letter == 'O' or letter == 'Q':
print(letter + new_suffix)
else:
print(letter + suffix)- 參考 範例 8-2 改寫 find 函數，接受第三個參數，目的是讓搜尋的動作從該參數指定的起始位置開始進行。
def find(word, letter, n):
index = n - 1
while index < len(word):
if word[index] == letter:
return index
index = index + 1
return -1
print(find('banana', 'a', 5))- 參考 範例 8-3 改寫計算 a 字母次數的程式，將這個功能封裝在一個名為 count 的函數當中。函數接受兩個參數，一個是字串，一個是字元。
def count(w, l):
count = 0
for i in w:
if i == l:
count = count + 1
print(count)
word = 'banana'
letter = 'a'
count(word, letter)- 將上個練習的函數改成如同第 3 題那樣，有三個參數的版本。
def count(w, l, n):
count = 0
for i in range(n - 1, len(w)):
if w[i] == l:
count = count + 1
print(count)
word = 'banana'
letter = 'a'
count(word, letter, 3)- 將 除錯 章節中的函數改成正確的版本，並使用 abc 與 cba, 今天心情很好 與 好很情心天今 來測試它。
def isReverse(word1, word2):
if len(word1) != len(word2):
return False
i = 0
j = len(word2) - 1
while j >= 0:
if word1[i] != word2[j]:
return False
i = i+1
j = j-1
return True
s = '今天心情很好'
t = '好很情心天今'
print(isReverse(s, t))練習
第1題 檔名 8-1.py
閱讀這份文件中的 [String Methods][https://docs.python.org/3/library/stdtypes.html#string-methods] 部分，看看你能不能夠找到一些有用的方法。其中，strip 和 replace 這兩個方法很實用。
也確認一下裡面說明語法的部分是否看得懂。例如 str.find(sub[, start[, end]]) 代表什麼？
find 是一個字串方法，必要的參數是 sub ，而 [ ] 代表可選參數。
可選參數有 start 與 end ，排序第二的參數是 start。 如果有 start, 也不一定要有 end 參數。
寫一支程式來調用 strip 與 replace 這兩個方法，以確認你看得懂它的說明，也可以自己搜尋其他相關的資料來閱讀。
第2題 檔名 8-2.py
有一個字串方法名為 count, 它的功能類似 8-8 迴圈與計算次數 的同名函數。
請查詢這個方法應該怎麼使用，寫一支程式調用它來計算 a 字母出現在 banana 字串中的次數。
第3題 檔名 8-3.py
其實字串切片還可以有第三個參數，表示取得字元的 間距，直接看範例：
>>> fruit = 'banana'
>>> fruit[0:5:2]
'bnn'如果第三個 index 是 -1 ，就表示字串切片的內容會反轉顯示。
寫一個函數名為 isPalindrome ，功能是判斷該字串參數是不是一個 迴文。
先歸納與觀察一下迴文的規則，再思考函數應該怎麼寫。
(迴文是一種修辭方式，正讀或反讀讀出的語句皆能通順，甚至內容相同，也可以發展成文字遊戲。除了矩陣，亦能將文字排列成圓圈狀)
例如：上海自來水來自海上，或者英文的 noon, redivider 等，本題用字或句子必須是有意義且完全相同才行。
第4題 檔名 8-4.py
以下有幾個函數，它們的功能都是判斷一個字串是否為全部小寫。但有一些函數可能存在瑕疵，請對每個函數加以說明。
(假設傳入每個函數的參數都是一個字串)
(1)
def any_lowercase1(s):
for c in s:
if c.islower():
return True
else:
return False(2)
def any_lowercase2(s):
for c in s:
if 'c'.islower():
return 'True'
else:
return 'False'(3)
def any_lowercase3(s):
for c in s:
flag = c.islower()
return flag(4)
def any_lowercase4(s):
flag = False
for c in s:
flag = flag or c.islower()
return flag(5)
def any_lowercase5(s):
for c in s:
if not c.islower():
return False
return True如果覺得它們都有瑕疵，那請寫出一個正確的版本吧。
第5題 檔名 8-5.py
有一種編碼方式叫作 凱薩密碼 (Caesar cypher)，這是一種古老的加密字母方式。
方法是將所有字母以指定數字順向或逆向旋轉，旋轉的數字就是解開加密的鑰匙，在這裡我們先把它稱為 key 好了。
例如 d 這個字母，如果 key 是 3 ，它就被加密為 g； 如果 key 是 -2 ，它就被加密為 b。
加密的過程是循環式的，例如字母 y 的 key是 4 ，就加密成 c； 字母 b 的 key 是 -2 ，就加密成 z。
通常加密是針對一整串的字，甚至整句或整篇文章，像 hal 就是 ibm 的 key 為 -1 來進行加密的結果。
請寫一個函數名為 rotateWord ，接受兩個參數，第一個是原來的字串，第二個是整數(正負) key,
功能就是進行上述的 凱薩密碼 加密動作，所以必須回傳加密過後的字串。
有兩個系統內建函數也許用得上：
- ord 接受一個字元並返回其 unicode 編碼，對字母來說 unicode 編碼就等於 ascii 碼。
- chr 與上述 ord 相反，接受一個 unicode 編碼，並返回該編碼所代表的字元。
因為字母的編碼是連續的，所以我們可以這樣使用：
>>> ord('c') - ord('a')
2需要注意的是大小寫的編碼不同，也可以觀察一下標點符號或空格的加密。
參考資料
影片
最後更新：2021-10-08 21:19:16
From： 111.249.165.250
By： 特種兵
