Python语法速查： 4. 字符串常用操作

返回目录

本篇索引

（1）字符串常用方法

（2）字符串常量

（3）模板字符串Template

（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()	是否所有字符都为空白	' \t '.isspace()   # 结果为 True
s.isprintable()	是否所有字符都可打印。	'a\t'.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\tb'.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\n','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	包括：空格、制表符（\t）、换行（\n）、回车（\r）、垂直制表符（\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'\nabc'前面的'\n'不会被解释为换行符，仅仅就是字面意思的斜杠和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、\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'}

返回目录