数据结构——字符串

发表于 更新于 分类于 评论数： 阅读次数： 本文字数： 10k 阅读时长 ≈ 17 分钟

本章概述：python基础——字符串的基本使用

一、字符编码

在将字符串使用之前，我们有必要先了解一下字符编码。字符串也是一种数据类型，但是，字符串比较特殊的是还有一个编码问题。

1、ASCII编码

因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），如果要表示更大的整数，就必须用更多的字节。比如两个字节可以表示的最大整数是65535，4个字节可以表示的最大整数是4294967295。

由于计算机是美国人发明的，因此，最早只有127个字符被编码到计算机里，也就是大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码，比如大写字母A的编码是65，小写字母z的编码是122，因此，ASCII编码为一个字节。

2、GB2312及其他编码

前面说过了，ASCII编码为一个字节，但是要处理中文显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。

你可以想得到的是，全世界有上百种语言，日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里，各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。

3、Unicode字符

Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。

Unicode标准也在不断发展，但最常用的是UCS-16编码，用两个字节表示一个字符（如果要用到非常偏僻的字符，就需要4个字节）。

ASCII编码和Unicode编码的区别：ASCII编码是1个字节，而Unicode编码通常是2个字节。

字母A用ASCII编码是十进制的65，二进制的01000001；

字符0用ASCII编码是十进制的48，二进制的00110000，注意字符'0'和整数0是不同的；

汉字中已经超出了ASCII编码的范围，用Unicode编码是十进制的20013，二进制的01001110 00101101。

把ASCII编码的A用Unicode编码，只需要在前面补0就可以，因此，A的Unicode编码是00000000 01000001。

4、可变长编码——UTF-8

Unicode不会出现乱码问题，也能把全球的所有文字字符都表示进去，但是新的问题又出现了：如果统一成Unicode编码，乱码问题从此消失了。但是，如果你写的文本基本上全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。

所以，本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间。

字符 ASCII Unicode UTF-8
A 01000001 00000000 01000001 01000001
中 无 01001110 00101101 11100100 10111000 10101101

UTF-8编码有一个额外的好处，就是ASCII编码实际上可以被看成是UTF-8编码的一部分，所以，大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作

5、字符编码工作方式

在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件。浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器。所以你看到很多网页的源码上会有类似<meta charset="UTF-8" />的信息，表示该网页正是用的UTF-8编码。

二、python的字符串

1、python字符串的编码方式

在python3中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言。

1
2
3
s1 = 'hello, world!'
s2 = "你好，世界！"
print(s1, s2)

Python提供了ord()函数获取字符的Unicode值，chr()函数把Unicode值转换为对应的字符。

1
2
3
4
5
6
7
8
9
10
>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'
>>> chr(0x4e2d)
'中'

如果知道字符的整数编码，还可以用十六进制这么写str：

1
2
>>> '\u4e2d\u6587'
'中文'
2、编码和解码

Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。

纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。Python对bytes类型的数据用带b前缀的单引号或双引号表示。

1
2
3
4
5
6
7
8
>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
>>> '中文'.encode('ascii')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

在bytes中，无法显示为ASCII字符的字节，用\x##显示。

反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法。

1
2
3
4
>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'

如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节

1
2
>>> b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')
'中'
3、字符串驻留机制

字符串驻留：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。

Python 支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线（_）、字母和数字）会启用字符串驻留机制。也就是说，当定义多个相同的符合上述所说的规则的字符串时，在内存中仅保留一份，然后将变量映射到相同的内存中去。

1
2
3
4
5
6
7
8
9
10
11
12
>>> a='abc123'
>>> b='abc123'
>>> id(a)
3134634372784
>>> id(b)
3134634372784
>>> c='a!'
>>> d='a!'
>>> id(c)
3134634353072
>>> id(d)
3134629631472

上面的例子可以发现，a和b指向同一个内存地址，c和d则不是。因为ab负责字符串驻留机制的规则，cd不符合驻留机制。

三、字符串基本使用

1、转义字符和原始字符

可以在字符串中使用\（反斜杠）来表示转义，也就是说\后面的字符不再是它原来的意义，例如：\n不是代表反斜杠和字符n，而是表示换行；\t也不是代表反斜杠和字符t，而是表示制表符。所以如果字符串本身又包含了'、"、\这些特殊的字符，必须要通过\进行转义处理

Python中的字符串可以r或R开头，这种字符串被称为原始字符串，意思是字符串中的每个字符都是它本来的含义，没有所谓的转义字符。例如，在字符串'hello\n'中，\n表示换行；而在r'hello\n'中，\n不再表示换行，就是反斜杠和字符n。所以当需要转义时则使用反斜杠，不需要时以r开头即可。

2、字符串运算

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

2.1、拼接和重复

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

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!!!
2.2、比较运算

对于两个字符串类型的变量，可以直接使用比较运算符比较两个字符串的相等性或大小。前面讲编码的时候也有讲到，字符串在内存中是以Unicode表示的，所以字符串的大小比较比的是每个字符对应的编码的大小。例如A的编码是65， 而a的编码是97，所以'A' < 'a'的结果相当于就是65 < 97的结果，很显然是True；而'boy' < 'bad'，因为第一个字符都是'b'比不出大小，所以实际比较的是第二个字符的大小，显然'o' < 'a'的结果是False，所以'boy' < 'bad'的结果也是False。至于字符的编码是多少，前面也有说过，可以用ord函数获得。下面的代码为大家展示了字符串的比较运算。

1
2
3
4
5
6
7
8
9
10
11
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('度'))    #30334 24230
s4 = '王大锤'
print(ord('王'), ord('大'), ord('锤'))    # 29579 22823 38180
print(s3 > s4, s3 <= s4)      # True False

Python中还有一个is运算符（身份运算符），如果用is来比较两个字符串，它比较的是两个变量对应的字符串对象的内存地址，简单的说就是两个变量是否对应内存中的同一个字符串。另外还可以通过id函数来查看变量在内存中的位置。

1
2
3
4
5
6
7
8
s1 = 'hello world'
s2 = 'hello world'
s3 = s2
# 比较字符串的内容
print(s1 == s2, s2 == s3)    # True True
# 比较字符串的内存地址
print(s1 is s2, s2 is s3)    # False True
print(id(s1),id(s2),id(s3))   #1800411810608 1800411810800 1800411810800
2.3、成员运算

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
2.4、获取字符串长度

函数len可以获取字符串长度

1
2
s = 'hello, world'
print(len(s))                   # 12

如果想获取字节数，则需要把字符串编码成bytes。

1
len('中文'.encode('utf-8'))   #6
2.5、索引和切片

我们可以从字符串中取出某个字符，称为索引计算，索引从0开始，0代表字符串中的第一个字符，因此长度为n的字符串，索引范围为0到n-1，最后一个字符的索引也可以表示为-1，所以索引范围也可以是-1到-n。注意，因为字符串是不可变类型，所以不能通过索引运算修改字符串中的字符。

1
2
3
4
5
6
7
name = "blog.z7sz.top"
length=len(name)

# 获取第一个字符
print(name[0],name[-length])   #b  b
# 获取最后一个字符
print(name[-1],name[length-1])  #p

在进行索引操作时，如果索引越界（不在索引范围内）时，会引发IndexError异常。

如果要从字符串中取出多个字符，我们可以对字符串进行切片，运算符是[i:j:k]，其中i是开始索引，索引对应的字符可以取到；j是结束索引，索引对应的字符不能取到；k是步长，默认值为1。假设字符串的长度为N，当k > 0时表示正向切片（从前向后获取字符），如果没有给出i和j的值，则i的默认值是0，j的默认值是N；当k < 0时表示负向切片（从后向前获取字符），如果没有给出i和j的值，则i的默认值是-1，j的默认值是-N - 1。

1
2
3
4
5
6
7
8
9
10
name = "blog.z7sz.top"

# k=1的正向切片操作
print(name[0:3])  #blo
print(name[-7:-4])   #7sz
# k=2的正向切片操作
print(name[0:3:2])   #bo
# k=-1的负向切片操作
print(name[7:1:-1])   #s7z.go
print(name[::-1])   #pot.zs7z.golb  字符串倒序的一种方法
2.6、循环遍历每个字符
1
2
3
s1 = 'hello'
for ch in s1:
    print(ch)

3、字符串的方法

在Python中，我们可以通过字符串类型自带的方法对字符串进行操作和处理。

3.1、大小写相关操作
1
2
3
4
5
6
7
8
9
10
11
12
13
name = "blog.z7sz.top"

# 把字符串中的第一个字符首字母大写
print(name.capitalize())  

# 把字符串中每一个单词的首字母大写
print(name.title())  

# 转换字符串中所有大写字符为小写
print(name.lower())  

# 转换字符串所有小写字符为大写
print(name.upper())
3.2、查找操作
1
2
3
4
5
6
7
8
# 寻找字符（find，rfind，index，rindex）
print(name.find("a"))  # 从左到右找，直至找到想要寻找的字符串的位置位置，找不到则返回-1
print(name.rfind("z"))  # 从右往左找，直至找到想要寻找的字符串的位置位置，找不到则返回-1
print(name.index("a"))  # 用法跟find一样，找不到报错
print(name.rindex("z"))  # 用法跟rfind一样，找不到报错

print(name.find('o', 5))   # 从索引为5的位置开始查找字符o出现的位置
print(name.index('o', 5))   # 从索引为5的位置开始查找字符o出现的位置
3.3、性质判断

可以通过字符串的startswith、endswith来判断字符串是否以某个字符串开头和结尾；还可以用is开头的方法判断字符串的特征，这些方法都返回布尔值。

1
2
3
4
5
6
7
8
9
10
11
12
# 检查开头和结尾字符串
print(name.startswith("z"))  # 检查字符串是否是以某字符开头，返回布尔类型
print(name.endswith("z"))  # 检查字符串是否是以某字符结尾，返回布尔类型

# isdigit方法检查字符串是否由数字构成返回布尔值
print("12www".isdigit())    # False
# isalpha方法检查字符串是否以字母构成返回布尔值
print("12www".isalpha())    # False
# isalnum方法检查字符串是否以数字和字母构成返回布尔值
print("12www".isalnum())    # True
# isspace方法检查字符串中只包含空格，则返回true
print("   ".isspace())  #True
3.4、格式化字符串

在Python中，字符串类型可以通过center、ljust、rjust方法做居中、左对齐和右对齐的处理。如果要在字符串的左侧补零，也可以使用zfill方法。

1
2
3
4
5
6
7
8
9
10
11
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('33'.zfill(5))      # 00033
print('-33'.zfill(5))     # -0033

在用print函数输出字符串时，可以用下面的方式对字符串进行格式化。

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

我们也可以用字符串的方法来完成字符串的格式。

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

c=17.125
print("{0:.2f}%".format(c))   #17.12%

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

1
2
3
4
5
6
a = 321
b = 123
print(f'{a} * {b} = {a * b}')

c=17.125
print(f"{c:.2f}%")

字符串格式化更多操作参照以下表格

变量值 占位符 格式化结果 说明
3.1415926 {:.2f} '3.14' 保留小数点后两位
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' 科学计数法格式
3.5、删除字符
1
2
3
4
# 删除字符，一般用来删除两端或一段的空字符
print("aabuafngg".lstrip("a"))  # 删除最左边的n个相同字符，默认为空字符
print("aabuafngg".rstrip("a"))  # 删除最右边的n个相同字符，默认为空字符
print("aabuafngg".strip("a"))  # 删除最左边或者最右边的n个相同字符，默认为空字符
3.6、替换操作

replace方法的第一个参数是被替换的内容，第二个参数是替换后的内容，还可以通过第三个参数指定替换的次数。

1
2
3
# 替换（replace）
print(name.replace("blog", "z7sz"))
print(name.replace("z", "b", 1))  # 数字表示替换几个
3.7、分割/合并操作

可以使用字符串的split方法将一个字符串拆分为多个字符串（放在一个列表中），也可以使用字符串的join方法将列表中的多个字符串连接成一个字符串。

1
2
3
4
s = 'I love you'
words = s.split()
print(words)            # ['I', 'love', 'you']
print('#'.join(words))  # I#love#you

split方法默认使用空格进行拆分，我们也可以指定其他的字符来拆分字符串，而且还可以指定最大拆分次数来控制拆分的效果。

1
2
3
4
5
s = 'I#love#you#so#much'
words = s.split('#')
print(words)  # ['I', 'love', 'you', 'so', 'much']
words = s.split('#', 3)
print(words)  # ['I', 'love', 'you', 'so#much']
3.8、其他方法

对于字符串类型来说，还有一个常用的操作是对字符串进行匹配检查，即检查字符串是否满足某种特定的模式。例如，一个网站对用户注册信息中用户名和邮箱的检查，就属于模式匹配检查。实现模式匹配检查的工具叫做正则表达式，Python语言通过标准库中的re模块提供了对正则表达式的支持，正则表达式这里不讲，涉及到更深层次的知识。

1
2
# 计算某字符出现的频率
print(name.count("n"))