Python 的内置字符串方法.docx
《Python 的内置字符串方法.docx》由会员分享，可在线阅读，更多相关《Python 的内置字符串方法.docx（27页珍藏版）》请在冰豆网上搜索。
Python的内置字符串方法
Python的内置字符串方法（收藏专用）
字符串处理是非常常用的技能，但Python内置字符串方法太多，常常遗忘，为了便于快速参考，特地依据Python3.5.1给每个内置方法写了示例并进行了归类，便于大家索引。
PS:
可以点击概览内的绿色标题进入相应分类或者通过右侧边栏文章目录快速索引相应方法。
概览
字符串大小写转换
∙str.capitalize（）
∙str.lower（）
∙str.casefold（）
∙str.swapcase（）
∙str.title（）
∙str.upper（）
字符串格式输出
∙str.center（width[,fillchar]）
∙str.ljust（width[,fillchar]）;str.rjust（width[,fillchar]）
∙str.zfill（width）
∙str.expandtabs（tabsize=8）
∙str.format（^args,^^kwargs）
∙str.format_map（mapping）
字符串搜索定位与替换
∙str.count（sub[,start[,end]]）
∙str.find（sub[,start[,end]]）;str.rfind（sub[,start[,end]]）
∙str.index（sub[,start[,end]]）;str.rindex（sub[,start[,end]]）
∙str.replace（old,new[,count]）
∙str.lstrip（[chars]）;str.rstrip（[chars]）;str.strip（[chars]）
∙staticstr.maketrans（x[,y[,z]]）;str.translate（table）
字符串的联合与分割
∙str.join（iterable）
∙str.partition（sep）;str.rpartition（sep）
∙str.split（sep=None,maxsplit=-1）;str.rsplit（sep=None,maxsplit=-1）
∙str.splitlines（[keepends]）
字符串条件判断
∙str.endswith（suffix[,start[,end]]）;str.startswith（prefix[,start[,end]]）
∙str.isalnum（）
∙str.isalpha（）
∙str.isdecimal（）;str.isdigit（）;str.isnumeric（）
∙str.isidentifier（）
∙str.islower（）
∙str.isprintable（）
∙str.isspace（）
∙str.istitle（）
∙str.isupper（）
字符串编码
∙str.encode（encoding=”utf-8″,errors=”strict”）
大小写转换
str.capitalize（）
将首字母转换成大写，需要注意的是如果首字没有大写形式，则返回原字符串。
1
2
3
4
5
6
7
8
9
10
11
'adidog'.capitalize（）
#'Adidog'
'abcd徐'.capitalize（）
#'Abcd徐'
'徐abcd'.capitalize（）
#'徐abcd'
'ß'.capitalize（）
#'SS'
str.lower（）
将字符串转换成小写，其仅对 ASCII 编码的字母有效。
1
2
3
4
5
6
7
8
'DOBI'.lower（）
#'dobi'
'ß'.lower（） #'ß'为德语小写字母，其有另一种小写'ss'，lower方法无法转换
#'ß'
'徐ABCD'.lower（）
#'徐abcd'
str.casefold（）
将字符串转换成小写，Unicode编码中凡是有对应的小写形式的，都会转换。
1
2
3
4
5
'DOBI'.casefold（）
#'dobi'
'ß'.casefold（） #德语中小写字母ß等同于小写字母ss，其大写为SS
#'ss'
str.swapcase（）
对字符串字母的大小写进行反转。
1
2
'徐Dobia123ß'.swapcase（）
#:
'徐dOBIA123SS' 这里的ß被转成SS是一种大写
但需要注意的是 s.swapcase（）.swapcase（）==s 不一定为真：
1
2
3
4
5
6
7
8
9
10
11
u'xb5'
#'µ'
u'xb5'.swapcase（）
#'Μ'
u'xb5'.swapcase（）.swapcase（）
#'μ'
hex（ord（u'xb5'.swapcase（）.swapcase（）））
Out[154]:
'0x3bc'
这里 'Μ'（是mu不是M）的小写正好与 'μ' 的写法一致。
str.title（）
将字符串中每个“单词”首字母大写。
其判断“单词”的依据则是基于空格和标点，所以应对英文撇好所有格或一些英文大写的简写时，会出错。
1
2
3
4
5
6
7
8
9
'Helloworld'.title（）
#'HelloWorld'
'中文abcdef12gh'.title（）
#'中文AbcDef12Gh'
#但这个方法并不完美：
"they'rebill'sfriendsfromtheUK".title（）
#"They'ReBill'SFriendsFromTheUk"
str.upper（）
将字符串所有字母变为大写，会自动忽略不可转成大写的字符。
1
2
'中文abcdef12gh'.upper（）
#'中文ABCDEF12GH'
需要注意的是 s.upper（）.isupper（） 不一定为 True。
字符串格式输出
str.center（width[,fillchar]）
将字符串按照给定的宽度居中显示，可以给定特定的字符填充多余的长度，如果指定的长度小于字符串长度，则返回原字符串。
1
2
3
4
5
'12345'.center（10,'*'）
#'**12345***'
'12345'.center（10）
#' 12345 '
str.ljust（width[,fillchar]）;str.rjust（width[,fillchar]）
返回指定长度的字符串，字符串内容居左（右）如果长度小于字符串长度，则返回原始字符串，默认填充为ASCII空格，可指定填充的字符串。
1
2
3
4
5
6
7
8
9
10
11
'dobi'.ljust（10）
#'dobi '
'dobi'.ljust（10,'~'）
#'dobi~~~~~~'
'dobi'.ljust（3,'~'）
#'dobi'
'dobi'.ljust（3）
#'dobi'
str.zfill（width）
用‘0’填充字符串，并返回指定宽度的字符串。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
"42".zfill（5）
#'00042'
"-42".zfill（5）
#'-0042'
'dd'.zfill（5）
#'000dd'
'--'.zfill（5）
#'-000-'
''.zfill（5）
#'0000'
''.zfill（5）
#'00000'
'dddddddd'.zfill（5）
#'dddddddd'
str.expandtabs（tabsize=8）
用指定的空格替代横向制表符，使得相邻字符串之间的间距保持在指定的空格数以内。
1
2
3
4
5
6
7
8
9
tab='1t23t456t7890t1112131415t161718192021'
tab.expandtabs（）
#'1 23 456 7890 1112131415 161718192021'
#'123456781234567812345678123456781234567812345678' 注意空格的计数与上面输出位置的关系
tab.expandtabs（4）
#'1 23 4567890 1112131415 161718192021'
#'12341234123412341234123412341234'
str.format（^args,^^kwargs）
格式化字符串的语法比较繁多，官方文档已经有比较详细的examples，这里就不写例子了，想了解的童鞋可以直接戳这里 Formatexamples.
str.format_map（mapping）
类似 str.format（*args,**kwargs） ，不同的是 mapping 是一个字典对象。
1
2
3
4
People={'name':
'john','age':
56}
'Mynameis{name},iam{age}old'.format_map（People）
#'Mynameisjohn,iam56old'
字符串搜索定位与替换
str.count（sub[,start[,end]]）
1
2
3
4
5
6
7
8
9
10
text='outerprotectivecovering'
text.count（'e'）
#4
text.count（'e',5,11）
#1
text.count（'e',5,10）
#0
str.find（sub[,start[,end]]）;str.rfind（sub[,start[,end]]）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
text='outerprotectivecovering'
text.find（'er'）
#3
text.find（'to'）
#-1
text.find（'er',3）
Out[121]:
3
text.find（'er',4）
Out[122]:
20
text.find（'er',4,21）
Out[123]:
-1
text.find（'er',4,22）
Out[124]:
20
text.rfind（'er'）
Out[125]:
20
text.rfind（'er',20）
Out[126]:
20
text.rfind（'er',20,21）
Out[129]:
-1
str.index（sub[,start[,end]]）;str.rindex（sub[,start[,end]]）
与 find（） rfind（） 类似，不同的是如果找不到，就会引发 ValueError。
str.replace（old,new[,count]）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'dogwowwowjiao'.replace（'wow','wang'）
#'dogwangwangjiao'
'dogwowwowjiao'.replace（'wow','wang',1）
#'dogwangwowjiao'
'dogwowwowjiao'.replace（'wow','wang',0）
#'dogwowwowjiao'
'dogwowwowjiao'.replace（'wow','wang',2）
#'dogwangwangjiao'
'dogwowwowjiao'.replace（'wow','wang',3）
#'dogwangwangjiao'
str.lstrip（[chars]）;str.rstrip（[chars]）;str.strip（[chars]）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
' dobi'.lstrip（）
#'dobi'
''.lstrip（'dbk'）
#''
'dobi '.rstrip（）
#'dobi'
''.rstrip（'acn'）
#'db.kun.ac.'
' dobi '.strip（）
#'dobi'
''.strip（'db.c'）
#''
''.strip（'cbd.un'）
#'kun.a'
staticstr.maketrans（x[,y[,z]]）;str.translate（table）
maktrans 是一个静态方法，用于生成一个对照表，以供 translate 使用。
如果 maktrans 仅一个参数，则该参数必须是一个字典，字典的key要么是一个Unicode编码（一个整数），要么是一个长度为1的字符串，字典的value则可以是任意字符串、None或者Unicode编码。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a='dobi'
ord（'o'）
#111
ord（'a'）
#97
hex（ord（'狗'））
#'0x72d7'
b={'d':
'dobi',111:
'is','b':
97,'i':
'u72d7u72d7'}
table=str.maketrans（b）
a.translate（table）
#'dobiisa狗狗'
如果 maktrans 有两个参数，则两个参数形成映射，且两个字符串必须是长度相等；如果有第三个参数，则第三个参数也必须是字符串，该字符串将自动映射到 None：
1
2
3
4
5
6
7
8
9
10
11
a='dobiisadog'
table=str.maketrans（'dobi','alph'）
a.translate（table）
#'alphhsaalg'
table=str.maketrans（'dobi','alph','o'）
a.translate（table）
#'aphhsaag'
字符串的联合与分割
str.join（iterable）
用指定的字符串，连接元素为字符串的可迭代对象。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
'-'.join（['2012','3','12']）
#'2012-3-12'
'-'.join（[2012,3,12]）
#TypeError:
sequenceitem0:
expectedstrinstance,intfound
'-'.join（['2012','3',b'12']） #bytes为非字符串
#TypeError:
sequenceitem2:
expectedstrinstance,bytesfound
'-'.join（['2012']）
#'2012'
'-'.join（[]）
#''
'-'.join（[None]）
#TypeError:
sequenceitem0:
expectedstrinstance,NoneTypefound
'-'.join（['']）
#''
','.join（{'dobi':
'dog','polly':
'bird'}）
#'dobi,polly'
','.join（{'dobi':
'dog','polly':
'bird'}.values（））
#'dog,bird'
str.partition（sep）;str.rpartition（sep）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
'dogwowwowjiao'.partition（'wow'）
#（'dog','wow','wowjiao'）
'dogwowwowjiao'.partition（'dog'）
#（'','dog','wowwowjiao'）
'dogwowwowjiao'.partition（'jiao'）
#（'dogwowwow','jiao',''）
'dogwowwowjiao'.partition（'ww'）
#（'dogwowwowjiao','',''）
'dogwowwowjiao'.rpartition（'wow'）
Out[131]:
（'dogwow','wow','jiao'）
'dogwowwowjiao'.rpartition（'dog'）
Out[132]:
（'','dog','wowwowjiao'）
'dogwowwowjiao'.rpartition（'jiao'）
Out[133]:
（'dogwowwow','jiao',''）
'dogwowwowjiao'.rpartition（'ww'）
Out[135]:
（'','','dogwowwowjiao'）
str.split（sep=None,maxsplit=-1）;str.rsplit（sep=None,maxsplit=-1）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
'1,2,3'.split（','）,'1,2,3'.rsplit（）
#（['1','2','3'],['1,','2,','3']）
'1,2,3'.split（',',maxsplit=1）, '1,2,3'.rsplit（',',maxsplit=1）
#（['1','2,3'],['1,2','3']）
'123'.split（）,'123'.rsplit（）
#（['1','2','3'],['1','2','3']）
'123'.split（maxsplit=1）,'123'.rsplit（maxsplit=1）
#（['1','23'],['12','3']）
' 1 2 3 '.split（）
#['1','2','3']
'1,2,,3,'.split（','）,'1,2,,3,'.rsplit（','）
#（['1','2','','3',''],['1','2','','3','']）
''.split（）
#[]
''.split（'a'）
#['']
'bcd'.split（'a'）
#['bcd']
'bcd'.split（None）
#['bcd']
str.splitlines（[keepends]）
字符串以行界符为分隔符拆分为列表；当 keepends 为True，拆分后保留行界符，能被识别的行界符见官方文档。
1
2
3
4
5
6
7
8
9
'abcnndefgrklrn'.splitlines（）
#['abc','','defg','kl']
'abcnndefgrklrn'.splitlines（keepends=True）
#['abcn','n','defgr','klrn']
"".splitlines（），''.split（'n'） #注意两者的区别
#（[],['']）
"Onelinen".splitlines（）
#（['Oneline'],['Twolines','']）
字符串条件判断
str.endswith（suffix[,start[,end]]）;str.startswith（prefix[,start[,end]]）
1
2
3
4
5
6
7
8
9
10
11
12
text='outerprotectivecovering'
text.endswith（'ing'）
#True
text.endswith（（'gin','ing'））
#True
text.endswith（'ter',2,5）
#True
text.endswith（'ter',2,4）
#False
str.isalnum（）
字符串和数字的任意组合，即为真，简而言之：
只要 c.isalpha（）, c.isdecimal（）, c.isdigit（）, c.isnumeric（） 中任意一个为真，则 c.isalnum（） 为真。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
'dobi'.isalnum（）
#True
'dobi123'.isalnum（）
#True
'123'.isalnum（）
#True
'徐'.isalnum（）
#True
'dobi_123'.isalnum（）
#
升级会员 