# 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 中的字符串数据类型。