本篇索引
（1）字符串常用方法
（2）字符串常量
（4）正则表达式
（1）字符串常用方法
Python3中，字符串全都用Unicode形式，所以省去了很多以前各种转换与声明的麻烦。字符串属于序列，所有序列可用的方法（比如切片等）都可用于字符串。
注意：字符串属于不可变序列，所有处理修改字符的方法，都会生成一个新字符串返回，原字符串不会变。
| 字符串方法 | 简述 | 举例或说明 | |
|---|---|---|---|
| 字符串内容检查 | |||
| s.isalpha() | 是否所有字符都为字母 |
'abc'.isalpha() # 结果为 True |
|
| s.islower() | 字符串中字母是否都为小写（无视其中的非字母字符） |
'abc'.islower() # 结果为 True |
|
| s.isupper() | 字符串中字母是否都为大写（无视其中的非字母字符） |
'ABC'.isupper() # 结果为 True |
|
| s.isdecimal() | 是否所有字符都为数字0~9（小数点和正负号视作非数字） |
'123'.isdedimal() # 结果为 True |
|
| s.isdigit() | 是否所有字符都为：数字0~9、罗马数字（小数点和正负号视作非数字） |
'Ⅳ'.isdigit() # 结果为 True |
|
| s.isnumeric() | 是否所有字符都为：数字0~9、罗马数字、汉字数字（小数点和正负号视作非数字） |
'一百'.isnumeric() # 结果为 True |
|
| s.isalnum() | 是否所有字符都为字母或数字 |
'abc123'.isalnum() # 结果为 True |
|
| s.isspace() | 是否所有字符都为空白 |
' '.isspace() # 结果为 True |
|
| s.isprintable() | 是否所有字符都可打印。 |
'a '.isprintable() # 结果为 False |
|
| s.isascii() | 是否所有字符都为ascii码范围内字符 |
'a1#'.isascii() # 结果为 True |
|
| s.istitle() | 是否字符串中每个单词首字母都为大写（若单词首字符为非字母字符，则判断第2个字符，以此类推） |
'Ab 2Cc'.istitle() # 结果为 True |
|
| s.isidentifier() | 字符串内容是否为Python保留字 |
'if'.isidentifier() # 结果为 True |
|
| 子串查找与判断 | |||
| s.startswith(prefix [,start [,end]]) | 检查字符串是否以prefix开头，start, end为查找范围（用法同切片）。 |
'abc'.startswith('ab') # 结果为 True |
|
| s.endswith(suffix [,start [,end]]) | 检查字符串是否以suffix结尾，start, end为查找范围（用法同切片）。 |
'abc'.endswith('b') # 结果为 False 'abc'.endswith('b',0,2) # 结果为 True |
|
| s.find(sub [,start [,end]]) | 查找指定字符串sub首次出现的位置，若没找到则返回-1。start, end为查找范围（用法同切片）。 |
'abcabc'.find('bc') # 结果为 1 |
|
| s.rfind(sub [,start [,end]]) | 查找指定字符串sub最后一次出现的位置，若没找到则返回-1，start, end用法同上。 |
'abcabc'.rfind('bc') # 结果为 4 |
|
| s.index(sub [,start [,end]]) | 功能同s.find()，区别是没找到时引发ValueError错误。 |
'abcabc'.index('bc') # 结果为 1 |
|
| s.rindex(sub [,start [,end]]) | 功能同s.rfind()，区别是没找到时引发ValueError错误。 |
'abcabc'.index('bc') # 结果为 4 |
|
| s.count(sub [,start [,end]]) | 统计指定子字符串sub出现的次数，start和end为查找范围（用法同切片）。 |
'abc'.count('b',1,1) # 结果为 0 'abc'.count('b',1,2) # 结果为 1 |
|
| 字符串修改 | |||
| s.lower() | 返回新字符串，内容为将原字符串中字母全转成小写（非字母字符则不变） |
'A1B2'.lower() # 返回为 'a1b2' |
|
| s.upper() | 返回新字符串，内容为将原字符串中字母全转成大写（非字母字符则不变） |
'a1b2'.upper() # 返回为 'A1B2' |
|
| s.swapcase() | 返回新字符串，内容为将原字符串中字母大小写互换（非字母字符则不变） |
'abCD'.swapcase() # 返回为 'ABcd' |
|
| s.capitalize() | 返回新字符串，内容为将原字符串中每个单词的首字母变为大写。 |
'ab cd'.capitalize() # 返回为 'Ab Cd; |
|
| s.expandtabs(tabsize=8) | 返回新字符串，内容用空格替换制表符，入参为tab对应的空格数。 |
a b'.expandtabs(4) # 返回为 'a b' |
|
| s.replace(old, new [,count]) | 返回新字符串，内容为用new替换原字符串中old内容，count可指定替换次数（默认为全部替换） |
'abcdab'.replace('ab','xy') # 返回为 'xycdxy' |
|
| 字符串格式简单处理 | |||
| s.strip([chars]) | 返回新字符串，内容为删掉原字符串中两边的空白。若指定入参chars，则为删掉原字符串两端在入参chars中出现的字符。 |
' abc '.strip() # 返回为 'abc' 'www.xyz.com'.strip('.cwom') # 返回为 'xyz' |
|
| s.lstrip([chars]) | 用法同上，不过仅处理字符串的左边。 |
'www.xyz.com'.lstrip('.cwom') # 返回为 'xyz.com' |
|
| s.rstrip([chars]) | 用法同上，不过仅处理字符串的右边。 |
'www.xyz.com'.rstrip('.cwom') # 返回为 www.xyz' |
|
| s.center(width [,fillchar]) | 返回新字符串，在长度为width的宽度内将原字符串居中，fillchar为填充单字符 |
'abc'.center(9,'*') # 返回为 '***abc***' |
|
| s.ljust(width [,fillchar]) | 返回新字符串，在长度为width的宽度内将原字符串靠左对齐，fillchar为填充单字符 |
'abc'.ljust(9,'*') # 返回为 'abc******' |
|
| s.rjust(width [,fillchar]) | 返回新字符串，在长度为width的宽度内将原字符串靠右对齐，fillchar为填充单字符 |
'abc'.rjust(9,'*') # 返回为 '******abc' |
|
| s.zfill(width) | 返回新字符串，在原字符串左边填充0，直至其宽度为width |
'abc'.zfill(9) # 返回为 '000000abc' |
|
| s.translate(table) | 字符映射转换。使用一个转换表table，将字符串中的某个子串映射成另一个子串。转换table由下面的maketrans()方法生成。 |
t=str.maketrans({'ab':'cd'}) 'abc'.translate(t) # 返回为 'cdc' t2=str.maketrans('ab','xy') 'abc'.translate(t2) # 返回为 'xyc' t3=str.maketrans('ab','xy',c) 'abc'.translate(t3) # 返回为 'xy' |
|
| s.maketrans(x [,y [,z]]) | 静态方法。生成一个供上面translate()方法是用的转换表，其中原始子串和映射后子串必须长度相同。若只提供一个参数：x必须为一个字典，键名表示原始子串，值表示映射后子串。若提供2个参数：x表示原始子串，y表示映射后子串。若提供3个参数：x, y含义不变，z表示要删除的子串。 | ||
| 完整字符串格式化方法 | |||
| s.format(*args, **kwargs) | 字符串格式化方法 | ||
| s.format_map(mapping) | Python3.2新增方法，可以直接使用字典作为输入参数进行字符串格式化。 |
比较：format()与format_map() 'Hi {name}!'.format(name='Tom') # 结果为 'Hi Tom!' d={'name':'Tom'} 'Hi {name}!'.format_map(d) # 结果为 'Hi Tom!' |
|
| 字符串分割与拼接 | |||
| s.split(sep=None, maxsplit=-1) | 将字符串以sep作为分隔符进行划分，将划分后的每个片段子串排成一个列表返回。maxsplit是划分的最大次数（默认-1为不设上限）。若在字符串中没找到指定分隔符，则将原字符串作为单一元素放入列表。 |
'a,b,c'.split(',') # 结果为 ['a','b','c'] |
|
| s.rsplit(sep=None, maxsplit=-1) | 用法同上，只不过是从右边开始划分字符串，列表中内容的顺序仍旧为从左到右。详见右例。 |
'a,b,c'.rsplit(',',maxsplit=1) # 结果为 ['a,b','c'] 'a,b,c'.rsplit(',') # 结果仍为 ['a','b','c'] |
|
| splitlines([keepends]) | 将多行字符串按行进行分隔成列表，若参数keepends为True，则保留每行后的换行符。 |
x="""a b""" x.splitlines() # 结果为 ['a','b'] x.splitlines(True) # 结果为 ['a ','b'] |
|
| s.partition(sep) | 用分隔符字符串sep划分字符串，返回一个元祖(head, sep, tail)。若没找到sep，则返回(s, "", "") |
'a;b;c'.partition(';') # 结果为 ('a', ';', 'b;c') |
|
| s.rpartition(sep) | 用法同上，只不过是从右边开始划分字符串，详见右例。 |
'a;b;c'.rpartition(';') # 结果为 ('a;b', ';', 'c') |
|
| s.join(iter) | 用s作为分隔符，将iter中所有迭代对象拼接成一个字符串返回。 |
';'.join('abc') # 结果为 'a;b;c' ';'.join(['ab','cd']) # 结果为 'ab;cd' |
|
| 字符串编码 | |||
| s.encoding(encoding="utf-8", errors="sctrict") | 返回字符串的编码后字节流版本，返回类型为bytes。默认为严格检错模式，只要在转换过程中发现错误，即引发UnicodeError错误。 |
常用的encoding参数： 'ascii'、'utf-16'、'utf-32'、 'gb2312'（国标）、 'gbk' (gb2312的超集) |
|
（2）字符串常量
string模块包含很多有用的常量，详见下表：
| 常量 | 简述 |
|---|---|
| string.digits | 字符串 '0123456789' |
| string.octdigits | 字符串 '01234567' |
| string.hexdigits | 字符串 '0123456789abcdefABCDEF' |
| string.ascii_lowercase | 字符串 'abcdefghijklmnopqrstuvwxyz' |
| string.ascii_uppercase | 字符串 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' |
| string.ascii_letters | 字符串 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' |
| string.punctuation | 由ASCII标点符号字符组成的字符串 |
| string.whitespace | 包括：空格、制表符（ ）、换行（ ）、回车（ ）、垂直制表符（v）、换页（f） |
| string.printable | 可打印字符组成的字符串，是digits, ascii_letters, punctuation, whitespace的组合 |
（3）模板字符串Template
string模块的Template类型也可以进行简单的“字符串格式化”。用法如下：
（1）生成一个Template对象（其中用$表示以后将要代入的变量）；
（2）对此对象调用substitute(m [,**kwargs])方法，将数据传入并生成格式化后的字符串。 可以用字典m来传入数据，也可以用后面关键字参数**kwargs的方法传入数据。
详见下例：
>>> t=string.Template('$name is $age') # 生成Template类型的对象实例t
>>> t.substitute({'name':'Tom', 'age':6}) # 用字典传入数据，结果为 'Tom is 6'
>>> t.substitute(name='Tom', age=6) # 用关键字参数传入数据，结果同上
还可以用它的template属性来查看原始字符串：
>>> print(t.template) # 结果为：'$name is $age'
（4）正则表达式
Python的re模块用于正则表达式。可以使用re模块的方法直接进行正则表达式的匹配和替换，也可以将正则表达式先编译成一个“正则表达式对象”，然后再使用这个正则表达式对象的方法进行字符串匹配和替换，下面我们分别进行介绍。
另外，由于正则表达式中大量使用特殊字符和反斜杠，所以正则表达式通常都写为“原始字符串”（即在字符串前加上字母r），原始字符串中，所有的特殊字符不会被转义，如“r' abc'前面的' '不会被解释为换行符，仅仅就是字面意思的斜杠和n。
本篇仅介绍re模块的用法，关于正则表达式本身的详细语法，可点击查看这里：《正则表达式用法简介与速查》。
● re模块的直接方法
使用下面的方法需先：import re
| 方法 | 简述 | 举例或说明 |
|---|---|---|
| re.compile(patt, flags=0) | 将入参patt编译为“正则表达式对象”， flag含义详见下述 |
关于正则表达式对象的用法 详见下述。 |
| re.escape(string) | 返回一个字符串，其中所有与正则表达式相关的特殊字符前都带有反斜杠。 |
re.escape('ab12[]') # 返回为 'ab12[] |
| re.findall(patt, string, flags=0) | 在 string 中匹配 patt，匹配结果用一列表返回。 flag含义详见下述 |
re.findall('d', 'a12b2') # 结果为 ['1','2','2'] |
| re.finditer(patt, string, flags=0) | 与上面 findall()的用法相同（在string 中匹配 patt），但返回一个含MatchObject类型的迭代器对象。 MatchObject详见下述。 |
re.finditer('d', 'a12b2') # 结果为一个MatchObject类型的迭代器 |
| re.search(patt, string, flags=0) | 与上面 finditer()的用法相同（在string 中匹配 patt），但仅返回第一个匹配的MatchObject对象，若未找到匹配则返回None。 MatchObject详见下述。 |
m=re.search('d', 'a12b2') print(m.group(0)) # 结果为 '1' |
| re.match(patt, string, flags=0) | 与上面 search()的用法相同（在string 中匹配 patt，仅返回第一个匹配的MathchObject对象），但仅匹配string的开头部分。 MatchObject详见下述。 |
re.match('d', 'a12') # 结果为 None re.match('d', '21a') # 结果为有匹配 |
| re.split(patt, string, maxsplit=0, flags=0) | 根据patt出现的位置拆分string，返回字符串列表。maxsplit为最大拆分次数，其他参数含义同上。 |
re.split('d', 'a1b23c4') # 结果为 ['a','b','','c',''] |
| re.sub(patt, repl, string, count=0, flags=0) | 使用替换值repl替换string中的patt匹配处内容，返回替换后的新字符串。count是执行替换的最大次数，其他参数含义同上。 |
re.sub('d','x','a1b23c') # 结果为 'axxbxc' |
| re.subn(patt, repl, string, count=0, flags=0) | 与上面 sub()相同（使用替换值repl替换string中的patt匹配处内容），但返回一个元组，其中包含新字符串和替换次数 |
re.subn('d','x','a1b23c') # 结果为 ('axxbxc', 3) |
| re.purge() | 清空正则表达式的缓存内容 |
一般用于含子表达式时的情况 |
flag标志：各标志本质上为一个整数值，多个标志同时使用时，中间用“或”运算符合并。
| 缩写 | 全称 | 整数值 | 含义说明 |
|---|---|---|---|
| re.A | re.ASCII | 256 |
执行仅8位ASCII字符匹配 |
| re.I | re.IGNORECASE | 2 |
执行不区分大小写的匹配 |
| re.L | re.LOCALE | 4 |
为w、W、、B 使用地区设置 |
| re.M | re.MULTILINE | 8 |
将^和$应用于多行字符串的的每一行（正常情况下，^和$仅用于匹配整个字符串的开头和结尾）。 |
| re.S | re.DOTALL | 16 |
使点字符“.”匹配所有字符，包括换行符 |
| re.U | re.UNICODE | 32 |
使用Unicode（Python3默认标志） |
| re.X | re.VERBOSE | 64 |
忽略模式字符串中未转义的空格和注释 |
● 正则表达式对象的使用方法
由re.compile()函数编译创建的正则表达式对象，具有以下属性和方法：
| 属性或方法 | 简述 | 举例或说明 | |
|---|---|---|---|
| 属性 | |||
| flags | 在使用complie编译正则表达式时使用的flags参数，为一个整数。 |
r=re.compile('a') print(r.flags) # 结果为 32 |
|
| groupindex | 一个字典，对类似(?P<name>...)的扩展正则表达式，将其定义的各符号分组名映射到数字编号。 |
r=re.compile('(?P<a1>d)(?P<a2>abc)') print(r.groupindex) # 结果为 {'a1':1, 'a2':2} |
|
| pattern | 本正则表达式对象在compile()编译前的原始表达字符串 |
略 |
|
| 方法 | |||
| findall(str [,pos [,endpos]]) | 等效于前面的re.findall()函数（在 string 中匹配本正则对象，匹配结果用一列表返回），pos和endpos指定搜索的开始和结束位置。 |
r=re.compile('d') r.findall('a12b2') # 结果为 ['1','2','2'] |
|
| finditer(str [,pos [,endpos]]) | 等效于前面的re.finditer()函数（在string 中匹配本正则对象，返回一个含MatchObject类型的迭代器对象），pos和endpos含义同上。 |
r=re.compile('d') r.finditer('a12b2') # 结果为一个MatchObject类型的迭代器 |
|
| search(str [,pos [,endpos]]) | 等效于前面的re.search()函数（在string 中匹配本正则对象，但仅返回第一个匹配的MatchObject对象），pos和endpos含义同上。 |
r=re.compile('d') m=r.search('a12b2') print(m.group(0)) # 结果为 '1' |
|
| match(str [,pos [,endpos]]) | 等效于前面的re.match()函数（在string 中匹配本正则对象，仅返回第一个匹配的MathchObject对象，且仅匹配string的开头部分），pos和endpos含义同上。 |
r=re.compile('d') m=r.match('a12b2') # 结果为 None |
|
| split(str, maxsplit=0) | 等效于前面的re.split()函数（根据本正则对象出现的位置拆分string，返回字符串列表，maxsplit为最大拆分次数）。 |
r=re.compile('d') r.split('a1b23c4') # 结果为 ['a','b','','c',''] |
|
| sub(repl, str, count=0) | 等效于前面的re.sub()函数（使用替换值repl替换string中的本正则对象匹配处内容，返回替换后的新字符串。count是执行替换的最大次数）。 |
r=re.compile('d') r.sub('x','a1b23c') # 结果为 'axxbxc' |
|
| subn(repl, str, count=0) | 等效于前面的re.subn()函数（使用替换值repl替换string中的本正则对象匹配处内容，返回一个元组，其中包含新字符串和替换次数）。 |
r=re.compile('d') r.subn('x','a1b23c') # 结果为 ('axxbxc', 3) |
|
● MatchObject详解：
MatchObject实例包含若干匹配的完整信息，它具有以下属性和方法
| 属性或方法 | 简述 | 举例或说明 | |
|---|---|---|---|
| 属性 | |||
| pos | 传递给search()或match()函数的pos值 |
略 |
|
| endpos | 传递给search()或match()函数的endpos值 |
略 |
|
| lastindex | 在使用子表达式时，相匹配的最后一个子表达式的数字索引（从1开始），若没有匹配的子表达式，则为None。 |
r=re.compile('(a)(b)') m=r.search('abc') print(m.lastindex) # 结果为 2 # 解释：第2个子表达式为'b'，有匹配，故最后一个匹配的子表达式的索引为2 |
|
| lastgroup | 在使用子表达式时，相匹配的最后一个子表达式的给定名称，如果没有相匹配的子表达式，或正则表达式中没有给定名称的子表达式，则为None。 |
r=re.compile('(?P<a1>a)(?P<a2>b)') m=r.search('abc') print(m.lastgroup) # 结果为 a2 # 解释：第2个子表达为'b'，有匹配，且第2个子表达式被命名为'a2'，故最后结果显式为'a2' |
|
| re | 一个正则表达式对象，它的match()或search()方法生成此MatchObject实例。 |
r=re.compile('a') m=r.search('abc') print(m.re) # 结果为 re.compile('a') |
|
| string | 传递给match()或search()的字符串。 |
略 |
|
| 方法 | |||
| expand(template) | 返回一个字符串，该字符串可通过在字符串template上使用反斜杠来提取出被匹配的内容（若使用子表达数字索引，需要使用双反斜杠）。 |
r=re.compile('(?P<a1>a)(?P<a2>b)') m=r.search('abc') m.expand('\1') # 结果为 'a' m.expand('g<a2>') # 结果为 'b' |
|
| group([grp1, grp2, ...]) | 返回匹配的一个或多个子表达式，参数grp1,grp2,... 为子表达式的索引或给定名称。若不指定入参或入参为0，则返回整个匹配值。 |
r=re.compile('(?P<a1>a)(?P<a2>b)') m=r.search('abc') m.group(0) # 结果为 'ab' m.group(1) # 结果为 'a' m.group('a2') # 结果为 'b' m.group(1,'a2') # 结果为 ('a','b') |
|
| [] | Python3.6新增功能，可以使用[]操作符来返回匹配的子表达式，数字索引含义同上。 |
续上例 m[0] # 结果为 'ab' m[1] # 结果为 'a' m[2] # 结果为 'b' |
|
|
start([group]) end([group]) |
这两个方法返回匹配的子表达式在原字符串中的开始和结束索引（end的含义同切片，为结束位置的后1个位置）。若不指定group，将使用相匹配的整个字符串。 |
续上例 m.start() # 结果为 0 m.end() # 结果为 2 m.start(1) # 结果为 0 m.start(2) # 结果为 1 |
|
| span([group]) | 返回一个元组，内容为（m.start([group], m.end([group])) |
续上例 m.span() # 结果为 (0,2) m.span(1) # 结果为 (0,1) m.span(2) # 结果为 (1,2) |
|
| groups(default=None) | 返回一个元组，其中每个元素为各个子表达式匹配的文本，若某子表达式未找到匹配，则对应元素为None（若指定入参defalut，则将对应的None元素替换为defalut） |
r=re.compile('(?P<a1>a)(?P<a2>b)?') m=r.search('axy') m.groups() # 结果为 ('a', None) m.groups('z') # 结果为 ('a', 'z') |
|
| groupdict(default=None) | 返回一个字典，其中包含所有给定名称的子表达式匹配，default含义同上。 |
续上例 m.groupdict() #结果为{'a1':'a', 'a2':None} m.groupdict('z') #结果为{'a1':'a', 'a2':'z'} |
|