第009课：字符串的使⽤

第⼆次世界⼤战促使了现代电⼦计算机的诞⽣，世界上的第⼀台通⽤电⼦计算机叫 ENIAC （电⼦数值积分计算机），诞⽣于美国的宾夕法尼亚⼤学，占地167 平⽶，重量 27 吨，每秒钟⼤约能够完成约 5000 次浮点运算，如下图所示。ENIAC 诞⽣之后被应⽤于导弹弹道的计算，⽽数值计算也是现代电⼦计算机最为重要的⼀项功能。

随着时间的推移，虽然数值运算仍然是计算机⽇常⼯作中最为重要的组成部分，但是今天的计算机还要处理⼤量的以⽂本形式存在的信息。如果我们希望通过Python 程序来操作本这些⽂本信息，就必须要先了解字符串这种数据类型以及与它相关的知识。

字符串的定义

所谓 字符串 ，就是 由零个或多个字符组成的有限序列 ，⼀般记为：

在 Python 程序中，如果我们把单个或多个字符⽤单引号或者双引号包围起来，就可以表示⼀个字符串。字符串中的字符可以是特殊符号、英⽂字⺟、中⽂字符、⽇⽂的平假名或⽚假名、希腊字⺟、 Emoji 字符 等。

s1 = 'hello, world!'
s2 = "你好，世界！"
print(s1, s2)
# 以三个双引号或单引号开头的字符串可以折⾏
s3 = '''
hello,
world!
'''
print(s3, end='')

提示 ： print 函数中的 end='' 表示输出后不换⾏，即将默认的结束符 \n （换⾏符）更换

为 '' （空字符）。

转义字符和原始字符串

可以在字符串中使⽤ \ （反斜杠）来表示转义，也就是说 \ 后⾯的字符不再是它原来的意义，例

如： \n 不是代表反斜杠和字符 n ，⽽是表示换⾏； \t 也不是代表反斜杠和字符 t ，⽽是表示制表符。 所以如果字符串本身⼜包含了 ' 、 " 、 \ 这些特殊的字符，必须要通过 \ 进⾏转义处理。例如要输出⼀个带单引号或反斜杠的字符串，需要⽤如下所示的⽅法。

s1 = '\'hello, world!\''
print(s1)
s2 = '\\hello, world!\\'
print(s2)

Python 中的字符串可以 r 或 R 开头，这种字符串被称为原始字符串，意思是字符串中的每个字符都是它本来的含义，没有所谓的转义字符。例如，在字符串 'hello\n' 中， \n 表示换⾏；⽽在 r'hello\n' 中， \n 不再表示换⾏，就是反斜杠和字符 n 。⼤家可以运⾏下⾯的代码，看看会输出什

么。

# 字符串s1中\t是制表符，\n是换⾏符
s1 = '\time up \now'
print(s1)
# 字符串s2中没有转义字符，每个字符都是原始含义
s2 = r'\time up \now'
print(s2)

Python 中还允许在 \ 后⾯还可以跟⼀个⼋进制或者⼗六进制数来表示字符，例如 \141 和 \x61 都代表⼩写字⺟ a ，前者是⼋进制的表示法，后者是⼗六进制的表示法。另外⼀种表示字符的⽅式是在 \u 后⾯跟Unicode 字符编码，例如 \u9a86\u660a 代表的是中⽂ “ 骆昊 ” 。运⾏下⾯的代码，看看输出了什么。

s1 = '\141\142\143\x61\x62\x63'
s2 = '\u9a86\u660a'
print(s1, s2)

字符串的运算

Python 为字符串类型提供了⾮常丰富的运算符，我们可以使⽤ + 运算符来实现字符串的拼接，可以使⽤ * 运算符来重复⼀个字符串的内容，可以使⽤ in 和 not in 来判断⼀个字符串是否包含另外⼀个字符串，我们也可以⽤ [] 和 [:] 运算符从字符串取出某个字符或某些字符。

 

拼接和重复

下⾯的例⼦演示了使⽤ + 和 * 运算符来实现字符串的拼接和重复操作。

s1 = 'hello' + ' ' + 'world'
print(s1) # hello world
s2 = '!' * 3
print(s2) # !!!
s1 += s2 # s1 = s1 + s2
print(s1) # hello world!!!
s1 *= 2 # s1 = s1 * 2
print(s1) # hello world!!!hello world!!!

⽤ * 实现字符串的重复是⾮常有意思的⼀个运算符，在很多编程语⾔中，要表示⼀个有 10 个 a 的字符串，你只能写成 "aaaaaaaaaa" ，但是在 Python 中，你可以写成 'a' * 10 。你可能觉得 "aaaaaaaaaa" 这种写法也没有什么不⽅便的，那么想⼀想，如果字符 a 要重复 100 次或者 1000 次⼜会如何呢？

⽐较运算

对于两个字符串类型的变量，可以直接使⽤⽐较运算符⽐较两个字符串的相等性或⼤⼩。需要说明的是，因为字符串在计算机内存中也是以⼆进制形式存在的，那么字符串的⼤⼩⽐较⽐的是每个字符对应的编码的⼤⼩。例如 A 的编码是 65 ， ⽽ a 的编码是 97 ，所以 'A' < 'a' 的结果相当于就是 65 < 97 的结果，很显然是 True ；⽽ 'boy' < 'bad' ，因为第⼀个字符都是 'b' ⽐不出⼤⼩，所以实际⽐较的是第⼆个字符的⼤⼩，显然 'o' < 'a' 的结果是 False ，所以 'boy' < 'bad' 的结果也是 False 。如果不清楚两个字符对应的编码到底是多少，可以使⽤ ord 函数来获得，例如 ord('A') 的值是 65 ，⽽ord('昊 ') 的值是 26122 。下⾯的代码为⼤家展示了字符串的⽐较运算。

 

s1 = 'a whole new world'
s2 = 'hello world'
print(s1 == s2, s1 < s2) # False True
print(s2 == 'hello world') # True
print(s2 == 'Hello world') # False
print(s2 != 'Hello world') # True
s3 = '张三'
print(ord('张'), ord('三')) # 39558 26122
s4 = '王⼤锤'
print(ord('王'), ord('⼤'), ord('锤')) # 29579 22823 38180
print(s3 > s4, s3 <= s4) # True False

需要强调⼀下的是，字符串的⽐较运算⽐较的是字符串的内容， Python 中还有⼀个 is 运算符（身份运算符），如果⽤ is 来⽐较两个字符串，它⽐较的是两个变量对应的字符串是否在内存中相同的位置 （内存地址），简单的说就是两个变量是否对应内存中的同⼀个字符串。看看下⾯的代码就⽐较清楚 is 运算符的作⽤了。

s1 = 'hello world'
s2 = 'hello world'
s3 = s2
# ⽐较字符串的内容
print(s1 == s2, s2 == s3) # True True
# ⽐较字符串的内存地址
print(s1 is s2, s2 is s3) # False True

成员运算

Python 中可以⽤ in 和 not in 判断⼀个字符串中是否存在另外⼀个字符或字符串， in 和 not in 运算通常称为成员运算，会产⽣布尔值 True 或 False ，代码如下所示。

s1 = 'hello, world'
print('wo' in s1) # True
s2 = 'goodbye'
print(s2 in s1) # False

获取字符串⻓度

获取字符串⻓度没有直接的运算符，⽽是使⽤内置函数 len ，我们在上节课的提到过这个内置函数，代码如下所示。

s = 'hello, world'
print(len(s)) # 12
print(len('goodbye, world')) # 14

索引和切⽚

如果希望从字符串中取出某个字符，我们可以对字符串进⾏索引运算，运算符是 [n] ，其中 n 是⼀个整数，假设字符串的⻓度为 N ，那么 n 可以是从 0 到 N-1 的整数，其中 0 是字符串中第⼀个字符的索引，⽽ N-1 是字符串中最后⼀个字符的索引，通常称之为正向索引；在 Python 中，字符串的索引也可以是从 -1 到 -N 的整数，其中 -1 是最后⼀个字符的索引，⽽ -N 则是第⼀个字符的索引，通常称之为负向索引。注意，因为字符串是不可变类型 ，所以 不能通过索引运算修改字符串中的字符 。

s = 'abc123456'
N = len(s)
# 获取第⼀个字符
print(s[0], s[-N]) # a a
# 获取最后⼀个字符
print(s[N-1], s[-1]) # 6 6
# 获取索引为2或-7的字符
print(s[2], s[-7]) # c c
# 获取索引为5和-4的字符
print(s[5], s[-4]) # 3 3

需要提醒⼤家注意的是，在进⾏索引操作时，如果索引越界（正向索引不在 0 到 N-1 范围，负向索引不在 -1 到 -N 范围），会引发 IndexError 异常，错误提示信息为： string index out of range （字符串索引超出范围）。 如果要从字符串中取出多个字符，我们可以对字符串进⾏切⽚，运算符是 [i:j:k] ，其中 i 是开始索引，索引对应的字符可以取到； j 是结束索引，索引对应的字符不能取到； k 是步⻓，默认值为 1 ，表示从前向后获取相邻字符的连续切⽚，所以 :k 部分可以省略。假设字符串的⻓度为 N ，当 k > 0 时表示正向切⽚（从前向后获取字符），如果没有给出 i 和 j 的值，则 i 的默认值是 0 ， j 的默认值是 N ； 当 k < 0 时表示负向切⽚（从后向前获取字符），如果没有给出 i 和 j 的值，则 i 的默认值是 -1 ， j 的默认值是 -N - 1 。如果不理解，直接看下⾯的例⼦，记住第⼀个字符的索引是 0 或 -N ，最后⼀个字符 的索引是 N-1 或 -1 就⾏了。

s = 'abc123456'
# i=2, j=5, k=1的正向切⽚操作
print(s[2:5]) # c12
# i=-7, j=-4, k=1的正向切⽚操作
print(s[-7:-4]) # c12
# i=2, j=9, k=1的正向切⽚操作
print(s[2:]) # c123456
# i=-7, j=9, k=1的正向切⽚操作
print(s[-7:]) # c123456
# i=2, j=9, k=2的正向切⽚操作
print(s[2::2]) # c246
# i=-7, j=9, k=2的正向切⽚操作
print(s[-7::2]) # c246
# i=0, j=9, k=2的正向切⽚操作
print(s[::2]) # ac246
# i=1, j=-1, k=2的正向切⽚操作
print(s[1:-1:2]) # b135
# i=7, j=1, k=-1的负向切⽚操作
print(s[7:1:-1]) # 54321c
# i=-2, j=-8, k=-1的负向切⽚操作
print(s[-2:-8:-1]) # 54321c
# i=7, j=-10, k=-1的负向切⽚操作
print(s[7::-1]) # 54321cba
# i=-1, j=1, k=-1的负向切⽚操作
print(s[:1:-1]) # 654321c
# i=0, j=9, k=1的正向切⽚
print(s[:]) # abc123456
# i=0, j=9, k=2的正向切⽚
print(s[::2]) # ac246
# i=-1, j=-10, k=-1的负向切⽚
print(s[::-1]) # 654321cba
# i=-1, j=-10, k=-2的负向切⽚
print(s[::-2]) # 642ca

循环遍历

如果希望从字符串中取出每个字符，可以使⽤ for 循环对字符串进⾏遍历，有两种⽅式。

⽅式⼀：

s1 = 'hello'
for index in range(len(s1)):
 print(s1[index])

⽅式⼆：

s1 = 'hello'
for ch in s1:
 print(ch)

字符串的⽅法

在 Python 中，我们可以通过字符串类型⾃带的⽅法对字符串进⾏操作和处理，对于⼀个字符串类型的变量，我们可以⽤ 变量名 . ⽅法名 () 的⽅式来调⽤它的⽅法。所谓⽅法其实就是跟某个类型的变量绑定的函数，后⾯我们讲⾯向对象编程的时候还会对这⼀概念详加说明。

⼤⼩写相关操作

下⾯的代码演示了和字符串⼤⼩写变换相关的⽅法。

s1 = 'hello, world!'
# 使⽤capitalize⽅法获得字符串⾸字⺟⼤写后的字符串
print(s1.capitalize()) # Hello, world!
# 使⽤title⽅法获得字符串每个单词⾸字⺟⼤写后的字符串
print(s1.title()) # Hello, World!
# 使⽤upper⽅法获得字符串⼤写后的字符串
print(s1.upper()) # HELLO, WORLD!
s2 = 'GOODBYE'
# 使⽤lower⽅法获得字符串⼩写后的字符串
print(s2.lower()) # goodbye

查找操作

如果想在⼀个字符串中从前向后查找有没有另外⼀个字符串，可以使⽤字符串的 find 或 index ⽅法。

s = 'hello, world!'
# find⽅法从字符串中查找另⼀个字符串所在的位置
# 找到了返回字符串中另⼀个字符串⾸字符的索引
print(s.find('or')) # 8
# 找不到返回-1
print(s.find('shit')) # -1
# index⽅法与find⽅法类似
# 找到了返回字符串中另⼀个字符串⾸字符的索引
print(s.index('or')) # 8
# 找不到引发异常
print(s.index('shit')) # ValueError: substring not found

在使⽤ find 和 index ⽅法时还可以通过⽅法的参数来指定查找的范围，也就是查找不必从索引为 0 的位置开始。 find 和 index ⽅法还有逆向查找（从后向前查找）的版本，分别是 rfind 和 rindex ，代码

如下所示。

s = 'hello good world!'
# 从前向后查找字符o出现的位置(相当于第⼀次出现)
print(s.find('o')) # 4
# 从索引为5的位置开始查找字符o出现的位置
print(s.find('o', 5)) # 7
# 从后向前查找字符o出现的位置(相当于最后⼀次出现)
print(s.rfind('o')) # 12

性质判断

可以通过字符串的 startswith 、 endswith 来判断字符串是否以某个字符串开头和结尾；还可以⽤ is开头的⽅法判断字符串的特征，这些⽅法都返回布尔值，代码如下所示。

s1 = 'hello, world!'
# startwith⽅法检查字符串是否以指定的字符串开头返回布尔值
print(s1.startswith('He')) # False
print(s1.startswith('hel')) # True
# endswith⽅法检查字符串是否以指定的字符串结尾返回布尔值
print(s1.endswith('!')) # True
s2 = 'abc123456'
# isdigit⽅法检查字符串是否由数字构成返回布尔值
print(s2.isdigit()) # False
# isalpha⽅法检查字符串是否以字⺟构成返回布尔值
print(s2.isalpha()) # False
# isalnum⽅法检查字符串是否以数字和字⺟构成返回布尔值
print(s2.isalnum()) # True

格式化字符串

在 Python 中，字符串类型可以通过 center 、 ljust 、 rjust ⽅法做居中、左对⻬和右对⻬的处理。

s = 'hello, world'
# center⽅法以宽度20将字符串居中并在两侧填充*
print(s.center(20, '*')) # ****hello, world****
# rjust⽅法以宽度20将字符串右对⻬并在左侧填充空格
print(s.rjust(20)) # hello, world
# ljust⽅法以宽度20将字符串左对⻬并在右侧填充~
print(s.ljust(20, '~')) # hello, world~~~~~~~~

我们之前讲过，在⽤ print 函数输出字符串时，可以⽤下⾯的⽅式对字符串进⾏格式化。

a = 321
b = 123
print('%d * %d = %d' % (a, b, a * b))

当然，我们也可以⽤字符串的⽅法来完成字符串的格式，代码如下所示。

a = 321
b = 123
print('{0} * {1} = {2}'.format(a, b, a * b))

从 Python 3.6 开始，格式化字符串还有更为简洁的书写⽅式，就是在字符串前加上 f 来格式化字符串， 在这种以 f 打头的字符串中， { 变量名 } 是⼀个占位符，会被变量对应的值将其替换掉，代码如下所示。

a = 321
b = 123
print(f'{a} * {b} = {a * b}')

如果需要进⼀步控制格式化语法中变量值的形式，可以参照下⾯的表格来进⾏字符串格式化操作。

变量值	占位符	格式化结果	说明
3.1415926	{:.2f}	'3.14'	保留⼩数点后两位
3.1415926	{:+.2f}	'+3.14'	带符号保留⼩数点后两位
-1	{:+.2f}	'-1.00'	带符号保留⼩数点后两位
3.1415926	{:.0f}	'3'	不带⼩数
123	{:0>10d}	0000000123	左边补 0 ，补够 10 位
123	{:x<10d}	123xxxxxxx	右边补 x ，补够 10 位
123	{:>10d}	' 123'	左边补空格，补够 10 位
123	{:<10d}	'123 '	右边补空格，补够 10 位
123456789	{:,}	'123,456,789'	逗号分隔格式
0.123	{:.2%}	'12.30%'	百分⽐格式
123456789	{:.2e}	'1.23e+08'	科学计数法格式

修剪操作

字符串的 strip ⽅法可以帮我们获得将原字符串修剪掉左右两端空格之后的字符串。这个⽅法⾮常有实⽤价值，通常⽤来将⽤户输⼊中因为不⼩⼼键⼊的头尾空格去掉， strip ⽅法还有 lstrip 和 rstrip 两个版本，相信从名字⼤家已经猜出来这两个⽅法是做什么⽤的。

s = ' jackfrued@126.com \t\r\n'
# strip⽅法获得字符串修剪左右两侧空格之后的字符串
print(s.strip()) # jackfrued@126.com