【20天搞定Python基礎】一文清晰掌握Python字串

Python中的字串

字串的意思就是“一串字元”，比如 “Hello world” 是一個字串， “How are you？” 也是一個字串。

Python 要求字串必須使用引號括起來，使用單引號也行，使用雙引號也行，只要兩邊的引號能配對即可。

字串引號裡面的的每個基本單元叫做字元，比如字串 “abc” 中， “a” 、 “b” 和 “c” 就是字串組成的基本單元，它們都是字元。

如下定義的變數，儲存的是字串型別的值

a = “I‘m Bob” # 一對雙引號

b = ’I am Bob‘ # 一對單引號

c = ’He said：I\‘m Bob’ # 跳脫字元

d = ‘’‘I’m Bob‘’‘ # 三個單引號

e = “”“I’m Bob ”“” # 三個雙引號

小總結：

雙引號或者單引號中的資料，就是字串

如果使用一對引號來定義字串，當出現符號衝突時可以使用跳脫字元，比如變數c

使用三個單引號或者三個雙引號定義的字串可以包裹任意文字

字串的運算

Python為字串型別提供了非常豐富的運算子，我們可以使用 + 運算子來實現字串的拼接，可以使用 * 運算子來重複一個字串的內容，可以使用 in 和 not in 來判斷一個字串是否包含另外一個字串，我們也可以用 ［］ 和 ［：］ 運算子從字串取出某個字元或某些字元。

拼接和重複

下面的例子演示了使用 + 和 * 運算子來實現字串的拼接和重複操作。

s1 = ‘hello’ + ‘ ’ + ‘world’

print（s1） # 結果：hello world

s2 = ‘！’ * 3

print（s2） # 結果：！！！

s1 += s2 # s1 = s1 + s2

print（s1） # 結果：hello world！！！

s1 *= 2 # s1 = s1 * 2

print（s1） # 結果：hello world！！！hello world！！！

用 * 實現字串的重複是非常有意思的一個運算子，在很多程式語言中，要表示一個有10個 a 的字串，你只能寫成 “aaaaaaaaaa” ，但是在Python中，你可以寫成 ‘a’ * 10 。你可能覺得 “aaaaaaaaaa” 這種寫法也沒有什麼不方便的，那麼想一想，如果字元 a 要重複100次或者1000次又會如何呢？

比較運算

對於兩個字串型別的變數，可以直接使用比較運算子比較兩個字串的相等性或大小。

需要說明的是，因為字串在計算機記憶體中也是以二進位制形式存在的，那麼字串的比較其實比的是：每個字元對應的編碼的大小。

例如 A 的編碼是 65 ， 而 a 的編碼是 97 ，所以 ‘A’ < ‘a’ 的結果相當於就是 65 < 97 的結果，很顯然是 True ；

而 ‘boy’ < ‘bad’，因為第一個字元都是 ‘b’比不出大小，所以實際比較的是第二個字元的大小，顯然 ‘o’ < ‘a’ 的結果是 False ，所以 ‘boy’ < ‘bad’ 的結果也是 False 。

如果不清楚兩個字元對應的編碼到底是多少，可以使用 ord 函式來獲得，例如 ord（‘A’） 的值是 65 ，而 ord（‘趙’） 的值是 36213 。

下面的程式碼為大家展示了字串的比較運算。

s1 = ‘a whole new world’

s2 = ‘hello world’

print（s1 == s2） # False

print（s1 < s2） # True

print（s2 == ‘hello world’） # True

print（s2 == ‘Hello world’） # False

print（s2 ！= ‘Hello world’） # True

s3 = ‘趙四’

print（ord（‘趙’）， ord（‘四’）） # 36213 22235

s4 = ‘王大拿’

print（ord（‘王’）， ord（‘大’）， ord（‘拿’）） # 29579 22823 25343

print（s3 > s4， s3 <= s4） # True False

需要強調一下的是，字串的比較運算比較的是字串的內容，Python中還有一個 is 運算子（身份運算子），如果用 is 來比較兩個字串，它比較的是兩個變數對應的字串是否在記憶體中相同的位置（記憶體地址），簡單的說就是兩個變數是否對應記憶體中的同一個字串。看看下面的程式碼就比較清楚 nis 運算子的作用了。

s1 = ‘hello world’

s2 = ‘hello world1’

s3 = s2

# 比較字串的內容

print（s1 == s2， s2 == s3） # False True

# 比較字串的記憶體地址

print（s1 is s2， s2 is s3） # False True

總結：s1==s2 比較的是字串裡面的內容，只要內容相同結果就是True，不同就是False；而s1 is s2則比較的是記憶體地址，兩者記憶體是不一樣的所以False。

成員運算

Python中可以用 in 和 not in 判斷一個字串中是否存在另外一個字元或字串， in 和 not in 運算通常稱為成員運算，會產生布爾值 True 或 False ，程式碼如下所示。

s1 = ‘hello， world’

print（‘he’ in s1） # True

s2 = ‘goodbye’

print（s2 in s1） # False

獲取字串長度

獲取字串長度沒有直接的運算子，而是使用內建函式

len

，我們在上節課的提到過這個內建函式，程式碼如下所示。

索引與切片

字串中的每個字元都有表示位置的下標值，下標範圍從左往右從0開始依次增加或者從右往左從-1開始依次減少。

比如我們有字串“soldier”，現在它的下標怎麼命名的？

如果希望從字串中取出某個字元，我們可以對字串進行索引運算，運算子是［n］ ，其中 n 是一個整數，假設字串的長度為 N ，那麼 n 可以是從 0 到 N-1 的整數，其中 0 是字串中第一個字元的索引，而 N-1 是字串中最後一個字元的索引，通常稱之為正向索引；

在Python中，字串的索引也可以是從 -1 到 -N 的整數，其中 -1 是最後一個字元的索引，而 -N 則是第一個字元的索引，通常稱之為負向索引。注意，因為

字串是不可變型別

，所以

不能透過索引運算修改字串中的字元

。

s = ‘abc123456’

n = len（s）

# 獲取第一個字元

print（s［0］， s［-n］） # a a

# 獲取最後一個字元

print（s［n-1］， s［-1］） # 6 6

# 獲取索引為2或-7的字元

print（s［2］， s［-7］） # c c

# 獲取索引為5和-4的字元

print（s［5］， s［-4］） # 3 3

需要提醒大家注意的是，在進行索引操作時，如果索引越界（正向索引不在0 到 N-1 範圍，負向索引不在 -1 到 -N 範圍），會引發 IndexError 異常，錯誤提示資訊為：string index out of range（字串索引超出範圍）。

如果要從字串中取出多個字元，我們可以對字串進行切片，運算子是 ［i：j：k］ ，其中 i 是開始索引，索引對應的字元可以取到； j 是結束索引，索引對應的字元不能取到； k 是步長，預設值為 1 ，表示從前向後獲取相鄰字元的連續切片，所以 ：k 部分可以省略。

假設字串的長度為 N ，當 k > 0 時表示正向切片（從前向後獲取字元），如果沒有給出 i 和 j 的值，則 i 的預設值是 0 ， j 的預設值是 N ；當 k < 0 時表示負向切片（從後向前獲取字元），如果沒有給出 i 和 j 的值，則 i 的預設值是 -1 ，j的預設值是 -N - 1 。如果不理解，直接看下面的例子，記住第一個字元的索引是 0 或 -N ，最後一個字元的索引是 N-1 或 -1 就行了。

s = ‘abc123456’

# i=2， j=5， k=1的正向切片操作

print（s［2：5］） # c12

# i=-7， j=-4， k=1的正向切片操作

print（s［-7：-4］） # c12

# i=2， j=9， k=1的正向切片操作

print（s［2：］） # c123456

# i=2， j=9， k=2的正向切片操作

print（s［2：：2］） # c246

# i=0， j=9， k=2的正向切片操作

print（s［：：2］） # ac246

# i=1， j=-1， k=2的正向切片操作

print（s［1：-1：2］） # b135

# i=7， j=1， k=-1的負向切片操作

print（s［7：1：-1］） # 54321c

# i=-2， j=-8， k=-1的負向切片操作

print（s［-2：-8：-1］） # 54321c

# i=7， j=-10， k=-1的負向切片操作

print（s［7：：-1］） # 54321cba

# i=-1， j=1， k=-1的負向切片操作

print（s［：1：-1］） # 654321c

# i=0， j=9， k=1的正向切片

print（s［：］） # abc123456

迴圈遍歷

如果希望從字串中取出每個字元，可以使用 for 迴圈對字串進行遍歷，有兩種方式。

方式一：

s1 = ‘hello’

for index in range（len（s1））：

print（s1［index］）

方式二：

s1 = ‘hello’

for ch in s1：

print（ch）

字串的方法

在Python中，我們可以透過字串型別自帶的方法對字串進行操作和處理，對於一個字串型別的變數，我們可以用 變數名。方法名（） 的方式來呼叫它的方法。所謂方法其實就是跟某個型別的變數繫結的函式，後面我們講面向物件程式設計的時候還會對這一概念詳加說明。

大小寫相關操作

下面的程式碼演示了和字串大小寫變換相關的方法。

capitalize（）： 字串首字母大寫

title（）： 字串中每個單詞首字母大寫

upper（）： 字串全部大寫

lower（）： 字串全部小寫

s1 = ‘hello， world！’

# 使用capitalize方法獲得字串首字母大寫後的字串

print（s1。capitalize（）） # Hello， world！

# 使用title方法獲得字串每個單詞首字母大寫後的字串

print（s1。title（）） # Hello， World！

# 使用upper方法獲得字串大寫後的字串

print（s1。upper（）） # HELLO， WORLD！

s2 = ‘GOODBYE’

# 使用lower方法獲得字串小寫後的字串

print（s2。lower（）） # goodbye

查詢操作

如果想在一個字串中從前向後查詢有沒有另外一個字串，可以使用字串的 find 或 index 方法。

find（）： 從字串中查詢另一個字串（引數）所在的位置，如果存在則返回匹配的字串的首字母下標，沒有找到則返回-1

index（）： 與find方法類似，如果找不到則會引發異常。

s = ‘hello， world！’

# find方法從字串中查詢另一個字串所在的位置

# 找到了返回字串中另一個字串首字元的索引

print（s。find（‘or’）） # 8

# 找不到返回-1

print（s。find（‘good’）） # -1

# index方法與find方法類似

# 找到了返回字串中另一個字串首字元的索引

print（s。index（‘or’）） # 8

# 找不到引發異常

print（s。index（‘good’）） # ValueError： substring not found

在使用 find 和 index 方法時還可以透過方法的引數來指定查詢的範圍，也就是查詢不必從索引為 0 的位置開始。 find 和 index 方法還有逆向查詢（從後向前查詢）的版本，分別是 rfind 和 rindex ，

rfind（）： “r”表示的是right右側，表示從右側開始查詢字串，沒有找到返回-1

rindex（）： 與rfind方法類似，如果找不到則會引發異常。

程式碼如下所示。

s = ‘hello good world！’

# 從前向後查詢字元o出現的位置（相當於第一次出現）

print（s。find（‘o’）） # 4

# 從索引為5的位置開始查詢字元o出現的位置

print（s。find（‘o’， 5）） # 7

# 從後向前查詢字元o出現的位置（相當於最後一次出現）

print（s。rfind（‘o’）） # 12

判斷

可以透過字串的 startswith 、 endswith 來判斷字串是否以某個字串開頭和結尾；還可以用 is 開頭的方法判斷字串的特徵，這些方法都返回布林值，

startswith（）：判斷字串是否以指定的字串開頭，返回布林值結果

endswith（）：判斷字串是否以指定的字串結尾，返回布林值結果

isdigit（）：判斷字串是否由數字構成，返回布林值結果

isalpha（）：判斷字串是否以字母構成，返回布林值結果

isalnum（）：判斷字串是否以數字和字母構成，返回布林值結果

程式碼如下所示。

s1 = ‘hello， world！’

# startwith方法檢查字串是否以指定的字串開頭返回布林值

print（s1。startswith（‘He’）） # False

print（s1。startswith（‘hel’）） # True

# endswith方法檢查字串是否以指定的字串結尾返回布林值

print（s1。endswith（‘！’）） # True

s2 = ‘abc123456’

# isdigit方法檢查字串是否由數字構成返回布林值

print（s2。isdigit（）） # False

# isalpha方法檢查字串是否以字母構成返回布林值

print（s2。isalpha（）） # False

# isalnum方法檢查字串是否以數字和字母構成返回布林值

print（s2。isalnum（）） # True

去除空格

字串的 strip 方法可以幫我們獲得將原字串修剪掉左右兩端空格之後的字串。這個方法非常有實用價值，通常用來將使用者輸入中因為不小心鍵入的頭尾空格去掉， strip 方法還有 lstrip 和 rstrip 兩個版本，相信從名字大家已經猜出來這兩個方法是做什麼用的。

s = ‘ helloworld@126。com \t\r\n’

# strip方法獲得字串修剪左右兩側空格之後的字串

print（s。strip（）） # helloworld@126。com

格式化字串

在Python中，字串型別可以透過 center 、 ljust 、 rjust 方法做居中、左對齊和右對齊的處理。

s = ‘hello， world’

# center方法以寬度20將字串居中並在兩側填充*

print（s。center（20， ‘*’）） # ****hello， world****

# rjust方法以寬度20將字串右對齊並在左側填充空格

print（s。rjust（20）） # hello， world

# ljust方法以寬度20將字串左對齊並在右側填充~

print（s。ljust（20， ‘~’）） # hello， world~~~~~~~~

我們之前講過，在用 print 函式輸出字串時，可以用下面的方式對字串進行格式化。

a = 321

b = 123

print（‘%d * %d = %d’ % （a， b， a * b））

當然，我們也可以用字串的方法來完成字串的格式，程式碼如下所示。

a = 321

b = 123

print（‘{0} * {1} = {2}’。format（a， b， a * b））

從Python 3。6開始，格式化字串還有更為簡潔的書寫方式，就是在字串前加上 f 來格式化字串，在這種以 f 打頭的字串中， {變數名} 是一個佔位符，會被變數對應的值將其替換掉，程式碼如下所示。

a = 321

b = 123

print（f‘{a} * {b} = {a * b}’）

如果需要進一步控制格式化語法中變數值的形式，可以參照下面的表格來進行字串格式化操作。

其他方法

除了上面講到的方法外，字串型別還有很多方法，如拆分、合併、編碼、解碼等，這些方法等我們用到的時候再為大家進行續點講解。

對於字串型別來說，還有一個常用的操作是對字串進行匹配檢查，即檢查字串是否滿足某種特定的模式。

例如，一個網站對使用者註冊資訊中使用者名稱和郵箱的檢查，就屬於模式匹配檢查。

實現模式匹配檢查的工具叫做正則表示式，Python語言透過標準庫中的 re 模組提供了對正則表示式的支援，我們會在後續的文章中為大家講解這個知識點。