Python 字符串
最后修改于 2024 年 1 月 29 日
在本文中，我们将更详细地处理字符串数据。
Python 字符串定义
Python 中的字符串是字符序列。它是一种派生数据类型。字符串是不可变的。这意味着一旦定义，它们就无法更改。许多 Python 方法，如 replace、join 或 split，都会修改字符串。但是，它们不会修改原始字符串。它们会创建字符串的副本，对其进行修改并返回给调用者。
Python 字符串字面量
可以使用单引号、双引号或三引号创建 Python 字符串。 当我们使用三引号时，字符串可以跨越多行而无需使用转义字符。
#!/usr/bin/python # string_literals.py a = "proximity alert" b = 'evacuation' c = """ requiem for a tower """ print(a) print(b) print(c)
在我们的示例中，我们将三个字符串字面量分配给 a、b 和 c 变量。 我们将它们打印到控制台。
$ ./string_literals.py proximity alert evacuation requiem for a tower
Python 中的 Unicode
如果我们要创建 Unicode 字符串，我们在文本开头添加一个 u 或 U 字符。
#!/usr/bin/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)
在我们的示例中，我们以俄文字母打印列夫·托尔斯泰：《安娜·卡列尼娜》。
$ ./unicode.py Лев Николаевич Толстой: Анна Каренина
我们可以直接在代码中使用俄语字母。
#!/usr/bin/python # unicode2.py text = 'Лев Николаевич Толстой: Анна Каренина' print(text)
在此示例中，我们直接在源代码中使用非拉丁字符。 我们使用编码注释定义了 UTF-8 编码。
在 Python 中使用引号
Python 中的字符串由单引号或双引号字符分隔。 如果我们想显示引号，例如在直接引语中，该怎么办？ 有两种基本方法可以做到这一点。
#!/usr/bin/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?"')
我们使用 \ 字符来转义额外的引号。 通常，双引号字符用于分隔字符串文字。 然而，当转义时，原始含义被抑制。 它显示为一个普通字符，可以在字符串文字中使用。 在引号中使用引号的第二种方法是混合使用单引号和双引号。
$ ./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 方法计算字符串中的字符数。 空白字符也会被计算在内。
#!/usr/bin/python # string_length.py s1 = "Eagle" s2 = "Eagle\n" s3 = "Eagle " print(len(s1)) print(len(s2)) print(len(s3))
我们计算三个字符串的长度。
s1 = "Eagle" s2 = "Eagle\n" s3 = "Eagle "
定义了三个字符串。 第二个字符串末尾有一个换行符。 第三个字符串有两个额外的空格字符。
print(len(s1))
我们将字符数打印到控制台。
$ ./length.py 5 6 7
从输出中我们可以看到，空白字符（在本例中为换行符和空格字符）也被计算在内。
Python 字符串去除空白字符
在字符串处理中，我们经常会得到一个字符串，其开头或结尾有空白字符。 术语空白（字符）指的是不可见字符，如换行符、制表符、空格或其他控制字符。 我们有 strip、lstrip 和 rstrip 方法来删除这些字符。
#!/usr/bin/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)))
我们将去除方法应用于一个有三个空白字符的字符串 word。 开头有一个空格，结尾有两个空格。 请注意，这些方法会删除任意数量的空白字符，而不仅仅是一个。
s2 = s.rstrip()
rstrip 方法返回一个删除了尾随空白字符的字符串。
s3 = s.lstrip()
lstrip 方法返回一个删除了前导空白字符的字符串。
s4 = s.strip()
strip 方法返回一个删除了前导和尾随字符的字符串的副本。
print('{0} {1}'.format(s2, len(s2)))
format 方法用于动态构建字符串。 {0} 是一个控制字符，指的是 format 方法的第一个参数。 {1} 指的是第二个参数。
$ ./stripping.py Eagle 8 Eagle 6 Eagle 7 Eagle 5
Python 字符串转义序列
当我们处理字符串时，我们可以使用转义序列。 转义序列是特殊字符，在字符串中使用时具有特定用途。
print(" bbb\raaa") # prints aaabbb
回车符 \r 是一个控制字符，用于将行尾返回到行首。
#!/usr/bin/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")
换行符是一个控制字符，它开始一个新行文本。
$ ./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
接下来，我们检查退格控制字符。
print("Python\b\b\booo") # prints Pytooo
退格控制字符 \b 将光标向后移动一个字符。 在我们的例子中，我们使用三个退格字符来删除三个字母并用三个 o 字符替换它们。
print("Towering\tinferno") # prints Towering inferno
水平制表符在文本之间添加空格。
"Johnie's dog" 'Johnie\'s dog'
单引号和双引号可以嵌套。或者，如果我们只使用单引号，我们可以使用反斜杠来转义单引号的默认含义。
如果我们在字符串前添加一个 r，我们会得到一个原始字符串。 转义序列不会被解释。
#!/usr/bin/python # raw.py print(r"Another world\n")
$ ./raw.py Another world\n
我们得到包含换行符的字符串。
Python 比较字符串
比较字符串是编程中的一项常见工作。 我们可以使用 == 运算符比较两个字符串。 我们可以使用非等式 != 运算符检查相反的情况。 运算符返回布尔值 True 或 False。
#!/usr/bin/python
# comparing.py
print("12" == "12")
print("17" == "9")
print("aa" == "ab")
print("abc" != "bce")
print("efg" != "efg")
在此代码示例中，我们比较一些字符串。
print("12" == "12")
这两个字符串相等，所以该行返回 True。
print("aa" == "ab")
两个字符串的前两个字符相等。 接下来比较以下字符。 它们是不同的，所以该行返回 False。
print("abc" != "bce")
由于两个字符串不同，所以该行返回 True。
$ ./comparing.py True False False True False
Python 访问字符串元素
可以访问 Python 中的字符串元素。
#!/usr/bin/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[:])
索引操作用于获取字符串的元素。
print(s[0]) print(s[4])
第一行打印第一个字符。 第二行打印第五个字符。 索引从零开始。
print(s[-1]) print(s[-2])
当索引为负数时，我们从字符串末尾检索元素。 在这种情况下，我们打印最后一个和倒数第二个字符。
print(s[0:4])
也可以访问字符范围。 此行打印从第一个字符到第四个字符的字符范围。
print(s[:])
此行打印字符串中的所有字符。
$ ./string_elements.py E e e l **************** Eagl ag Eagle
可以使用 for 循环来遍历字符串的所有字符。
#!/usr/bin/python # traverse.py s = "ZetCode" for i in s: print(i, " ", end="")
该脚本将给定字符串的所有字符打印到控制台。
$ ./traverse.py Z e t C o d e
Python 查找子字符串
find、rfind、index 和 rindex 方法用于查找字符串中的子字符串。 它们返回子字符串第一次出现的索引。 find 和 index 方法从字符串的开头开始搜索。 rfind 和 rindex 从字符串的结尾开始搜索。
find 和 index 方法的区别在于，当找不到子字符串时，前者返回 -1。 后者引发 ValueError 异常。
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 参数是结束索引。 默认情况下，它等于字符串的长度。
#!/usr/bin/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"))
我们有一个简单的句子。 我们尝试查找句子中子字符串的索引。
print(a.find("wolf"))
该行查找句子中子字符串“wolf”第一次出现的位置。 它打印 8。
print(a.find("wolf", 10, 20))
此行尝试查找“wolf”子字符串。 它从第 10 个字符开始，搜索接下来的 20 个字符。 此范围内没有这样的子字符串，因此该行打印 -1，表示未找到。
print(a.find("wolf", 15))
在这里，我们从第 15 个字符开始搜索到字符串的末尾。 我们找到子字符串第二次出现的位置。 该行打印 35。
print(a.rfind("wolf"))
rfind 从末尾查找子字符串。 它找到子字符串“wolf”第二次出现的位置。 该行打印 35。
$ ./substrings.py 8 -1 35 35
在第二个示例中，我们使用 index 和 rindex 方法。
#!/usr/bin/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 方法搜索子字符串。
print(a.index("wolf"))
print(a.rindex("wolf"))
这些行从开头和结尾查找子字符串“wolf”第一次出现的位置。
try:
print(a.rindex("fox"))
except ValueError as e:
print("Could not find substring")
当找不到子字符串时，rindex 方法会引发 ValueError 异常。
$ ./substrings2.py 8 35 Could not find substring
Python 基本字符串操作
在下一个示例中，我们进行字符串乘法和连接。
#!/usr/bin/python
# add_multiply.py
print("eagle " * 5)
print("eagle " "falcon")
print("eagle " + "and " + "falcon")
* 运算符将字符串重复 n 次。 在我们的例子中是五次。 彼此相邻的两个字符串字面量会自动连接。 我们也可以使用 + 运算符显式地连接字符串。
$ ./add_multiply.py eagle eagle eagle eagle eagle eagle falcon eagle and falcon
我们可以使用 len 函数来计算字符串的字符长度。
#!/usr/bin/python # eagle.py var = 'eagle' print(var, "has", len(var), "characters")
在该示例中，我们计算字符串变量中的字符数。
$ ./eagle.py eagle has 5 characters
某些编程语言允许隐式添加字符串和数字。 在 Python 语言中，这是不可能的。 我们必须显式地转换值。
#!/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 中的字符串是不可变的，因此会构建一个替换值的新字符串。
replace(old, new [, max])
默认情况下，replace 方法会替换子字符串的所有出现。 该方法接受第三个参数，该参数将替换限制为一定数量。
#!/usr/bin/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)
我们有一个句子，我们将“wolf”替换为“fox”。
b = a.replace("wolf", "fox")
此行将所有出现的“wolf”替换为“fox”。
c = a.replace("wolf", "fox", 1)
在这里我们只替换第一次出现。
$ ./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 方法分割字符串。 它们返回一个字符串列表，这些字符串是使用分隔符从字符串中剪切出来的。 可选的第二个参数是允许的最大分割数。
#!/usr/bin/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)
我们有一个逗号分隔的字符串。 我们将字符串切割成几部分。
k = nums.split(",")
我们使用逗号作为分隔符将字符串分割成八个部分。 该方法返回一个包含八个字符串的列表。
l = nums.split(",", 5)
在这里，我们将字符串分割成六个部分。 有五个子字符串和字符串的其余部分。
m = nums.rsplit(",", 3)
在这里，我们将字符串分割成四个部分。 这次分割是从右边开始的。
$ ./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 字符串连接字符串。 它返回一个从作为参数传递的字符串连接的字符串。 元素之间的分隔符是提供此方法的字符串。
#!/usr/bin/python
# split_join.py
nums = "1,5,6,8,2,3,1,9"
n = nums.split(",")
print(n)
m = ':'.join(n)
print(m)
首先，我们将字符串分割成一个字符串列表。 然后，我们将字符串连接成一个字符串，元素之间用提供的字符分隔。
m = ':'.join(n)
join 方法从字符串列表中创建一个字符串。 元素之间用 : 字符分隔。
$ ./split_join.py ['1', '5', '6', '8', '2', '3', '1', '9'] 1:5:6:8:2:3:1:9
可用于分割字符串的另一种方法是 partition。 它将在分隔符第一次出现时分割字符串，并返回一个包含分隔符之前的部分、分隔符本身和分隔符之后的部分的 3 元组。
#!/usr/bin/python
# partition.py
s = "1 + 2 + 3 = 6"
a = s.partition("=")
print(a)
在此示例中，我们使用 partition 方法。
a = s.partition("=")
这会将字符串切割成三个部分。 = 字符之前的部分、分隔符和分隔符之后的右侧部分。
$ ./partition.py
('1 + 2 + 3 ', '=', ' 6')
Python 字符串大小写
Python 有四种字符串方法来处理字符串的大小写。 这些方法返回一个新的修改后的字符串。
#!/usr/bin/python # convert_case.py a = "ZetCode" print(a.upper()) print(a.lower()) print(a.swapcase()) print(a.title())
我们有一个字符串 word，我们在上面演示这四种方法。
print(a.upper())
upper 方法返回字符串的副本，其中所有字符都转换为大写。
print(a.lower())
在这里，我们获得一个字符串的小写字母副本。
print(a.swapcase())
swapcase 方法交换字母的大小写。 小写字符将是大写，反之亦然。
print(a.title())
title 方法返回字符串的副本，其中第一个字符是大写，其余字符是小写。
$ ./convert_case.py ZETCODE zetcode zETcODE Zetcode
Python 字符串上的操作
有几个有用的内置函数可用于处理字符串。
#!/usr/bin/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")
在我们的示例中，我们有一个字符串 sentence。 我们计算句子中字符的绝对数量、字母字符的数量、数字和空格。 为此，我们使用以下函数：len、isalpha、isdigit 和 isspace。
$ ./letters.py There are 19 characters There are 14 alphabetic characters There are 2 digits There are 3 spaces
在下一个示例中，我们打印足球比赛的结果。
#!/usr/bin/python
# teams1.py
print("Ajax Amsterdam" " - " "Inter Milano " "2:3")
print("Real Madridi" " - " "AC Milano " "3:3")
print("Dortmund" " - " "Sparta Praha " "2:1")
我们已经知道相邻的字符串是连接的。
$ ./teams1.py Ajax Amsterdam - Inter Milano 2:3 Real Madridi - AC Milano 3:3 Dortmund - Sparta Praha 2:1
接下来，我们改善输出的外观。
#!/usr/bin/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 方法返回一个右对齐的字符串。 如果字符串小于我们提供的宽度，则用空格填充。
$ ./teams2.py Ajax Amsterdam - Inter Milano 2:3 Real Madrid - AC Milano 3:3 Dortmund - Sparta Praha 2:1
现在输出看起来更好了。
Python 字符串格式化
字符串格式化是将各种值动态地放入字符串中。 可以使用 % 运算符或 format 方法实现字符串格式化。
#!/usr/bin/python
# oranges.py
print('There are %d oranges in the basket' % 32)
print('There are {0} oranges in the basket'.format(32))
在代码示例中，我们动态地构建一个字符串。 我们在句子中放一个数字。
print('There are %d oranges in the basket' % 32)
我们使用 %d 格式说明符。 d 字符表示我们期望一个整数。 在字符串之后，我们放置一个模运算符和一个参数。 在这种情况下，我们有一个整数值。
print('There are {0} oranges in the basket'.format(32))
使用 format 方法实现相同的任务。 这次格式说明符是 {0}。
$ ./oranges.py There are 32 oranges in the basket There are 32 oranges in the basket
下一个示例演示如何向字符串添加更多值。
#!/usr/bin/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))
在这两行中，我们都添加了两个格式说明符。
$ ./fruits.py There are 12 oranges and 23 apples in the basket There are 12 oranges and 23 apples in the basket
在下一个示例中，我们构建一个带有浮点数和字符串值的字符串。
#!/usr/bin/python
# height.py
print('Height: %f %s' % (172.3, 'cm'))
print('Height: {0:f} {1:s}'.format(172.3, 'cm'))
我们打印一个人的身高。
print('Height: %f %s' % (172.3, 'cm'))
浮点值的格式说明符是 %f，字符串的格式说明符是 %s。
print('Height: {0:f} {1:s}'.format(172.3, 'cm'))
使用 format 方法，我们将 f 和 s 字符添加到说明符。
$ ./height.py Height: 172.300000 cm Height: 172.300000 cm
我们可能不喜欢上一个示例中的数字默认有 6 位小数的事实。 我们可以控制格式说明符中小数的位数。
#!/usr/bin/python
# height2.py
print('Height: %.2f %s' % (172.3, 'cm'))
print('Height: {0:.2f} {1:s}'.format(172.3, 'cm'))
小数点后跟一个整数控制小数位数。 在我们的例子中，数字将有两位小数。
$ ./height2.py Height: 172.30 cm Height: 172.30 cm
以下示例显示了其他格式化选项。
#!/usr/bin/python
# various.py
# hexadecimal
print("%x" % 300)
print("%#x" % 300)
# octal
print("%o" % 300)
# scientific
print("%e" % 300000)
前两种格式适用于十六进制数字。 x 字符将以十六进制表示法格式化数字。 # 字符将向十六进制数字添加 0x。 o 字符以八进制格式显示数字。 e 字符将以科学计数法格式显示数字。
$ ./various.py 12c 0x12c 454 3.000000e+05
format 方法也支持二进制格式。
#!/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))
该示例以十六进制、二进制、八进制和科学计数法格式打印数字。
下一个例子将打印三列数字。
#!/usr/bin/python
# columns1.py
for x in range(1, 11):
print('%d %d %d' % (x, x*x, x*x*x))
数字是左对齐的，输出不是最佳的。
$ ./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
为了纠正这一点，我们使用宽度说明符。 宽度说明符定义对象的最小宽度。 如果对象小于宽度，则用空格填充。
#!/usr/bin/python
# columns2.py
for x in range(1, 11):
print('%2d %3d %4d' % (x, x*x, x*x*x))
现在输出看起来不错。 值 2 使第一列的宽度为 2 个字符。
$ ./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 方法改进的格式。
#!/usr/bin/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 教程。