第八章 字符串

字符串和整形、浮点数以及布尔值很不一样。一个字符串是一个序列，意味着是对其他值的有序排列。在本章你将学到如何读取字符串中的字符，你还会学到一些字符串相关的方法。

8.1 字符串是序列

字符串就是一串有序的字符。你可以通过方括号操作符，每次去访问字符串中的一个字符：

>>> fruit = 'banana'
>>> letter = fruit[1]

第二个语句选择了 fruit 这个字符串的序号为1的字符，并把这个字符赋值给了 letter 这个变量。

（译者注：思考一下这里的 letter 是一个什么类型的变量。）

方括号内的内容叫做索引。索引指示了你所指定的字符串中字符的位置（就跟名字差不多）。

但你可能发现得到的结果和你预期的有点不一样：

>>> letter
'a'

大多数人都认为banana 的第『1』个字符应该是 b，而不是 a。但对于计算机科学家来说，索引是字符串从头的偏移量，所以真正的首字母偏移量应该是0.

>>> letter = fruit[0]
>>> letter
'b'

所以 b 就是字符串 banana 的第『0』个字符，而 a 是第『1』个，n 就是第『2』个了。

你可以在方括号内的索引中使用变量和表达式：

>>> i = 1
>>> fruit[i]
'a'
>>> fruit[i+1]
'n'

但要注意的事，索引的值必须是整形的。否则你就会遇到类型错误了：

>>> letter = fruit[1.5]
TypeError: string indices must be integers

8.2 len 长度

len 是一个内置函数，会返回一个字符串中字符的长度：

>>> fruit = 'banana'
>>> len(fruit) 6

要得到一个字符串的最后一个字符，你可能会想到去利用 len 函数：

>>> length = len(fruit)
>>> last = fruit[length]
IndexError: string index out of range

出现索引错误的原因就是banana 这个字符串在第『6』个位置是没有字母的。因为我们从0开始数，所以这一共6个字母的顺序是0到5号。因此要得到最后一次字符，你需要在字符串长度的基础上减去1才行：

>>> last = fruit[length-1]
>>> last
'a'

或者你也可以用负数索引，意思就是从字符串的末尾向前数几位。fruit[-1]这个表达式给你最后一个字符，fruit[-2]给出倒数第二个，依此类推。

8.3 用 for 循环遍历字符串

很多计算过程都需要每次从一个字符串中拿一个字符。一般都是从头开始，依次得到每个字符，然后做点处理，然后一直到末尾。这种处理模式叫遍历。写一个遍历可以使用 while 循环：

index = 0
while index < len(fruit):
    letter = fruit[index]
    print(letter)
    index = index + 1

这个循环遍历了整个字符串，然后它再把买一个字符显示在一行上面。循环条件是 index 这个变量小于字符串 fruit 的长度，所以当 index 与字符串长度相等的时候，条件就不成立了，循环体就不运行了。最后一个字符被获取的时候，index 正好是len(fruit)-1，这就已经是该字符串的最后一个字符了。

下面就练习一下了，写一个函数，接收一个字符串做参数，然后倒序显示每一个字符，每行显示一个。

另外一种遍历的方法就是 for 循环了：

for letter in fruit:
    print(letter)

每次循环之后，字符串中的下一个字符都会赋值给变量 letter。循环在进行到没有字符剩余的时候就停止了。

下面的例子展示了如何使用级联（字符串加法）以及一个 for 循环来生成一个简单的序列（用字母表顺序）。

在 Robert McCloskey 的一本名叫《Make Way for Ducklings》的书中，小鸭子的名字依次为：Jack, Kack, Lack, Mack, Nack, Ouack, Pack, 和Quack。下面这个循环会依次输出他们的名字：

prefixes = 'JKLMNOPQ'
suffix = 'ack'
for letter in prefixes:
    print(letter + suffix)

输出结果如下：

Jack Kack Lack Mack Nack Oack Pack Qack

当然了，有点不准确的地方，因为有“Ouack”和 “Quack”两处拼写错了。做个练习，修改一下程序，改正这个错误。

8.4 字符串切片

字符串的一段叫做切片。从字符串中选择一部分做切片，与选择一个字符有些相似：

>>> s = 'Monty Python'
>>> s[0:5]
'Monty'
>>> s[6:12]
'Python'

[n:m]这种操作符，会返回字符串中从第『n』个到第『m』个的字符，包含开头的第『n』个，但不包含末尾的第『m』个。这个设计可能有点违背直觉，但可能有助于想象这个切片在字符串中的方向，如图8.1。

Figure 8.1: Slice indices.

如果你忽略了第一个索引（就是冒号前面的那个），切片会默认从字符串头部开始。如果你忽略了第二个索引，切片会一直包含到最后一位：

>>> fruit = 'banana'
>>> fruit[:3]
'ban'
>>> fruit[3:]
'ana'

如果两个索引相等，得到的就是空字符串了，用两个单引号来表示：

>>> fruit = 'banana'
>>> fruit[3:3]
''

空字符串不包含字符，长度为0，除此之外，都与其他字符串是一样的。

那么来练习一下，你觉得 fruit[:]这个是什么意思？在程序中试试吧。

8.5 字符串不可修改

大家总是有可能想试试把方括号在赋值表达式的等号左侧，试图去更改字符串中的某一个字符。比如：

>>> greeting = 'Hello, world!'
>>> greeting[0] = 'J'
TypeError: 'str' object does not support item assignment

『object』是对象的意思，这里指的是字符串类 string，然后『item』是指你试图赋值的字符串中的字符。目前来说，一个对象就跟一个值差不多，但后续在第十章第十节我们再对这个定义进行详细讨论。

产生上述错误的原因是字符串是不能被修改的，这意味着你不能对一个已经存在的字符串进行任何改动。你顶多也就能建立一个新字符串，新字符串可以基于旧字符串进行一些改动。

>>> greeting = 'Hello, world!'
>>> new_greeting = 'J' + greeting[1:]
>>> new_greeting
'Jello, world!'

上面的例子中，对 greeting 这个字符串进行了切片，然后添加了一个新的首字母过去。这并不会对原始字符串有任何影响。（译者注：也就是 greeting 这个字符串的值依然是原来的值，是不可改变的。）

8.6 搜索

下面这个函数是干啥的？

def find(word, letter):
    index = 0
    while index < len(word):
        if word[index] == letter:
            return index
        index = index + 1
    return -1

# 改进的find函数,利用列表收集字母letter在单词word中出现的全部位置.
def find(word, letter): 
    index = 0

    result_list=[]

    while index < len(word):
        if word[index] == letter:

            result_list.append(index) 

        index = index + 1

    return result_list

find('banana','a')

简单来说，find 函数，也就是查找，是方括号操作符[]的逆运算。方括号是知道索引然后提取对应的字符，而查找函数是选定一个字符去查找这个字符出现的索引位置。如果字符没有被找到，函数就返回-1。

这是我们见过的第一个返回语句位于循环体内的例子。如果word[index]等于letter，函数就跳出循环立刻返回。如果字符在字符串里面没出现，程序正常退出循环并且返回-1。

这种计算-遍历一个序列然后返回我们要找的东西的模式就叫做搜索了。

做个练习，修改一下 find 函数，加入第三个参数，这个参数为查找开始的字符串位置。

8.7 循环和计数

下面这个程序计算了字母 a 在一个字符串中出现的次数：

word = 'banana'
count = 0
for letter in word:
    if letter == 'a':
        count = count + 1
    print(count)

这一程序展示了另外一种计算模式，叫做计数。变量 count 被初始化为0，然后每次在字符串中找到一个 a，就让 count 加1.当循环退出的时候，count 就包含了 a 出现的总次数。

做个练习，把上面的代码封装进一个名叫 count 的函数中，泛化一下，一遍让他接收任何字符串和字母作为参数。

然后再重写一下这个函数，这次不再让它遍历整个字符串，而使用上一节中练习的三参数版本的 find 函数。

8.8 字符串方法

字符串提供了一些方法，这些方法能够进行很多有用的操作。方法和函数有些类似，也接收参数然后返回一个值，但语法稍微不同。比如，upper 这个方法就读取一个字符串，返回一个全部为大写字母的新字符串。

与函数的 upper(word)语法不同，方法的语法是 word.upper()。

>>> word = 'banana'
>>> new_word = word.upper()
>>> new_word 
'BANANA'

这种用点号分隔的方法表明了使用的方法名字为 upper，使用这个方法的字符串的名字为 word。后面括号里面是空白的，表示这个方法不接收参数。

A method call is called an invocation;方法的调用被叫做——调用（译者注：中文都混淆成调用，英文里面 invocation 和 invoke 都有祈祷的意思，和 call 有显著的意义差别，但中文都混淆成调用，这种例子不胜枚举，所以大家尽量多读原版作品。）；在这里，我们就说调用了 word 的 upper 方法。

结果我们发现string 有一个方法叫做 find，跟我们写过的函数 find 有惊人的相似：

>>> word = 'banana'
>>> index = word.find('a')
>>> index
1

在这里我们调用了 word 的 find 方法，然后给定了我们要找的字母 a 作为一个参数。

实际上，这个 find 方法比我们的 find 函数功能更通用；它不仅能查找字符，还能查找字符串：

>>> word.find('na')
2

默认情况下 find 方法从字符串的开头来查找，不过可以给它一个第二个参数，让它从指定位置查找：

>>> word.find('na', 3)
4

这是一个可选参数的例子；find 方法还能接收第三个参数，可以指定查找终止的位置：

>>> name = 'bob'
>>> name.find('b', 1, 2)
-1

这个搜索失败了，因为 b 并没有在索引1到2且不包括2的字符中间出现。搜索到指定的第三个变量作为索引的位置，但不包括该位置，这就让 find 方法与切片操作符相一致。

8.9 运算符 in

in 这个词在字符串操作中是一个布尔操作符，它读取两个字符串，如果前者的字符串为后者所包含，就返回真，否则为假：

>>> 'a' in 'banana'
True
>>> 'seed' in 'banana'
False

举个例子，下面的函数显示所有同时在 word1和 word2当中出现的字母：

def in_both(word1, word2):
    for letter in word1:
        if letter in word2:
            print(letter)

选好变量名的话，Python 有时候读起来就跟英语差不多。你读一下这个循环，就能发现，『对第一个 word 当中的每一个字母letter，如果这个字母也在第二个 word 当中出现，就输出这个字母 letter。』

>>> in_both('apples', 'oranges')
a e s

8.10 字符串比较

关系运算符对于字符串来说也可用。比如可以看看两个字符串是不是相等：

if word == 'banana':
    print('All right, bananas.')

其他的关系运算符可以来把字符串按照字母表顺序排列：

if word < 'banana':
    print('Your word, ' + word + ', comes before banana.')
elif word > 'banana':
    print('Your word, ' + word + ', comes after banana.')
else:
    print('All right, bananas.')

Python 对大小写字母的处理与人类常规思路不同。所有大写字母都在小写字母之前，所以顺序上应该是：Your word，然后是 Pineapple，然后才是 banana。

一个解决这个问题的普遍方法是把字符串转换为标准格式，比如都转成小写的，然后再进行比较。一定要记得哈，以免你遇到一个用 Pineapple 武装着自己的家伙的时候手足无措。

8.11 调试

使用索引来遍历一个序列中的值的时候，弄清楚遍历的开头和结尾很不容易。下面这个函数用来对比两个单词，如果一个是另一个的倒序就返回真，但这个函数代码中有两处错误：

def is_reverse(word1, word2):
    if len(word1) != len(word2):
        return False
    i = 0
    j = len(word2)
    while j > 0:
        if word1[i] != word2[j]:
            return False
        i = i+1
        j = j-1
    return True

第一个 if 语句是检查两个词的长度是否一样。如果不一样长，当场就返回假。对函数其余部分，我们假设两个单词一样长。这里用到了守卫模式，在第6章第8节我们提到过。

i 和 j 都是索引：i 从头到尾遍历单词 word1，而 j 逆向遍历单词word2.如果我们发现两个字母不匹配，就可以立即返回假。如果经过整个循环，所有字母都匹配，就返回真。

如果我们用这个函数来处理单词『pots』和『stop』，我们希望函数返回真，但得到的却是索引错误：

>>> is_reverse('pots', 'stop')
 ...   File "reverse.py", line 15, in is_reverse     if word1[i] != word2[j]: IndexError: string index out of range

为了改正这个错误，第一步就是在出错的那行之前先输出索引的值。

while j > 0:
    print(i, j)        # print here
    if word1[i] != word2[j]:
        return False
    i = i+1
    j = j-1

然后我再次运行函数，得到更多信息了：

>>> is_reverse('pots', 'stop')
0 4
... IndexError: string index out of range

第一次循环完毕的时候，j 的值是4，这超出了『pots』这个字符串的范围了（译者注：应该是0-3）。最后一个索引应该是3，所以 j 的初始值应该是 len(word2)-1。

>>> is_reverse('pots', 'stop')
0 3 1 2 2 1
True

这次我们得到了正确的结果，但似乎循环只走了三次，这有点奇怪。为了弄明白带到怎么回事，我们可以画一个状态图。在第一次迭代的过程中，is_reverse 的框架如图8.2所示。

Figure 8.2: State diagram.

我通过设置变量框架中添加虚线表明，i和j的值显示在人物word1and word2拿许可证。

从这个图上运行的程序，文件，更改这些值I和J在每一次迭代过程。发现并解决此函数中的二次错误。

8.12 Glossary 术语列表

object: Something a variable can refer to. For now, you can use “object” and “value” interchangeably.

对象：一个值能够指代的东西。目前为止，你可以把对象和值暂且作为一码事来理解。

sequence: An ordered collection of values where each value is identified by an integer index.

序列：一系列值的有序排列，每一个值都有一个唯一的整数序号。

item: One of the values in a sequence.

元素：一列数值序列当中的一个值。

index: An integer value used to select an item in a sequence, such as a character in a string. In Python indices start from 0.

索引：一个整数值，用来指代一个序列中的特定一个元素，比如在字符串里面就指代一个字符。在 Python 里面索引从0开始计数。

slice: A part of a string specified by a range of indices.

切片：字符串的一部分，通过一个索引区间来取得。

empty string: A string with no characters and length 0, represented by two quotation marks.

空字符串：没有字符的字符串，长度为0，用两个单引号表示。

immutable: The property of a sequence whose items cannot be changed.

不可更改：一个序列中所有元素不能被改变的性质。

traverse: To iterate through the items in a sequence, performing a similar operation on each.

遍历：在一个序列中依次对每一个元素进行某种相似运算的过程。

search: A pattern of traversal that stops when it finds what it is looking for.

搜索：一种遍历的模式，找到要找的内容的时候就停止。

counter: A variable used to count something, usually initialized to zero and then incremented.

计数：一种用来统计某种东西数量的变量，一般初始化为0，然后逐次递增。

invocation: A statement that calls a method.

方法调用：调用方法的语句。

optional argument: A function or method argument that is not required.

可选参数：一个函数或者方法中有一些参数是可选的，非必需的。

8.13 练习

练习1

阅读 这里关于字符串的文档。你也许会想要试试其中一些方法，来确保你理解它们的意义。比如 strip 和 replace 都特别有用。

文档的语法有可能不太好理解。比如在find 这个方法中，方括号表示了可选参数。所以 sub 是必须的参数，但 start 是可选的，如果你包含了 start，end 就是可选的了。

练习2

字符串有个方法叫 count，与咱们在8.7中写的 count 函数很相似。 阅读一下这个方法的文档，然后写一个调用这个方法的代码，统计一下 banana 这个单词中 a 出现的次数 。

练习3

字符串切片可以使用第三个索引，作为步长来使用；步长的意思就是取字符的间距。一个步长为2的意思就是每隔一个取一个字符；3的意思就是每次取第三个，以此类推。

>>> fruit = 'banana'
>>> fruit[0:5:2]
'bnn'

步长如果为-1，意思就是倒序读取字符串，所以[::-1]这个切片就会生成一个逆序的字符串了。

使用这个方法把练习三当中的is_palindrome写成一个一行代码的版本。

练习4

下面这些函数都试图检查一个字符串是不是包含小写字母，但他们当中肯定有些是错的。描述一下每个函数真正的行为（假设参数是一个字符串）。

def any_lowercase1(s):
    for c in s:
        if c.islower():
            return True
        else:
            return False
def any_lowercase2(s):
    for c in s:
        if 'c'.islower():
            return 'True'
        else:
            return 'False'
def any_lowercase3(s):
    for c in s:
        flag = c.islower()
        return flag
def any_lowercase4(s):
    flag = False
        for c in s:
            flag = flag or c.islower()
            return flag
def any_lowercase5(s):
    for c in s:
        if not c.islower():
            return False
        return True

练习5

凯撒密码是一种简单的加密方法，用的方法是把每个字母进行特定数量的移位。对一个字母移位就是把它根据字母表的顺序来增减对应，如果到末尾位数不够就从开头算剩余的位数，『A』移位3就是『D』，而『Z』移位1就是『A』了。

要对一个词进行移位，要把每个字母都移动同样的数量。比如『cheer』这个单词移位7就是『jolly』，而『melon』移位-10就是『cubed』。在电影《2001 太空漫游》中，飞船的电脑叫 HAL，就是 IBM 移位-1。

写一个名叫 rotate_word 的函数，接收一个字符串和一个整形为参数，返回将源字符串移位该整数位得到的新字符串。

你也许会用得上内置函数 ord，它把字符转换成数值代码，然后还有个 chr 是用来把数值代码转换成字符。字母表中的字母都被编译成跟字母表中同样的顺序了，所以如下所示：

>>> ord('c') - ord('a')
2

c 是字母表中的第『2』个（译者注：从0开始数哈）的位置，所以上述结果是2。但注意：大写字母的数值代码是和小写的不一样的。

网上很多有冒犯意义的玩笑都是用 ROT13加密的，也就是移位13的凯撒密码。如果你不太介意，找一下这些密码解密一下吧。样例代码.