python-字符串全解（四）：字符串方法

上一章我们讨论了字符串的基本操作，主要是索引和分片的操作。说实话，分片操作你要用到极致确实需要花一点时间，不过字符串方法就很直接一点，只要记住调用场景和对应的参数就行。字符串的方法有很多，本章我们讨论常用的字符串方法。

1. replace方法：

顾名思义，这个方法是替换字符串的某些字符，然后返回替换后的字符串。因为字符串是不可变对象，所以这个方法调用对原来的字符串没有什么影响。这个方法有三个参数：old，new，count，其中old是原来的要被替换的字符串；new是新的替换字符串；cout是替换几次，一般情况下count这个参数省略，表示替换所有匹配的子串。来看下面的代码：

a = "abcaaabcaaabcaa"
b = a.replace("abc", "f")
c = a.replace("abc", "f", 1)
d = a.replace("abc", "f", 3)
e = a.replace("abc", "f", 4)
f = a.replace("abcd", "f")


print("a = {}, b = {}, c = {}，d = {}, e = {}, f={}".format(
    a, b, c, d, e, f))
#输出结果：a = abcaaabcaaabcaa, b = faafaafaa, c = faaabcaaabcaa，
# d = faafaafaa, e = faafaafaa, f=abcaaabcaaabcaa

b省略了count参数，所以把字符串中的"abc"全部替换成了"f"，c将count的设置为1，所以字符串从左到右开始搜索子串"abc"，如果遇到，则将其替换"f"，然后搜索停止，只替换一次。类似的d和e都是一样的，分别是替换3次和4次。当然，因为字符串只有三个"abc"子串，所以将count设置为3和4效果是一样的。f是字符串没有匹配出被替换的子串的时候，不做任何的操作，只是返回原字符串。当然replace函数只支持从左到右的开始替换，所以这个函数没有办法从右开始替换，当然你要是想替换右边第一个匹配的子串，方法有很多，接下来我们会根据新学到的方法来实现这个功能。

2.split方法（rsplit）

这个方法是根据分割符，将字符串分割成若干子串，并且返回一个包含子串的列表。他有两个参数，第一个参数是分隔符，可以是当个字符，也可以是多个字符，第二个参数是分隔的次数，默认可以不填，全部分隔。split还有个rsplit的函数，这个参数和split是一样的，不同的是从字符串的右边开始寻找分隔符开始分隔。看下面的例子：

a = "abcaaabcaaabcaa"
b = a.split("abc")
c = a.split("abc", 1)
d = a.split("abc", 3)
e = a.split("abc", 4)
f = a.split("abcd")
g = a.rsplit("abc", 1)
print("a = {}, b = {}, c = {}，d = {}, e = {}, f = {}, g = {}".format(
    a, b, c, d, e, f, g))
#输出结果：a = abcaaabcaaabcaa, b = ['', 'aa', 'aa', 'aa'],
# c = ['', 'aaabcaaabcaa']，d = ['', 'aa', 'aa', 'aa'],
# e = ['', 'aa', 'aa', 'aa'], f = ['abcaaabcaaabcaa'],
# g = ['abcaaabcaa', 'aa']

b，c，d，e有个共通之处，就是列表的第一个位置是空串，原因是分隔符"abc"，处于字符串的第一个位置，所以字符串会被分隔成""和"aaabcaaabcaa"，因为b的count参数为空，所以剩余的子串会继续寻找分隔符拆分，然后拆出"aa"和"aaabcaa"，剩余的子串继续拆分，直到字符串结束。c，d，e因为给了拆分的次数，所以1只拆分一次，d拆分三次，e和d的效果一样，因为分隔三次后字符串找不到第四次分隔的机会。f是在字符串中没有找到分隔符，然后直接返回了原来的字符串。g和c的不同之处是，c是从左至右开始寻找分隔符，而g是从右至左开始寻找分隔符，所以两者的结果是不同的。

刚才我们看到rsplit是通过从右到左寻找分隔符，我们可以利用这个函数实现从右替换，看下面的代码：

a = "abcaaabcaaabcaa"
b = a.rsplit("abc", 1)
c = "f".join(b)
print("a = {}, b = {}, c = {}".format(
    a, b, c))
#输出结果：a = abcaaabcaaabcaa, 
# b = ['abcaaabcaa', 'aa'], c = abcaaabcaafaa

我们首先利用rsplit函数，将字符串分为"abcaaabcaa"和"aa",这次的分隔的作用实际上是去掉了右边的第一个"abc"子串，突然后通过.join这个函数将分隔后的字符串再连接起来，连接用到的字符"f"就是我们要替换的新子串，这样就是实现了将右边第一个"abc"替换为"f"。

3.find方法（rfind）

find方法是寻找字符串中的字符串是否存在子串，如果存在，则返回子串开始的位置，如果查询不到，则返回-1。有三个参数，第一个参数是要寻找的字符串，第二个参数是字符串查找开始的位置索引，第三个参数是字符串查找结束的位置索引。第二和第三个参数允许在字符串的子串中查找字符串。rfind和上面的rsplit一样，就从右边开始查找。看下面的代码：

a = "abcaaabcaaabcaa"
b = a.find("abc")
c = a.rfind("abc")
d = a.find("abc", 2)
e = a.find("abc", 5, 7)
f = a.find("abc", 6, 15)

print("a = {}, b = {}, c = {}, d = {}, e = {}, f = {}".format(
    a, b, c, d, e, f))
#输出结果：a = abcaaabcaaabcaa, b = 0, c = 10, d = 5, e = -1, f = 10

b可以看到返回到要查找的字符串首次出现的位置0，c是从右边开始查找，首次出现的位置是10，d是从索引2开始查找，返回首次出现的位置是5，e返回的是-1，因查找的位置不包含结束位置的索引，如果将7改为8，则返回的也是5。f返回的是10，和c返回的位置一样，因为f的索引开始和结束的范围恰恰是从右开始查找的第一个符合的位置。

我们通过右边查找可以锁定从右开始的第一个子串的位置，所以同样可以实现从右替换。看下面的代码。

a = "abcaaabcaaabcaa"
b = a.rfind("abc")
c = a[0:b] + 'f' + a[b+len("abc"):]

print("a = {}, b = {}, c = {}".format(
    a, b, c))
#输出结果：a = abcaaabcaaabcaa, b = 10, c = abcaaabcaafaa

首先找到子串"abc"从右边第一次出现的位置，然后将a分成两部分，恰好去掉子串的部分将其替换成"f"，这样就实现了从右边替换的功能。

4.index方法（rindex）：

index和find的用法基本上一摸一样，就连参数都是一样的，唯一的不同之处是，index如果在字符串中找不到子串的话，会抛出异常。看下面的代码：

a = "abcaaabcaaabcaa"
b = a.index("abc")
c = a.rindex("abc")
d = a.index("abc", 2)
try:
    e = a.index("abc", 5, 7)
except Exception as ex:
    print(ex) #substring not found
    e = -1

f = a.index("abc", 6, 15)

print("a = {}, b = {}, c = {}, d = {}, e = {}, f = {}".format(
    a, b, c, d, e, f))
#输出结果：a = abcaaabcaaabcaa, b = 0, c = 10, d = 5, e = -1, f = 10

可以看出，当子串在字符串中找不到的时候，index会抛出异常，我们用try语句捕获并打印了这个异常。因为e在发生异常的时候来不及赋值，所以我们在except中将e赋值了-1，这样就达到了find的效果。用index而不用find的场景，是当我们如果找不到子串的时候就想抛出异常的时候，我们用index。

5.strip方法（lstrip，rstrip）

strip这个方法在我们想去除字符串两边多余的空格的时候，是很有用的。尤其是从标准输入流获取用户的输入，为了防止一些输入的干扰，尤其是空格，我们可以在对字符串调用strip方法。这个方法默认可以不填任何参数，去除两边的空格，回车(\r)，换行(\n)，以及制表符(\t,\v)等。当然我们可以指定参数，去除字符串两边的给定字符。lstrip是去除左边的字符，保留右边的。rstrip刚好相反，是去除右边的，保留左边的。看下面的代码：

a = "\r\n abc \r\n"
b = a.strip()
c = a.lstrip()
d = a.rstrip()
e = a.strip("\r\n")

print("b = {}, c = {}, d = {}, e = {}".format(
    b, c, d, e))
#输出结果：b = abc, c = abc 
#, d = 
# abc, e =  abc 

b直接调用strip，将a字符串中两边的回车，换成以及空格都去掉了。c只去左边的，我们看到打印到c的时候换了行，因为右边的没有去除，d相反，先换行在打印出abc，说明左边的没有去除。e指定了参数，只是去掉两边的回车换行，我们发现打印出来的e保留了两边的空格。当然，如果字符串没有空格换行或者字符串两边没有指定的参数，则只是返回原来的字符串。

6.upper和lower方法

这两个方法是将字符串的中的字母全部转化为大写或者小写。这样做的好处就是做到大小写无感，不管用户输入的是小写还是大写，都统一转化大写或者小写。看下面的代码：

a = "Abc1"
b = a.upper()
c = a.lower()


print("a = {}, b = {}, c = {}".format(
    a, b, c))
#输出结果：a = Abc1, b = ABC1, c = abc1

b将字符串中的字母全部转化为大写，c将字符串中的字母全部转化为小写，即便字符串中有数字，也不会有所影响，因为只是转化字母，不会转化非字母的字符。

7.join方法：

这个方法我们之前很多地方都用到过，这个是用字符串来连接参数中的成员。注意这个参数一定是一个可迭代的对象，之前我们讲过迭代，就是循环的去访问这个对象中的成员。可以迭代访问的就是迭代对象。有字符串，列表，元组等。关于可迭代对象，我们回头会单独来说，先看下面的代码：

a = "12345"
b = ["1", "2", "3", "4", "5"]
c = "abc".join(a)
d = "".join(b)


print("a = {}, b = {}, c = {}, d = {}".format(
    a, b, c, d))
#输出结果：a = 12345, b = ['1', '2', '3', '4', '5'], 
# c = 1abc2abc3abc4abc5, d = 12345

c相当于在a字符串的每个字符中间插入了"abc"，d是用一个空字符串去做连接，这个最常用，用来将一个列表的各个成员合并成一个字符串。在合并的时候一定要注意，列表的成员必须都是字符串，或是能自动转化为字符串的对象，如果包含整数，则合并会出错。

限于篇幅，我们字符串的常用方法就介绍到这里，这7个方法是目前我们用的比较多的，我有意忽略了encode方法和format方法，尤其是format方法，我给出的示例代码中都会用到，这是最简单的用法，但是format方法本身的一个格式化参数却很复杂，值得单独拿出来说，到时候会和格式化表达式一起来说。encode方法涉及到了字符编码方式，这个会留到讲unciode的章节来说。

总的来说，你掌握了前面的切片和索引，加上这几个方法，大部分的字符串操作已经覆盖了。如果你想更进一步，请关注后续的章节。