字符串的定义
所谓字符串，就是由零个或多个字符组成的有限序列。
在Python程序中，如果我们把单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。字符串中的字符可以是特殊符号、英文字母、中文字符、日文的平假名或片假名、希腊字母、Emoji字符等。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
s1 = 'hello, world!'
s2 = "你好，世界！"
print(s1, s2)
# 以三个双引号或单引号开头的字符串可以折行
s3 = ''' #s3包括两个换行符加上两行hello,world!
hello,
world!
'''
print(s3, end='')
"""
hello, world! 你好，世界！
hello,
world!
"""
|
提示：print函数中的end=''表示输出后不换行，即将默认的结束符\n（换行符）更换为''（空字符）。
转义字符串和原始字符串
可以在字符串中使用\（反斜杠）来表示转义，也就是说\后面的字符不再是它原来的意义，例如：\n不是代表反斜杠和字符n，而是表示换行；\t也不是代表反斜杠和字符t，而是表示制表符。所以如果字符串本身又包含了'、"、\这些特殊的字符，必须要通过\进行转义处理。例如要输出一个带单引号或反斜杠的字符串，需要用如下所示的方法。
1
2
3
4
5
6
7
8
9
|
s1 = '\'hello, world!\''
print(s1)
s2 = '\\hello, world!\\'
print(s2)
"""
'hello, world!'
\hello, world!\
"""
|
Python中的字符串可以r或R开头，这种字符串被称为原始字符串，意思是字符串中的每个字符都是它本来的含义，没有所谓的转义字符。例如，在字符串'hello\n'中，\n表示换行；而在r'hello\n'中，\n不再表示换行，就是反斜杠和字符n。大家可以运行下面的代码，看看会输出什么。
1
2
3
4
5
6
7
8
9
10
11
12
|
# 字符串s1中\t是制表符，\n是换行符
s1 = '\time up \now'
print(s1)
# 字符串s2中没有转义字符，每个字符都是原始含义
s2 = r'\time up \now'
print(s2)
"""
ime up
ow
\time up \now
"""
|
python中还允许在\后面还可以跟一个八进制或者十六进制数来表示字符，例如\141和\x61都代表小写字母a，前者是八进制的表示法，后者是十六进制的表示法。另外一种表示字符的方式是在\u后面跟Unicode字符编码
1
2
3
4
5
6
7
|
s1 = '\141\142\143\x61\x62\x63'
s2 = '\u5b54\u51e1\u8dc3'
print(s1, s2)
"""
abcabc 孔凡跃
"""
|
字符串的运算
Python为字符串类型提供了非常丰富的运算符，我们可以使用+运算符来实现字符串的拼接，可以使用*运算符来重复一个字符串的内容，可以使用in和not in来判断一个字符串是否包含另外一个字符串，我们也可以用[]和[:]运算符从字符串取出某个字符或某些字符。
拼接和重复
下面的例子演示了使用+和*运算符来实现字符串的拼接和重复操作。
1
2
3
4
5
6
7
8
|
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!!!
|
比较运算
对于两个字符串类型的变量，可以直接使用比较运算符比较两个字符串的相等性或大小。需要说明的是，因为字符串在计算机内存中也是以二进制形式存在的，那么字符串的大小比较比的是每个字符对应的编码的大小。例如A的编码是65， 而a的编码是97，所以'A' < 'a'的结果相当于就是65 < 97的结果，很显然是True；而'boy' < 'bad'，因为第一个字符都是'b'比不出大小，所以实际比较的是第二个字符的大小，显然'o' < 'a'的结果是False，所以'boy' < 'bad'的结果也是False。
如果不清楚两个字符对应的编码到底是多少，可以使用ord函数来获得，例如ord('A')的值是65。
1
2
3
4
5
6
7
8
|
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('凡'),ord('跃')) # 23380 20961 36291
|
需要强调一下的是，字符串的比较运算比较的是字符串的内容，Python中还有一个is运算符（身份运算符），如果用is来比较两个字符串，它比较的是两个变量对应的字符串是否在内存中相同的位置（内存地址），简单的说就是两个变量是否对应内存中的同一个字符串。看看下面的代码就比较清楚is运算符的作用了。
1
2
3
4
5
6
7
|
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，代码如下所示。
1
2
3
4
|
s1 = 'hello, world'
print('wo' in s1) # True
s2 = 'goodbye'
print(s2 in s1) # False
|
获取字符串长度
获取字符串长度没有直接的运算符，而是使用内置函数len，我们在上节课的提到过这个内置函数，代码如下所示。
1
2
3
|
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则是第一个字符的索引，通常称之为负向索引。
注意，因为字符串是不可变类型，所以**不能通过索引运算修改字符串中的字符**。在进行索引操作时，如果索引越界（正向索引不在0到N-1范围，负向索引不在-1到-N范围），会引发IndexError异常，错误提示信息为：string index out of range（字符串索引超出范围）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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
|
如果要从字符串中取出多个字符，我们可以对字符串进行切片，运算符是[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就行了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
s = 'abc123456' # len=9
# 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👎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循环对字符串进行遍历，有两种方式。
方式一：
1
2
3
|
s1 = 'hello'
for index in range(len(s1)): # 类似于数组下标
print(s1[index])
|
方式二：
1
2
3
|
s1 = 'hello'
for ch in s1: # 直接取
print(ch)
|
大小写
1
2
3
4
5
6
7
8
9
10
11
12
|
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方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
|
s = 'hello, world!'
# find方法从字符串中查找另一个字符串所在的位置
# 找到了返回字符串中另一个字符串首字符的索引
print(s.find('or')) # 8
# 找不到返回-1
print(s.find('hh')) # -1
# index方法与find方法类似
# 找到了返回字符串中另一个字符串首字符的索引
print(s.index('or')) # 8
# 找不到引发异常
print(s.index('hh')) # ValueError: substring not found
|
在使用find和index方法时还可以通过方法的参数来指定查找的范围，也就是查找不必从索引为0的位置开始。find和index方法还有逆向查找（从后向前查找）的版本，分别是rfind和rindex，代码如下所示。
1
2
3
4
5
6
7
8
|
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开头的方法判断字符串的特征，这些方法都返回布尔值，代码如下所示。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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方法做居中、左对齐和右对齐的处理。
1
2
3
4
5
6
7
8
|
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函数输出字符串时，可以用下面的方式对字符串进行格式化。
1
2
3
|
a = 321
b = 123
print('%d * %d = %d' % (a, b, a * b))
|
当然，我们也可以用字符串的方法来完成字符串的格式，代码如下所示。
1
2
3
|
a = 321
b = 123
print('{0} * {1} = {2}'.format(a, b, a * b))
|
从Python 3.6开始，格式化字符串还有更为简洁的书写方式，就是在字符串前加上f来格式化字符串，在这种以f打头的字符串中，{变量名}是一个占位符，会被变量对应的值将其替换掉，代码如下所示。
1
2
3
|
a = 321
b = 123
print(f'{a} * {b} = {a * b}')
|
如果需要进一步控制格式化语法中变量值的形式，可以参照下面的表格来进行字符串格式化操作。print({a:.2f})
| 变量值 |
占位符 |
格式化结果 |
说明 |
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两个版本
1
2
3
4
5
6
7
8
9
10
11
|
s = ' 1939667131@qq.com \t\r\n'
# strip方法获得字符串修剪左右两侧空格之后的字符串
print(s.strip())
print(s.lstrip())
print(s.rstrip())
"""
1939667131@qq.com
1939667131@qq.com
1939667131@qq.com
"""
|
字符串常用操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
import pyperclip
# 转义字符
print('My brother\'s name is \'007\'')
# My brother's name is '007'
# 原始字符串
print(r'My brother\'s name is \'007\'')
# My brother\'s name is \'007\'
str = 'hello123world'
print('he' in str)
print('her' in str)
# 字符串是否只包含字母
print(str.isalpha())
# 字符串是否只包含字母和数字
print(str.isalnum())
# 字符串是否只包含数字
print(str.isdecimal())
print(str[0:5].isalpha())#hello
print(str[5:8].isdecimal())#123
list = ['床前明月光', '疑是地上霜', '举头望明月', '低头思故乡']
print('-'.join(list))
# 床前明月光-疑是地上霜-举头望明月-低头思故乡
sentence = 'You go your way I will go mine'
words_list = sentence.split()
print(words_list)
# ['You', 'go', 'your', 'way', 'I', 'will', 'go', 'mine']
email = ' jackfrued@126.com '
print(email)
print(email.strip())
print(email.lstrip())
# jackfrued@126.com
# jackfrued@126.com
# jackfrued@126.com
# 将文本放入系统剪切板中
pyperclip.copy('老虎不发猫你当我病危呀')
# 从系统剪切板获得文本
# print(pyperclip.paste())
|
实现字符串倒转的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
from io import StringIO
def reverse_str1(str):
return str[::-1]
def reverse_str2(str):
if len(str) <= 1:
return str
return reverse_str2(str[1:]) + str[0:1]
def reverse_str3(str):
# StringIO对象是Python中的可变字符串
# 不应该使用不变字符串做字符串连接操作 因为会产生很多无用字符串对象
rstr = StringIO()
str_len = len(str)
for index in range(str_len - 1, -1, -1):
rstr.write(str[index])
"""
n
no
noh
noht
nohty
nohtyP
nohtyP
nohtyP e
nohtyP ev
nohtyP evo
nohtyP evol
nohtyP evol
nohtyP evol I
"""
return rstr.getvalue()
def reverse_str4(str):
return ''.join(str[index] for index in range(len(str) - 1, -1, -1))
def reverse_str5(str):
# 将字符串处理成列表
str_list = list(str)
str_len = len(str)
# 使用zip函数将两个序列合并成一个产生元组的迭代器
# 每次正好可以取到一前一后两个下标来实现元素的交换
for i, j in zip(range(str_len // 2), range(str_len - 1, str_len // 2, -1)):
str_list[i], str_list[j] = str_list[j], str_list[i]
# 将列表元素连接成字符串
return ''.join(str_list)
if __name__ == '__main__':
str = 'I love Python'
print(reverse_str1(str))
print(str)
print(reverse_str2(str))
print(str)
print(reverse_str3(str))
print(str)
print(reverse_str4(str))
print(str)
print(reverse_str5(str))
print(str)
|