Python字符串

在本文中，我们将更详细地处理字符串数据。

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字符串，我们在文本的开头添加一个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)

在我们的示例中，我们打印了LeoTolstoy:AnnaKareninainazbuka。

$ ./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)))

我们将剥离方法应用于具有三个空格的字符串单词。一个空格在开头，两个空格在结尾。请注意，这些方法会删除任意数量的空格，而不仅仅是一个。

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))

这一行试图找到一个“狼”子串。它从第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函数来计算stringin字符的长度。

#!/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)

我们有一个句子将“狼”替换为“狐狸”。

b = a.replace("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。它将在第一次出现seseparator时拆分字符串，并返回一个三元组，其中包含分隔符之前的部分、separator本身以及分隔符之后的部分。

#!/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")

在我们的示例中，我们有一个字符串句子。我们计算句子中的绝对字符数、字母字符数、数字和空格数。为此，我们使用以下函数：len、isalpha、是数字，和是空格。

$ ./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字符表示我们需要一个整数。在字符串之后，我们放置了一个modulooperator和一个参数。在这种情况下，我们有一个整数值。

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教程。