码迷,mamicode.com
首页 > 编程语言 > 详细

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

时间:2019-10-08 21:52:50      阅读:96      评论:0      收藏:0      [点我收藏+]

标签:prefix   字符串常量   模式   font   supper   local   ati   查找   star   

 

 (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()的用法相同,但返回一个含MatchObject类型的迭代器对象。 MatchObject详见下述。

re.finditer(‘\d‘, ‘a12b2‘)

# 结果为一个MatchObject类型的迭代器

re.search(patt, string, flags=0) 与上面 finditer()的用法相同,但仅返回第一个匹配的MatchObject对象,若未找到匹配则返回None。 MatchObject详见下述。

m=re.search(‘\d‘, ‘a12b2‘)

print(m.group(0))   # 结果为 ‘1‘

re.match(patt, string, flags=0) 与上面 search()的用法相同,但仅匹配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()相同,但返回一个元组,其中包含新字符串和替换次数

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()函数,pos和endpos指定搜索的开始和结束位置。

r=re.compile(‘\d‘)

r.findall(‘a12b2‘)

# 结果为 [‘1‘,‘2‘,‘2‘]

finditer(str [,pos [,endpos]]) 等效于前面的re.finditer()函数,pos和endpos含义同上。

r=re.compile(‘\d‘)

r.finditer(‘a12b2‘)

# 结果为一个MatchObject类型的迭代器

search(str [,pos [,endpos]]) 等效于前面的re.search()函数,pos和endpos含义同上。

r=re.compile(‘\d‘)

m=r.search(‘a12b2‘)

print(m.group(0))   # 结果为 ‘1‘

match(str [,pos [,endpos]]) 等效于前面的re.match()函数,pos和endpos含义同上。

r=re.compile(‘\d‘)

m=r.match(‘a12b2‘)   # 结果为 None

split(str, maxsplit=0) 等效于前面的re.split()函数。

r=re.compile(‘\d‘)

r.split(‘a1b23c4‘)

# 结果为 [‘a‘,‘b‘,‘‘,‘c‘,‘‘]

sub(repl, str, count=0) 等效于前面的re.sub()函数。

r=re.compile(‘\d‘)

r.sub(‘x‘,‘a1b23c‘)

# 结果为 ‘axxbxc‘

subn(repl, str, count=0) 等效于前面的re.subn()函数。

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‘}

 

 

 

 

 

 

返回页首

 

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

标签:prefix   字符串常量   模式   font   supper   local   ati   查找   star   

原文地址:https://www.cnblogs.com/initcircuit/p/11586060.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!