Python 字符串 · ZetCode 中文系列教程

# Python 字符串 > 原文： [http://zetcode.com/lang/python/strings/](http://zetcode.com/lang/python/strings/) 在 Python 編程教程的這一部分中，我們將更詳細地處理字符串數據。 ## Python 字符串定義 Python 中的字符串是字符序列。它是派生的數據類型。字符串是不可變的。這意味著一旦定義，就無法更改。許多 Python 方法，例如`replace()`，`join()`或`split()`都會修改字符串。但是，它們不會修改原始字符串。他們創建一個字符串副本，然后對其進行修改并返回給調用者。 ## Python 字符串字面值可以使用單引號，雙引號或三引號創建 Python 字符串。當我們使用三引號時，字符串可以跨越多行而無需使用轉義符。 `string_literals.py` ```py #!/usr/bin/env python # string_literals.py a = "proximity alert" b = 'evacuation' c = """ requiem for a tower """ print(a) print(b) print(c) ``` 在我們的示例中，我們為`a`，`b`和`c`變量分配了三個字符串字面值。然后將它們打印到控制臺。 ```py $ ./string_literals.py proximity alert evacuation requiem for a tower ``` ## Python 中的 Unicode 如果要創建 Unicode 字符串，請在文本開頭添加`u`或`U`字符。 `unicode.py` ```py #!/usr/bin/env python # unicode.py text = u'\u041b\u0435\u0432 \u041d\u0438\u043a\u043e\u043b\u0430\ \u0435\u0432\u0438\u0447 \u0422\u043e\u043b\u0441\u0442\u043e\u0439: \n\ \u0410\u043d\u043d\u0430 \u041a\u0430\u0440\u0435\u043d\u0438\u043d\u0430' print(text) ``` 在我們的示例中，我們在西里爾字母中打??印了托爾斯泰：《安娜·卡列尼娜》。 ```py $ ./unicode.py Лев Николаевич Толстой: Анна Каренина ``` 如果我們使用編碼注釋，則可以直接使用俄語字母。 `unicode2.py` ```py #!/usr/bin/python # -*- coding: utf-8 -*- # unicode2.py text = 'Лев Николаевич Толстой: Анна Каренина' print(text) ``` 在此示例中，我們直接在源代碼中使用非拉丁字符。我們定義了帶有編碼注釋的 UTF-8 編碼。 ## 在 Python 中使用引號 Python 中的字符串由單引號或雙引號字符分隔。如果我們想顯示報價，例如直接講話怎么辦？有兩種基本方法可以做到這一點。 `quotes.py` ```py #!/usr/bin/env python # quotes.py print("There are many stars.") print("He said, \"Which one is your favourite?\"") print('There are many stars.') print('He said, "Which one is your favourite?"') ``` 我們使用`\`字符轉義其他引號。通常，雙引號用于分隔字符串字面值。但是，當轉義時，其原始含義被抑制。它顯示為普通字符，可以在字符串字面值中使用。在引號中使用引號的第二種方法是混合單引號和雙引號。 ```py $ ./quotes.py There are many stars. He said, "Which one is your favourite?" There are many stars. He said, "Which one is your favourite?" ``` 這是輸出。 ## Python 字符串長度 `len()`方法計算字符串中的字符數。空白字符也算在內。 `string_length.py` ```py #!/usr/bin/env python # string_length.py s1 = "Eagle" s2 = "Eagle\n" s3 = "Eagle " print(len(s1)) print(len(s2)) print(len(s3)) ``` 我們計算三個字符串的長度。 ```py s1 = "Eagle" s2 = "Eagle\n" s3 = "Eagle " ``` 定義了三個字符串。第二個字符串的末尾有換行符。第三個有兩個額外的空格字符。 ```py print(len(s1)) ``` 我們將字符數打印到控制臺。 ```py $ ./length.py 5 6 7 ``` 從輸出中我們可以看到，空格（在本例中為換行符和空格符）也被計算在內。 ## Python 字符串剝離空白字符在字符串處理中，我們通常可能會以在字符串開頭或結尾處帶有空白字符的字符串結尾。術語空白（字符）是指不可見的字符，例如換行符，制表符，空格或其他控制字符。我們有`strip()`，`lstrip()`和`rstrip()`方法來刪除這些字符。 `stripping.py` ```py #!/usr/bin/env python # strippig.py s = " Eagle " s2 = s.rstrip() s3 = s.lstrip() s4 = s.strip() print('{0} {1}'.format(s, len(s))) print('{0} {1}'.format(s2, len(s2))) print('{0} {1}'.format(s3, len(s3))) print('{0} {1}'.format(s4, len(s4))) ``` 我們對具有三個空格的字符串單詞應用剝離方法。開頭一個空格，結尾兩個空格。請注意，這些方法會刪除任意數量的空格，而不僅僅是一個空格。 ```py s2 = s.rstrip() ``` `rstrip()`方法返回一個字符串，其中刪除了結尾的空白字符。 ```py s3 = s.lstrip() ``` `lstrip()`方法返回一個字符串，其中刪除了前導空格字符。 ```py s4 = s.strip() ``` `strip()`方法返回字符串的副本，其中刪除了前導和尾隨字符。 ```py print('{0} {1}'.format(s2, len(s2))) ``` `format()`方法用于動態構建字符串。 `{0}`是引用`format()`方法第一個參數的控制字符。 `{1}`是指第二個參數。 ```py $ ./stripping.py Eagle 8 Eagle 6 Eagle 7 Eagle 5 ``` 這是`stripping.py`示例的輸出。 ## Python 字符串轉義序列在處理字符串時，可以使用轉義序列。轉義序列是特殊字符，在字符串中使用時具有特定目的。 ```py print(" bbb\raaa") # prints aaabbb ``` 回車`\r`是行尾到行首的控制字符。 `strophe.py` ```py #!/usr/bin/env python # strophe.py print("Incompatible, it don't matter though\n'cos someone's bound to hear my cry") print("Speak out if you do\nYou're not easy to find") ``` 新行是控制字符，它開始新的一行文本。 ```py $ ./strophe.py Incompatible, it don't matter though 'cos someone's bound to hear my cry Speak out if you do You're not easy to find ``` 接下來，我們檢查退格控制字符。 ```py print("Python\b\b\booo") # prints Pytooo ``` 退格控制字符`\b`將光標向后移動一個字符。在本例中，我們使用三個退格字符刪除三個字母，并用三個`o`字符替換它們。 ```py print("Towering\tinferno") # prints Towering inferno ``` 水平選項卡在文本之間放置一個空格。 ```py "Johnie's dog" 'Johnie\'s dog' ``` 單引號和雙引號可以嵌套。或者，如果僅使用單引號，則可以使用反斜杠來轉義單引號的默認含義。如果我們在字符串前面加上`r`，則會得到原始字符串。轉義序列不被解釋。 `raw.py` ```py #!/usr/bin/env python # raw.py print(r"Another world\n") ``` ```py $ ./raw.py Another world\n ``` 我們得到的字符串包括換行符。 ## Python 比較字符串比較字符串是編程中的常見工作。我們可以使用`==`運算符比較兩個字符串。我們可以用非等式`!=`運算符檢查相反的情況。運算符返回布爾`True`或`False`。 `comparing.py` ```py #!/usr/bin/env python # comparing.py print("12" == "12") print("17" == "9") print("aa" == "ab") print("abc" != "bce") print("efg" != "efg") ``` 在此代碼示例中，我們比較了一些字符串。 ```py print("12" == "12") ``` 這兩個字符串相等，因此該行返回`True`。 ```py print("aa" == "ab") ``` 兩個字符串的前兩個字符相等。接下來比較以下字符。它們不同，因此該行返回`False`。 ```py print("abc" != "bce") ``` 由于兩個字符串不同，因此該行返回`True`。 ```py $ ./comparing.py True False False True False ``` 這是輸出。 ## Python 訪問字符串元素可以在 Python 中訪問字符串元素。 `string_elements.py` ```py #!/usr/bin/env python # string_elements.py s = "Eagle" print(s[0]) print(s[4]) print(s[-1]) print(s[-2]) print("****************") print(s[0:4]) print(s[1:3]) print(s[:]) ``` 索引操作用于獲取字符串的元素。 ```py print(s[0]) print(s[4]) ``` 第一行打印第一個字符。第二行打印第五個字符。索引從零開始。 ```py print(s[-1]) print(s[-2]) ``` 當索引為負數時，我們從字符串的末尾檢索元素。在這種情況下，我們將打印最后一個字符和最后一個字符。 ```py print(s[0:4]) ``` 也可以訪問字符范圍。該行打印從第一個字符開始到第四個字符結束的一系列字符。 ```py print(s[:]) ``` 此行將打印字符串中的所有字符。 ```py $ ./string_elements.py E e e l **************** Eagl ag Eagle ``` 這是輸出。 `for`循環可用于遍歷字符串的所有字符。 `traverse.py` ```py #!/usr/bin/env python # traverse.py s = "ZetCode" for i in s: print(i, " ", end="") ``` 該腳本將給定字符串的所有字符打印到控制臺。 ```py $ ./traverse.py Z e t C o d e ``` 這是輸出。 ## Python 查找子字符串 `find()`，`rfind()`，`index()`和`rindex()`方法用于查找字符串中的子字符串。它們返回第一次出現的子字符串的索引。 `find()`和`index()`方法從字符串的開頭搜索。 `rfind()`和`rindex()`從字符串的末尾開始搜索。 `find()`和`index()`方法之間的區別在于，當找不到子字符串時，前者返回 -1。后者引發`ValueError`異常。 ```py find(str, beg=0, end=len(string)) rfind(str, beg=0, end=len(string)) index(str, beg=0, end=len(string)) rindex(str, beg=0, end=len(string)) ``` `str`是要搜索的子字符串。 `beg`參數是起始索引，默認值為 0。`end`參數是終止索引。默認情況下，它等于字符串的長度。 `substrings.py` ```py #!/usr/bin/env python # substrings.py a = "I saw a wolf in the forest. A lone wolf." print(a.find("wolf")) print(a.find("wolf", 10, 20)) print(a.find("wolf", 15)) print(a.rfind("wolf")) ``` 我們有一個簡單的句子。我們嘗試在句子中找到子字符串的索引。 ```py print(a.find("wolf")) ``` 該行查找句子中子字符串`"wolf"`的第一次出現。打印 8。 ```py print(a.find("wolf", 10, 20)) ``` 該行嘗試查找`"wolf"`子字符串。它從第 10 個字符開始，然后搜索接下來的 20 個字符。在此范圍內沒有這樣的子字符串，因此該行顯示 -1（未找到）。 ```py print(a.find("wolf", 15)) ``` 在這里，我們搜索從第 15 個字符到字符串結尾的子字符串。我們找到子字符串的第二次出現。該行打印 35。 ```py print(a.rfind("wolf")) ``` `rfind()`從末尾查找子字符串。它查找`"wolf"`子字符串的第二次出現。該行打印 35。 ```py $ ./substrings.py 8 -1 35 35 ``` 這是輸出。在第二個示例中，我們將使用`index()`和`rindex()`方法。 `substrings2.py` ```py #!/usr/bin/env python # substrings2.py a = "I saw a wolf in the forest. A lone wolf." print(a.index("wolf")) print(a.rindex("wolf")) try: print(a.rindex("fox")) except ValueError as e: print("Could not find substring") ``` 在示例中，我們使用`index()`和`rindex()`方法搜索子字符串。 ```py print(a.index("wolf")) print(a.rindex("wolf")) ``` 這些行從開頭和結尾開始查找`"wolf"`子字符串的第一個匹配項。 ```py try: print(a.rindex("fox")) except ValueError as e: print("Could not find substring") ``` 當找不到子字符串時，`rindex()`方法引發`ValueError`異常。 ```py $ ./substrings2.py 8 35 Could not find substring ``` 這是示例的輸出。 ## Python 基本字符串操作在下一個示例中，我們將進行字符串乘法和連接。 `add_multiply.py` ```py #!/usr/bin/env python # add_multiply.py print("eagle " * 5) print("eagle " "falcon") print("eagle " + "and " + "falcon") ``` `*`運算符將字符串重復 n 次。在我們的情況下是五次。彼此相鄰的兩個字符串字面值會自動連接在一起。我們還可以使用`+`運算符顯式連接字符串。 ```py $ ./add_multiply.py eagle eagle eagle eagle eagle eagle falcon eagle and falcon ``` 這是`add_multiply.py`腳本的輸出。我們可以使用`len()`函數來計算字符串的長度（以字符為單位）。 `eagle.py` ```py #!/usr/bin/python # eagle.py var = 'eagle' print(var, "has", len(var), "characters") ``` 在示例中，我們計算字符串變量中的字符數。 ```py $ ./eagle.py eagle has 5 characters ``` 一些編程語言允許隱式添加字符串和數字。在 Python 語言中，這是不可能的。我們必須顯式轉換值。 `string_number.py` ```py #!/usr/bin/python # string_number.py print(int("12") + 12) print("There are " + str(22) + " oranges.") print(float('22.33') + 22.55) ``` 我們使用內置的`int()`函數將字符串轉換為整數。并且還有一個內置的`str()`函數將數字轉換為字符串。然后，我們使用`float()`函數將字符串轉換為浮點數。 ## Python 替換字符串 `replace()`方法將字符串中的子字符串替換為其他子字符串。由于 Python 中的字符串是不可變的，因此將使用替換的值構建新的字符串。 ```py replace(old, new [, max]) ``` 默認情況下，`replace()`方法將替換所有出現的子字符串。該方法采用第三個參數，它將替換次數限制為一定數量。 `replacing.py` ```py #!/usr/bin/env python # replacing.py a = "I saw a wolf in the forest. A lonely wolf." b = a.replace("wolf", "fox") print(b) c = a.replace("wolf", "fox", 1) print(c) ``` 我們有一句話用`"fox"`代替`"wolf"`。 ```py b = a.replace("wolf", "fox") ``` 該行將所有出現的`"wolf"`替換為`"fox"`。 ```py c = a.replace("wolf", "fox", 1) ``` 在這里，我們僅替換第一次出現的情況。 ```py $ ./replacing.py I saw a fox in the forest. A lonely fox. I saw a fox in the forest. A lonely wolf. ``` 這是輸出。 ## Python 分割和連接字符串可以使用`split()`或`rsplit()`方法分割字符串。它們返回使用分隔符從字符串中切出的字符串列表。可選的第二個參數是允許的最大分割數。 `splitting.py` ```py #!/usr/bin/env python # splitting.py nums = "1,5,6,8,2,3,1,9" k = nums.split(",") print(k) l = nums.split(",", 5) print(l) m = nums.rsplit(",", 3) print(m) ``` 我們有一個逗號分隔的字符串。我們把繩子切成小段。 ```py k = nums.split(",") ``` 我們使用逗號作為分隔符將字符串分成八個部分。該方法返回八個字符串的列表。 ```py l = nums.split(",", 5) ``` 在這里，我們將字符串分成六個部分。有五個子字符串，其余部分為字符串。 ```py m = nums.rsplit(",", 3) ``` 在這里，我們將字符串分成四個部分。這次拆分是從右側進行的。 ```py $ ./splitting.py ['1', '5', '6', '8', '2', '3', '1', '9'] ['1', '5', '6', '8', '2', '3,1,9'] ['1,5,6,8,2', '3', '1', '9'] ``` 字符串可以與`join()`字符串連接。它返回由作為參數傳遞的字符串連接而成的字符串。元素之間的分隔符是提供此方法的字符串。 `split_join.py` ```py #!/usr/bin/env python # split_join.py nums = "1,5,6,8,2,3,1,9" n = nums.split(",") print(n) m = ':'.join(n) print(m) ``` 首先，我們將字符串拆分為字符串列表。然后，我們將字符串連接到一個字符串中，并用提供的字符分隔元素。 ```py m = ':'.join(n) ``` `join()`方法從字符串列表中創建一個字符串。元素由`:`字符分隔。 ```py $ ./split_join.py ['1', '5', '6', '8', '2', '3', '1', '9'] 1:5:6:8:2:3:1:9 ``` 這是輸出。可以用于分割字符串的另一種方法是`partition()`。它將在第一次出現分隔符時分割字符串，并返回一個三元組，其中包含分隔符之前的部分，分隔符本身以及分隔符之后的部分。 `partition.py` ```py #!/usr/bin/env python # partition.py s = "1 + 2 + 3 = 6" a = s.partition("=") print(a) ``` 在此示例中，我們使用`partition()`方法。 ```py a = s.partition("=") ``` 這會將字符串切成三部分。 `=`字符前的一個，分隔符，分隔符的右邊。 ```py $ ./partition.py ('1 + 2 + 3 ', '=', ' 6') ``` 這是輸出。 ## Python 字符串大小寫 Python 有四種處理字符串大小寫的字符串方法。這些方法返回一個新的修改后的字符串。 `convert_case.py` ```py #!/usr/bin/env python # convert_case.py a = "ZetCode" print(a.upper()) print(a.lower()) print(a.swapcase()) print(a.title()) ``` 我們有一個字符串詞，我們將在上面演示這四種方法。 ```py print(a.upper()) ``` `upper()`方法返回字符串的副本，其中所有字符均轉換為大寫。 ```py print(a.lower()) ``` 在這里，我們以小寫字母獲取字符串的副本。 ```py print(a.swapcase()) ``` `swapcase()`方法交換字母的大小寫。小寫字符將變為大寫，反之亦然。 ```py print(a.title()) ``` `title()`方法返回字符串的副本，其中第一個字符為大寫，其余字符為小寫。 ```py $ ./convert_case.py ZETCODE zetcode zETcODE Zetcode ``` 這是輸出。 ## 對字符串的 Python 操作有幾個有用的內置函數可用于處理字符串。 `letters.py` ```py #!/usr/bin/env python # letters.py sentence = "There are 22 apples" alphas = 0 digits = 0 spaces = 0 for i in sentence: if i.isalpha(): alphas += 1 if i.isdigit(): digits += 1 if i.isspace(): spaces += 1 print("There are", len(sentence), "characters") print("There are", alphas, "alphabetic characters") print("There are", digits, "digits") print("There are", spaces, "spaces") ``` 在我們的示例中，我們有一個字符串句子。我們計算句子中的絕對字符數，字母字符數，數字和空格。為此，我們使用以下函數：`len()`，`isalpha()`，`isdigit()`和`isspace()`。 ```py $ ./letters.py There are 19 characters There are 14 alphabetic characters There are 2 digits There are 3 spaces ``` 在下一個示例中，我們將打印足球比賽的結果。 `teams1.py` ```py #!/usr/bin/env python # teams1.py print("Ajax Amsterdam" " - " "Inter Milano " "2:3") print("Real Madridi" " - " "AC Milano " "3:3") print("Dortmund" " - " "Sparta Praha " "2:1") ``` 我們已經知道相鄰的字符串是連接在一起的。 ```py $ ./teams1.py Ajax Amsterdam - Inter Milano 2:3 Real Madridi - AC Milano 3:3 Dortmund - Sparta Praha 2:1 ``` 接下來，我們將改善輸出的外觀。 `teams2.py` ```py #!/usr/bin/env python # teams2.py teams = { 0: ("Ajax Amsterdam", "Inter Milano"), 1: ("Real Madrid", "AC Milano"), 2: ("Dortmund", "Sparta Praha") } results = ("2:3", "3:3", "2:1") for i in teams: line = teams[i][0].ljust(16) + "-".ljust(5) + teams[i][1].ljust(16) + results[i].ljust(3) print(line) ``` `ljust()`方法返回左對齊字符串，`rjust()`方法返回右對齊字符串。如果字符串小于我們提供的寬度，則將用空格填充。 ```py $ ./teams2.py Ajax Amsterdam - Inter Milano 2:3 Real Madrid - AC Milano 3:3 Dortmund - Sparta Praha 2:1 ``` 現在輸出看起來更好。 ## Python 字符串格式化字符串格式化是將各種值動態地放入字符串中。可以使用`%`運算符或`format()`方法實現字符串格式化。 `oranges.py` ```py #!/usr/bin/env python # oranges.py print('There are %d oranges in the basket' % 32) print('There are {0} oranges in the basket'.format(32)) ``` 在代碼示例中，我們動態構建一個字符串。我們在句子中加上數字。 ```py print('There are %d oranges in the basket' % 32) ``` 我們使用`%d`格式說明符。 `d`字符表示我們期望一個整數。在字符串之后，我們放置一個模運算符和一個參數。在這種情況下，我們有一個整數值。 ```py print('There are {0} oranges in the basket'.format(32)) ``` 使用`format()`方法可以完成相同的任務。這次，格式化說明符是`{0}`。 ```py $ ./oranges.py There are 32 oranges in the basket There are 32 oranges in the basket ``` 下一個示例顯示如何向字符串中添加更多值。 `fruits.py` ```py #!/usr/bin/env python # fruits.py print('There are %d oranges and %d apples in the basket' % (12, 23)) print('There are {0} oranges and {1} apples in the basket'.format(12, 23)) ``` 在這兩行中，我們添加了兩個格式說明符。 ```py $ ./fruits.py There are 12 oranges and 23 apples in the basket There are 12 oranges and 23 apples in the basket ``` 在下一個示例中，我們構建一個帶有浮點數和字符串值的字符串。 `height.py` ```py #!/usr/bin/env python # height.py print('Height: %f %s' % (172.3, 'cm')) print('Height: {0:f} {1:s}'.format(172.3, 'cm')) ``` 我們打印一個人的身高。 ```py print('Height: %f %s' % (172.3, 'cm')) ``` 浮點值的格式說明符為`%f`，字符串為`%s`。 ```py print('Height: {0:f} {1:s}'.format(172.3, 'cm')) ``` 使用`format()`方法，我們將`f`和`s`字符添加到說明符中。 ```py $ ./height.py Height: 172.300000 cm Height: 172.300000 cm ``` 我們可能不喜歡上面示例中的數字默認情況下具有 6 個小數位的事實。我們可以控制格式說明符中的小數位數。 `height2.py` ```py #!/usr/bin/env python # height2.py print('Height: %.2f %s' % (172.3, 'cm')) print('Height: {0:.2f} {1:s}'.format(172.3, 'cm')) ``` 小數點后跟一個整數控制小數位數。在我們的情況下，該數字將保留兩位小數。 ```py $ ./height2.py Height: 172.30 cm Height: 172.30 cm ``` 下面的示例顯示其他格式設置選項。 `various.py` ```py #!/usr/bin/python # various.py # hexadecimal print("%x" % 300) print("%#x" % 300) # octal print("%o" % 300) # scientific print("%e" % 300000) ``` 前兩種格式使用十六進制數。 `x`字符將以十六進制格式格式化數字。 `#`字符會將`0x`添加到十六進制數字。 `o`字符以八進制格式顯示數字。 `e`字符將以科學格式顯示數字。 ```py $ ./various.py 12c 0x12c 454 3.000000e+05 ``` `format()`方法還支持二進制格式。 `various2.py` ```py #!/usr/bin/python # various2.py # hexadecimal print("{:x}".format(300)) print("{:#x}".format(300)) # binary print("{:b}".format(300)) # octal print("{:o}".format(300)) # scientific print("{:e}".format(300000)) ``` 該示例以十六進制，二進制，八進制和科學格式打印數字。下一個示例將打印三列數字。 `columns1.py` ```py #!/usr/bin/env python # columns1.py for x in range(1, 11): print('%d %d %d' % (x, x*x, x*x*x)) ``` 數字左對齊，輸出不是最佳的。 ```py $ ./columns1.py 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000 ``` 為了解決這個問題，我們使用寬度說明符。寬度說明符定義對象的最小寬度。如果對象小于寬度，則將填充空格。 `columns2.py` ```py #!/usr/bin/env python # columns2.py for x in range(1, 11): print('%2d %3d %4d' % (x, x*x, x*x*x)) ``` 現在輸出看起來正常。值 2 使第一列寬 2 個字符。 ```py $ ./columns2.py 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000 ``` 現在我們有了`format()`方法的改進格式。 `columns3.py` ```py #!/usr/bin/env python # columns3.py for x in range(1, 11): print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x)) ``` Python 教程的這一章專門介紹 Python 中的字符串數據類型。