字符串及正则表达式

字符串常用操作

拼接字符串

使用 “+” 运算符可完成对多个字符串的拼接， “+” 运算符可以连续多个字符串并产生一个字符串对象。
字符串不允许直接与其他类型的数据进行拼接。

计算字符串的长度

在 Python 中，数字、英文、小数点、下划线和空格占 1 字节；一个汉字可能会占 2～4 字节，占几字节取决于采用的编码。
汉字在 GBK/GB2312 编码中占 2 字节，在 UTF-8/Unicode 中一般占 3 字节（或 4 字节）。

在 Python 中，提供了 len() 函数计算字符串的长度，语法格式如下：在 Python 中，提供了 len() 函数计算字符串的长度，语法格式如下：

len(string)

其中， string 用于指定要进行长度统计的字符串。

截取字符串

由于字符串也属于序列，所以要截取字符串，可以采用切片方法实现。通过切片方法截取字符串的语法格式如下：

string[start : end : step]

参数说明如下：

• string：表示要截取的字符串。
• start：表示要截取的第一个字符的索引（包括该字符），如果不指定，则默认为 0。
• end：表示要截取的最后一个字符的索引（不包括该字符），如果不指定则默认为字符串的长度。
• step：表示切片的步长，如果省略，则默认为 1，当忽略该步长时，最后一个冒号也可以省略。

说明：字符串的索引同序列的索引是一样的，也是从 0 开始的，并且每个字符占一个位置。

注意：在进行字符串截取时，如果指定的索引不存在，则会抛出 “string index out of range” 的异常，要解决此问题，可以采用 try…except 语句捕获异常。

分隔字符串

在 Python 中，字符串对象的 split() 方法可以实现字符串的分隔，即把一个字符串按照指定的分隔符切分为字符串列表，该列表的元素中不包括分隔符。
split() 方法的语法格式如下：

str.split(sep, maxsplit)

参数说明如下：

• str：表示要进行分隔的字符串。
• sep：用于指定分隔符，可以包含多个字符，默认为 None，即所有空字符（包括空格、换行符 “\n” 、制表符 “\t” 等）。
• maxsplit：可选参数，用于指定分隔的次数，如果不指定或者为 -1 ，则分隔次数没有限制，否则返回结果列表的元素个数最多为 maxsplit+1
• 返回值：分隔后的字符串列表。

说明：在 split() 方法中，如果不指定 sep 参数，那么也不能指定 maxsplit 参数。

说明：在使用 split() 方法时，如果不指定参数，默认采用空格符进行分隔，这时无论有几个空格，空格符都将作为一个分隔符进行分隔。
如果指定一个分隔符，那么当这个分隔符出现多个时，就会每个分隔一次，没有得到内容的，将产生一个空元素。

检索字符串

在 python 中，字符串对象提供了很多应用于字符串查找的方法，主要介绍以下下面几种方法。

1. count() 方法

count() 方法用于检索指定字符串在另一个字符串中出现的次数。如果检索的字符串不存在，则返回 0，否则返回出现的次数，其语法格式如下：

str.count(sub[, start[, end]])

参数说明如下：

• str：表示原字符串。
• sub：表示要检索的子字符串。
• start：可选参数，表示检索范围的起始位置的索引，如果不指定，则从头开始检索。
• end：可选参数，表示检索范围的结束位置的索引，如果不指定，则一直检索到结尾。

2. find() 方法

该方法用于检索是否包含指定的子字符串。如果检索的字符串不存在，则返回 ﹣1，否则返回首次出现该子字符串时的索引，其语法格式如下：

str.find(sub[, start[, end]])

参数说明如下：

• str：表示原字符串。
• sub：表示要检索的子字符串。
• start：可选参数，表示检索范围的起始位置的索引，如果不指定，则从头开始检索。
• end：可选参数，表示检索范围的结束位置的索引，如果不指定，则一直检索到结尾。

说明：如果只是想要判断指定的字符串是否存在，可以使用 in 关键字实现。
如果存在就返回 True ,否则返回 False。另外，也可以根据 find() 方法的返回值是否大于 ﹣1 来确定是否存在。

说明： Python 的字符串对象还提供了 rfind() 方法，其作用与 find() 方法类似，只是 rfind() 方法从右边开始查找。

3. index()方法

index() 方法同 find() 方法类似，也是用于检索是否包含指定的子字符串。只不过如果使用 index() 方法，当指定的字符串不存在时会抛出异常，其语法格式如下：

str.index(sub[, start[, end]])

参数说明如下：

• str：表示原字符串。
• sub：表示要检索的子字符串。
• start：可选参数，表示检索范围的起始位置的索引，如果不指定，则从头开始检索。
• end：可选参数，表示检索范围的结束位置的索引，如果不指定，则一直检索到结尾。

说明： Python 的字符串对象还提供了 rindex() 方法，其作用与 index() 方法类似，只是 rindex() 方法从右边开始查找。

4. startswith() 方法

该方法用于检索字符串是否以指定子字符串开头，如果是则返回 True ，否则返回 False。 语法格式如下：

str.startswith(prefix[, start[, end]])

参数说明如下：

• str：表示原字符串。
• prefix：表示要检索的子字符串。
• start：可选参数，表示检索范围的起始位置的索引，如果不指定，则从头开始检索。
• end：可选参数，表示检索范围的结束位置的索引，如果不指定，则一直检索到结尾。

5. endswith() 方法

该方法用于检索字符串是否以指定子字符串结尾，如果是则返回 True ，否则返回 False 。 语法格式如下：

str.endswith(suffix[, start[, end]])

参数说明如下：

• str：表示原字符串。
• suffix：表示要检索的子字符串。
• start：可选参数，表示检索范围的起始位置的索引，如果不指定，则从头开始检索。
• end：可选参数，表示检索范围的结束位置的索引，如果不指定，则一直检索到结尾。

字母的大小写转换方法

在 Python 中，字符串对象提供了 lower() 方法和 upper() 方法进行字母的大小写转换，即用于将大写字母 ABC 转换为小写字母 abc ，或者将小写字母 abc 转换为大写字母 ABC ，下面分别进行介绍。

1. lower() 方法

lower() 方法用于将字符串中的全部大写字母转换为小写字母。如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新字符串，将原字符串中每个该进行小写转换的字符都转换成等价的小写字符。字符长度与原字符长度相同。 lower() 方法的语法格式如下：

str.lower()

其中，str 为要进行转换的字符串。

2. upper() 方法

upper() 方法用于将字符串的全部小写字母转换为大写字母。如果字符串中没有应该被转换的字符，则将原字符串返回；否则返回一个新字符串，将原字符串中每个该进行大写转换的字符都转换成等价的大写字符。新字符长度与原字符长度相同。upper() 方法的语法格式如下：

str.upper()

其中，str 为要进行转换的字符串。

去除字符串中的空格和特殊字符

用户在输入数据时，可能会无意中输入多余的空格，或在一些情况下，字符串前后不允许出现空格和特殊字符，此时就需要去除字符串中的空格和特殊字符。 可以使用 Python 中提供的 strip() 函数去除字符串左右两边的空格和特殊字符，也可以使用 lstrip() 函数去除字符串左边的空格和特殊字符，或使用 rstrip() 函数去除字符串中右边的空格和特殊字符。

说明：这里的特殊字符是指制表符 (\t )、回车符 (\r )、换行符 (\n ) 等。

1. strip() 方法

strip() 方法用于去掉字符串左、右两侧的空格符和特殊字符，其语法格式如下：

str.strip([chars])

其中，str 为要去除空格的字符串；chars 为可选参数，用于指定要去除的字符，可以指定多个。
如果不指定 chars 参数，默认将去除空格、制表符 (\t)、回车符 (\r)、换行符 (\n)等。

2. lstrip() 方法

lstrip() 方法用于去掉字符串左侧的空格和特殊字符，其语法格式如下：

str.lstrip([chars])

其中，str 为要去除空格的字符串；chars 为可选参数，用于指定要去除的字符，可以指定多个。
如果不指定 chars 参数，默认将去除空格、制表符 (\t)、回车符 (\r)、换行符 (\n)等。

3. rstrip() 方法

rstrip() 方法用于去掉字符串右侧的空格和特殊字符，其语法格式如下：

str.rstrip([chars])

其中，str 为要去除空格的字符串；chars 为可选参数，用于指定要去除的字符，可以指定多个。
如果不指定 chars 参数，默认将去除空格、制表符 (\t)、回车符 (\r)、换行符 (\n)等。

格式化字符串

格式化字符串的意思是先制定一个模板，在这个模板中预留几个空位，然后根据需要填上相应的内容。这些空位需要通过指定的符号标记（也称为占位符），而这些符号还不会显示出来。在 Python 中，格式化字符串有以下两种方法。

1. 使用％操作

在 Python 中，要实现格式化字符串，可以使用 “%” 操作符，语法格式如下：

'%[-][+][0][m][.n]格式化字符'%exp

参数说明如下：

• -：可选参数，用于指定左对齐，正数前方无符号，负数前方加负号。
• +：可选参数，用于指定右对齐，正数前方加正号，负数前方加负号。
• 0：可选参数，表示右对齐，正数前方无符号，负数前方加负号，用 0 填充空白处（一般与 m 参数一起使用）。
• m：可选参数，表示占用宽度。
• .n：可选参数，表示小数点后保留的位数。
• 格式化字符：用于指定类型，其值如表 1 所示。
• exp：要转换的项。如果要指定的项有多个，需要通过元组的形式进行指定，但不能使用列表。

说明：由于使用％操作符是早期 Python 中提供的方法，自从 Python 2.6 版本开始，字符串对象提供了 format() 方法对字符串进行格式化。现在一些 Python 社区也推荐使用这种方法，所以建议大家重点学习 format() 方法的使用。

2. 使用字符串对象的 format() 方法

字符串对象提供了 format() 方法用于字符串格式化，其语法格式如下：

str.format(args)

其中， format 用于指定字符串的显示样式（模板）; args 用于指定要转换的项，如果有多项，则用逗号进行分隔。

下面重点介绍如何创建模板。在创建模板时，需要使用{}和:指定占位符，基本语法格式如下：

{[index][:[[fill]align][sign][#][width][.precision][type]]}

参数说明如下：

• index：可选参数，用于指定要设置格式的对象在参数列表中的索引位置，索引值从 0 开始。如果省略，则根据值的先后顺序自动分配。

说明：当一个模板中出现多个占位符时，指定索引位置的规范需统一，即全部采用手动指定，或者全部采用自动指定。

• fill：可选参数，用于指定空白处填充的字符。
• align：可选参数，用于指定对齐方式（值为＜表示内容左对齐；值为＞表示内容右对齐；值为＝表示内容右对齐，将符号放在填充内容的最左侧，且只对数字类型有效；值为^表示内容居中），需要配合 width 一起使用。
• sign：可选参数，用于指定有无符号数（值为＋表示正数加正号，负数加负号；值为 -表示正数不变，负数加负号；值为空格表示正数加空格，负数加负号）。
• #：可选参数，对于二进制数、八进制数和十六进制数，如果加上＃，表示会显示 0b/0o/0x 前缀，否则不显示前缀。
• width：可选参数，用于指定所占宽度。
• .precision：可选参数，用于指定保留的小数位数。
• type：可选参数，用于指定类型， format() 方法中常用的格式化字符如表 2 所示。

在实际开发中，数值类型有多种显示方式，比如货币形式、百分比形式等，使用 format() 方法可以将数值格式化为不同的形式。

正则表达式基础

在处理字符串时，经常会有查找符合某些复杂规则的字符串的需求，正则表达式就是用于描述这些规则的工具。也就是说，正则表达式就是记录文本规则的代码。

行定位符

行定位符就是用来描述字符串的边界。”^“表示行的开始：”$”表示行的结尾。如：

^tm

该表达式表示要匹配字符串 tm 的开始位置是行头，如 tm equal Tomorrow Moon 就可以匹配， 而 Tomorrow Moon equal tm 则不匹配。但如果使用：

tm$

后者可以匹配而前者不能匹配。如果要匹配的字符串可以出现在字符串的任意部分，那么可以直接写成：

tm

这样两个字符串就都可以匹配了。

元字符

其实，正则表达式里还有很多元字符，下面来看看更多的例子：

\bmr\w*\b 

匹配以字母 mr 开头的单词，先是从某个单词开始处 (\b )，然后匹配字母 mr ，接着是任意数量的字母或数字 (\w*)，最后单词结束处 (\b)。
更多常用元字符如表 3 所示：

限定符

如果想匹配特定数量的数字，正则表达式为我们提供了限定符（指定数量的字符）来实现该功能。
常见的限定符如表 4 所示：

字符类

正则表达式查找数字和字母是很简单的，因为已经有了对应这些字符集合的元字符（如\d，\w )，但是如果要匹配没有预定义元字符的字符集合（比如元音字母 a、e、i、o、u )。
只需要在方括号里列出它们就行了，像[aeiou] 就匹配任何一个英文元音字母，[.?!]匹配标点符号.、？或！。也可以轻松指定一个字符范围，像[0-9]代表的含意与 \d 是完全一致的，即一位数字。同理，[a-z0-9A-Z]也完全等同于 \w（如果只考虑英文的话）。

说明：要想匹配给定字符串中任意一个汉字，可以使用[\u4e00-\u9fa5]；如果要匹配连续多个汉字，可以使用[\u4e00-\u9fa5]+。

排除字符

在前面列出的是匹配符合指定字符集合的字符串，现在反过来，匹配不符合指定字符集合的字符串。正则表达式提供了”^”字符，这个元字符在之前也出现过，表示行的开始。而这里将会放到方括号中，表示排除的意思。例如：

[^a-zA-Z]

该表达式用于匹配一个不是字母的字符。

选择字符

试想一下，如何匹配身份证号码？首先需要了解一下身份证号码的规则，身份证号码长度为15位或者18位。如果为15位时，则全为数字；如果为18位时，前17位为数字，最后一位是校验位，可能为数字或字符X( x )。在上面的描述中，包含着条件选择的逻辑，这就需要使用选择字符 “I” 来实现，该字符可以理解为”或”，匹配身份证号码的表达式可以写成如下方式：

^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$

该表达式的意思是匹配15位数字、18位数字，或者17位数字和最后一位。最后一位可以是数字或者 X ( x )。

转义字符

正则表达式中的转义字符”\”和 Python 中的转义字符大同小异，都是将特殊字符（如”.”、”?”、”\”等）变为普通的字符。举一个 IP 地址的实例，用正则表达式匹配诸如 127.0.0.1 这样格式的 IP 地址。如果直接使用点字符，格式为：

[1-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}

这显然不对，因为”.”可以匹配一个任意字符。这时，不仅是127.0.0.1这样的 IP ，连127101011这样的字符串也会被匹配出来。所以在使用”.”时，需要使用转义字符”\”。修改上面的正则表达式为：

[1-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}

说明：括号在正则表达式中也算是一个元字符。

分组

通过之前提到过的例子，相信你已经对小括号的作用有了一定的了解。小括号的第一个作用就是可以改变限定符的作用范围，如”|” “*” “^”等。下面来看一个表达式：

(thir|four)th 

这个表达式的意思是匹配单词 thirth 或 fourth ，如果不使用小括号，那么就变成了匹配单词 thir 和 fourth 了。

小括号的第二个作用是分组，也就是子表达式。如 (\.[0-9]{1,3}){3} 就是对分组 (.[0-9]{1,3}) 进行重复操作。

在 Python 中使用正则表达式

在 Python 中使用正则表达式时，是将其作为模式字符串使用的。例如，将匹配不是字母的一个字符的正则表达式表示为模式字符串，可以使用下面的代码：

'[^a-zA-Z]'

而如果将匹配以字母 m 开头的单词的正则表达式转换为模式字符串，则不能直接在其两侧添加引号定界符，例如，下面的代码是不正确的：

'\bm\w*\b'

需要将其中的”\”进行转义，转换后的结果为：

'\\bm\\w*\\b'

由于模式字符串中可能包括大量的特殊字符和反斜杠，所以需要写为原生字符串，即在模式字符串前加 r 或 R 。例如，上面的模式字符串采用原生字符串表示就是：

r'\bm\w*\b'

说明：在编写模式字符串时，并不是所有的反斜杠都需要进行转换，例如，前面编写的正则表达式”^d {8}$”中的反斜杠就不需要转义，因为其中的 \d 并没有特殊意义。不过，为了编写方便，本分类中所写正则表达式都采用原生字符串表示。

使用 re 模块实现正则表达式操作

在之前介绍了正则表达式的语法，本节将介绍如何在 Python 中使用正则表达式。 Python 提供了 re 模块，用于实现正则表达式的操作，可以使用 re 模块提供的方法（例如，search()、match()、 findall()等）进行字符串处理，也可以先使用 re 模块的 compile ()方法将模式字符串转换为正则表达式对象，然后再使用该正则表达式对象的相关方法来操作字符串。
在使用 re 模块时，需要先应用 import 语句引入，具体代码如下：

import re

如果在使用 re 模块时，未将其引入，将抛出异常。

匹配字符串

匹配字符串可以使用 re 模块提供的 match()、 search()和 findall()等方法。下面分别进行介绍。

1. 使用 match() 方法进行匹配

match()方法用于从字符串的开始处进行匹配，如果在起始位置匹配成功，则返回 Match 对象，否则返回 None ，其语法格式如下：

re.match(pattern, string, [flags])

参数说明如下：

• pattern：表示模式字符串，由要匹配的正则表达式转换而来。
• string：表示要匹配的字符串。
• flags：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。常用的标志如表所示。

例如，匹配字符串是否以 “mr” 开头，不区分字母大小写，代码如：

01 import re 
02 pattern =  r'mr_\w+'                            ＃模式字符串
03 string = 'MR_SHOP mr_shop'                      ＃要匹配的字符串
04 match = re.match(pattern,string,re.I)           ＃匹配字符串，不区分大小写
05 print(match)                                    ＃输出匹配结果
06 string = '项目名称 MR_SHOP mr_shop'
07 match = re.match(pattern,string,re.I)           ＃匹配字符串，不区分大小写
08 print(match)                                    ＃输出匹配结果

执行结果如下：

<sre.SRE_Match object; span=(0,7), match='MR_SHOP'> 
None 

从上面的执行结果中可以看出，字符串 “MR_SHOP” 是以 “mr” 开头的，所以返回一个 Match 对象，而字符串 “项目名称 MR_SHOP” 不是以 “mr” 开头的，所以返回 “None”。这是因为 match() 方法从字符串的开始位置开始匹配，当第一个字母不符合条件时，则不再进行匹配，直接返回 None 。

Match 对象中包含了匹配值的位置和匹配数据。其中，要获取匹配值的起始位置可以使用 Match 对象的 start()方法；要获取匹配值的结束位置可以使用 end() 方法；通过 span()方法可以返回匹配位置的元组；通过 string 属性可以获取要匹配的字符串。例如下面的代码：

01 import re                                      ＃模式字符串
02 pattern = r'mr_\w+'                            ＃要匹配的字符串
03 string = 'MR_SHOP mr_shop'                     ＃匹配字符串，不区分大小写
04 match = re.match(pattern,string,re.I)
05 print ('匹配值的起始位置：',match.start())
06 print ('匹配值的结束位置：',match.end())
07 print ('匹配位置的元组：',match.span())
08 print ('要匹配的字符串：',match.string())
09 print ('匹配数据：',match.group())

执行结果如下：

匹配值的起始位置：0
匹配值的结束位置：7
匹配位置的元组：(0, 7)
要匹配的字符串：MR_SHOP mr_shop
匹配数据：MR_SHOP

2. 使用 search() 方法进行匹配

search() 方法用于在整个字符串中搜索第一个匹配的值，如果在起始位置匹配成功，则返回 Match 对象，否则返回 None ，其语法格式如下：

re.search(pattern, string, [flags])

参数说明如下：

• pattern：表示模式字符串，由要匹配的正则表达式转换而来。
• string：表示要匹配的字符串。
• flags：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。常用的标志如表 5 所示。

例如，搜索第一个以” mr “开头的字符串，不区分字母大小写，代码如下：

01 import re 
02 pattern = r'mr_\w+'                            ＃模式字符串
03 string = 'MR_SHOP mr_shop'                     ＃要匹配的字符串
04 match = re.search(pattern,string,re.I)         ＃匹配字符串，不区分大小写
05 print(match)                                   ＃输出匹配结果
06 string = '项目名称 MR_SHOP mr_shop'
07 match = re.search(pattern,string,re.I)         ＃匹配字符串，不区分大小写
08 print(match)                                   ＃输出匹配结果

执行结果如下：

<_sre.SRE_Match object; span=(0, 7), match='MR_SHOP'>
<_sre.SRE_Match object; span=(4, 11), match='MR_SHOP'>

从上面的执行结果中可以看出， search() 方法不仅仅是在字符串的起始位置搜索，其他位置有符合的匹配也可以。

3. 使用 findall() 方法进行匹配

findall() 方法用于在整个字符串中搜索所有符合正则表达式的字符串，并以列表的形式返回。如果匹配成功，则返回包含匹配结构的列表，否则返回空列表，其语法格式如下：

re.findall(pattern, string, [flags])

参数说明如下：

• pattern：表示模式字符串，由要匹配的正则表达式转换而来。
• string：表示要匹配的字符串。
• flags：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。常用的标如表 5 所示。

例如，搜索以 “mr” 开头的字符串，代码如下：

01 import re 
02 pattern = r'mr_\w+'                           ＃模式字符串
03 string = 'MR_SHOP_mr_shop'                    ＃要匹配的字符串
04 match = re.findall(pattern,string,re.I)       ＃搜索字符串，不区分大小写
05 print(match)                                  ＃输出匹配结果
06 string = '项目名称 MR_SHOP mr_shop'
07 match = re.findall(pattern,string)            ＃搜索字符串，区分大小写
08 print(match)                                  ＃输出匹配结果

执行结果如下：

['MR_SHOP','mr_shop']
['mr_shop']

如果在指定的模式字符串中包含分组，则返回与分组匹配的文本列表，例如：

01 import re 
02 pattern = r'[1-9]{1,3}(\.[0-9]{1,3}){3}'       ＃模式字符串
03 strl ='127.0.0.1 192.168.1.66'                 ＃要配置的字符串
04 match = re.findall(pattern,strl)               ＃进行模式匹配
05 print(match)

上面代码的执行结果如下：

['.1', '.66']

从上面的结果中可以看出，并没有得到匹配的 IP 地址，这是因为在模式字符串中出现了分组，所以得到的结果是根据分组进行匹配的结果，即 “(.\[ 0-9]{1,3})” 匹配的结果。如果想获取整个模式字符串的匹配，可以将整个模式字符串使用一对小括号进行分组，然后在获取结果时只取返回值列表的每个元素（是一个元组）的第1个元素，代码如下：

01 import re 
02 pattern = r'([1-9]{1,3}(\.[0-9]{1,3}){3})'       ＃模式字符串
03 strl = '127.0.0.1 192.168.1.66'                  ＃要配置的字符串
04 match = re.findall(pattern,str1)                 ＃进行模式匹配
05 for item in match:
06 print(item[0])

执行结果如下：

127.0.0.1
192.168.1.66

替换字符串

sub()方法用于实现字符串替换，其语法格式如下：

re.sub(pattern, repl, string, count, flags)

参数说明如下：

• pattern：表示模式字符串，由要匹配的正则表达式转换而来。
• repl：表示替换的字符串。
• string：表示要被查找替换的原始字符串。
• count：可选参数，表示模式匹配后替换的最大次数，默认值为 0 ，表示替换所有的匹配。
• flags：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。常用的标志如表 5 所示。

使用正则表达式分隔字符串

split() 方法用于实现根据正则表达式分隔字符串，并以列表的形式返回。其作用同6.1.4节介绍的字符串对象的 split() 方法类似，所不同的就是分隔字符由模式字符串指定。其语法格式如下：

re.split(pattern, string, [maxsplit], [flags])

参数说明如下：

• pattern：表示模式字符串，由要匹配的正则表达式转换而来。
• string：表示要匹配的字符串。
• maxsplit：可选参数，表示最大的拆分次数。
• flags：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写。常用的标志如表 5 所示。