Python字符串方法详解
字符串方法汇总
- 字符串的类型判断
- 大小写转换
- 字符串的填充与对齐
- 字符串的修剪
- 字符串的测试与查找
- 字符串的替换
- 字符串的拆分与组合
字符串的类型判断
| 函数 | 描述 |
|---|---|
| str.isdigit() | 是否全为数字（0-9） |
| str.isdedecimal() | 是否只包含十进制数字字符 |
| str.isnumeric() | 是否只包含数字字符 |
- 对于非Unicode字符串，上述三个方法是等价的。
| 函数 | 描述 |
|---|---|
| str.isalpha() | 是否全为字母 |
| str.isalnum() | 是否全为字母或数字 |
| str.lower() | 是否全为小写 |
| str.isupper() | 是否全为大写 |
| str.istitle() | 是否为标题，即各单词首字母大写 |
- *注意，istitle()判断时会对每个单词的首字母边界判断。例如，word1 Word2、word1_ Word2、 word1()Word2中都包含两个单词，它们的首字母都是"w"和"W".因此，如果用istitle()去判断它们，将返回False,因为w是小写。
| 函数 | 描述 |
|---|---|
| str. isspace() | 判断字符串是否是空白(空格、制表符、换行符等)字符，没有任何字符是不算是空白。 |
| str. isidentifier() | 是否满足标识符定义规则 |
| str. isprintable() | 是否是可打印字符(例如制表符、换行符就不是可打印字符，但空格是) |
大小写转换
| 函数 | 描述 |
|---|---|
| str. lower() | 全部转换为小写 |
| str. upper() | 全部转换为大写 |
| str. capitalize() | 转换为首字母大写，其他字母小写 |
| str. title() | 转换为各单词首字母大写 |
| str. swapcase() | 大小写互换(大写–>小写，小写–>大写) |
| str. casefold() | 转换为大小写无关字符串比较的格式字符串 |
>>> print('ab XY' .lower() )
ab xy
>»> print('ab XY' .upper())
AB XY
>>> print('ab XY' .title () )
Ab Xy
>>>print('abc DE' .capitalize () )
Abc de
>>> print('abc XYZ' . swapcase () )
>ABC xyz
字符串的填充与对齐
- str. center (width[, fillchar]) 将字符串居中左右两边使用fillchar进行填充， 使得整个字符串的长度为width。fllchar默认为空格。如果width小于 字符串的长度，则无法填充直接返回字符串本身(不会创建新字符串对象)。
- str. ljust(width[, fillchar]) 左对齐
- str. rjust (width[, fillchar]) 右对齐
ljust()使用fillchar填充在字符串S的右边，使得整体长度为width。rjust()则 是填充在左边。如果不指定fillchar,则默认使用空格填充。如果width小于 或等于字符串S的长度，则无法填充，直接返回字符串S(不会创建新字符串对象)。 - str. zfill (width) 前方补0
用0填充在字符串S的左边使其长度为width。如果S前有正负号+/-,则0填充在这两个符号的后面，且符号也算入长度。如果width小于或等 于S的长度，则无法填充，直接返回S本身(不会创建新字符串对象)。 - str. expandtabs([tabsize]) 将字符串中的制表符扩展为若千个空格，tabsize默认为8
>>>print('ab'.center(4,'_'))
_ab_
>>>print('ab'.center(5,'_'))
__ab_
>>>print('ab'.center(4))
ab
>>>print(len('ab'.center(4)))
4
>>>print('abcde'.center(3))
abcde
>>>print('xyz'.ljust(5,'_'))
xyz__
>>>print('xyz'.rjust(5,'_'))
__xyz
字符串的修剪
| 函数 | 描述 |
|---|---|
| str. strip([chars]) | 移除左右两边的字符chars |
| str. lstrip([chars]) | 移除左边的字符chars |
| str. rstrip([chars]) | 移除右边的字符chars |
- 如果不指定chars或者指定为None,则默认移除空白(空格、制表符、换行符)。
唯一需要注意的是，chars可以是多个字符序列。在移除时，只要是这个序列中的字符，都会被移除。
1.移除单个字符空白
>>>' spacious '.lstrip()
'spacious '
>>>' spacious ' . rstrip ()
' spacious'
>>> 'spacious ' . lstrip('s')
'pacious
>> ' spacious' .rstrip('s')
' spaciou '
2.移除字符序列中的字符
>>>print('www.example.com'.lstrip('cmowz.'))
example.com
>>>print('wwwz.example.com'.lstrip('cmowz.'))
example.com
>>>print('wwaw.example.com'.lstrip('cmowz.'))
aw.example.com
>>>print('www.example.com'.strip('cmowz.'))
'example'
字符串的测试与查找
- str. startswith (prefix[, start[, end]])
- str. endswith(suffix[, start[, end]])
- endswith()检查字符串str是否以suffix结尾，返回布尔值的True和False。suffix可 以是一一个元组(tuple)。可以指定起始start和结尾end的搜索边界。
- 同理startswith()用来判断字符串str是否是以prefix开头。
举例：
1.suffix是普通的字符串时
>>>print('abcxyz'.endswith('xyz'))
True
#False,因为搜索范围为'yz'
>>>print('abcxyz'.endswith('xyz',4))
False
#False,因为搜索范围为'abcxy'
>>>print('abcxyz'.endswith('xyz',0,5))
False
#False,因为搜索范围为'yz'
>>>print('abcxyz'.endswith('xyz',0,6))
True
2.suffix是元组tuple时，只要tuple中任意一个 元素满足endswith的条件，就返回True。
>>>print('abcxyz'.endswith(('ab','xyz')))
True
#tuple中的‘ab’,'xy'都不满足条件
>>>print('abcxyz'.endswith(('ab','xy')))
False
#tuple中的'z'满足条件
>>>print('abcxyz'.endswith(('ab','xy','z')))
True
- str. count (sub[, start[, end]])
- 返回字符串str中子串sub出现的次数，可以指定从哪里开始计算(start)以及计算到哪里结束(end)， 索引从0开始计算，不包括end边界。
>>>print('xyabxyxy'.count('xy'))
3
>>>print('xyabxyxy'.count('xy',1))
2
#次数1是因为不包括end，所以查找范围为'yabxyx'
>>>print('xyabxyxy'.count('xy',1,7))
1
#次数2，因为查找的范围为'yabxyxy'
>>>print('xyabxyxy'.count('xy',1,8))
2
- str. find(sub[, start[, end]])
- str. rfind(sub[, start[, end]])
- str. index(sub[, start[, end]])
- str. rindex (sub[, start[, end]])
-
find()搜索 字符串S中是否包含子串sub，如果包含，则返回sub的索引位置，否则返回"-1"。可以指定起始start和结束end的搜索位置。
-
index()和find()一样，唯一不同点在于当找不到子串时，抛出ValueError错误。
-
rfind()则是返回搜索到的最右边子串的位置，如果只搜索到一个或没有搜索到子串，则和find()是等价的。同理rindex()。
-
>>>print('abcxyzXY'.find('xy'))
3
>>>print('abcxyzXY'.find('Xy'))
-1
>>>print('abcxyzXY'.find('xy',4))
-1
>>>print('xyzabcabc'.find('bc'))
4
>>>print('xyzabcabc'.rfind('bc'))
7
>>>print('xyzabcabc'.rindex('bcd'))
Traceback (most recent call last)
in ()
----> 1 print('xyzabcabc'.rindex('bcd'))
ValueError: substring not found
字符串的替换
-
S. replace(old, new[, count])
- 将字符串中的子串old替换为new字符串，如果给定count, 则表示只替换前count个old子串。 如果S中搜索不到子串old,则无法替换，直接返回字符串S(不创建新字符串对象)。
-
S. expandtabs (N)
- 将字符串S中的\t替换为一定数量的空格。默认N=8。注意，expandtabs(8)不是将\t直接替换为8个空格。例如’xyz\tab’ expandtabs()会将\t替换为5个空格，因为"xyz" 占用了3个字符位。所以，在替换"\t"为空格时，会减掉"\t"前面的字符数量。如果"'t"的前面正好没有字符， 则直接将"\t"替换为N个空格。另外，它不会替换换行符(\n或\r)。
-
S. translate (table)
-
static str. maketrans(x[, y[, z]])
- str.maketrans()生成一一个字符一一 映射的table,然后使用translate(table)对字符串S中的每个字符进行映射。
- translate()实现的功能和Linux中的tr命令是类似的。
- 注意，maketrans(x[, y[, z1])中的x和y都是字符串，且长度必须相等。
- 如果maketrans(x[, y[, z])给定了第三个参数z,则这个参数字符串中的每个字符都会被映射为None。
>>>print('abcxyzoxy'.replace('xy','XY'))
abcXYzoXY
#数字【1】表示只替换前【1】个'xy'为'XY'
>>>print('abcxyzoxy'.replace('xy','XY',1))
abcXYzoxy
>>>print('abcxyzoxy'.replace('mn','XY',1))
abcxyzoxy
字符串的拆分与组合
-
S. split (sep=None, maxsplit=-1)
-
S. rsplit (sep=None, maxsplit=-1)
-
S. splitlines ([keepends=True])
-
都是用来分割字符串，并生成一个列表
-
split()根据sep对S进行分割，maxspt于指定分割次数，如果不指定maxsplit或者给定值为"-1"， 则会从左向右搜索并且每遇到sep- 次就分割直到搜索完字符串。如果不指定sep或者指定为None,则改变分割算法:以空格为分隔符，且将连续的空白压缩为一一个空格。
-
rsplit()和split()是一 样的， 只不过是从右边向左边搜索。
-
splitlines()用来专门用来分割换行符。虽然它有点像split("|n’)或split(\r\n"), 但它们有些区别。
-
splitlines()中可以指定各种换行符，常见的是\n、\r、\rn。 如果指定keepends为True, 则保留所有的换行符。
-
#sep为单个字符时
>>>'1,2,3'.split(',')
['1','2','3']
>>>'1,2,3'.split(',',1)
['1','2,3'] # 只分割了一次
>>>'1,2,,3'.split(',')
['1','2','','3'] # 不会压缩连续的分隔符
>>>'<>'.split('<')
['','hello>','>','world>']
#sep为多个字符时
>>>'<>'.split('<>')
['', 'world>']
#不指定sep时
>>>'1 2 3'.split()
['1', '2', '3']
>>>'1 2 3'.split(maxsplit=1)
['1', '2 3']
>>>' 1 2 3 '.split()
['1', '2', '3']
>>>' 1 2 3 \n '.split()
['1', '2', '3']
#显示指定sep为空格、制表符、换行符时
>>>' 1 2 3 \n'.split(' ')
['', '1', '', '2','', '3','','\n']
>>>' 1 2 3 \n'.split(' \t')
[' 1 2 3 \n']
>>>' 1 2\n3 \n'.split('\n')
[' 1 2','3 ', ''] #注意列表的最后一项
>>>''.split('\n')
['']
-
S. partition(sep)
-
S. rpartition (sep)
-
搜索字符串S中的子串sep,并从sep处对S进行分割， 最后返回一个包含3元素的元组, sep左边的部分是元组的第一个元素， sep自身是元组的二个元素，sep右边是元组的第三个元素。
-
partition(sep)从左边第一 个sep进行分割，rpartition(sep)从右边第一 个sep进行分割。
-
如果搜索不到sep，则返回的3元素元组中，有两个元素为空。partition()是后两个元素为空，rpartition()是前两个元素为空。
-
#只搜索到一个sep时，两者结果相同
>>>print('abcxyzopq'.partition('xy'))
('abc', 'xy', 'zopq')
>>>print('abcxyzopq'.rpartition('xy'))
('abc', 'xy', 'zopq')
#搜索到多个sep时，分别从左第一个，右第一个sep分割
>>>print('abcxyzxyopq'.partition('xy'))
('abc', 'xy', 'zxyopq')
>>>print('abcxyzxyopq'.partition('xy'))
('abcxyz', 'xy', 'opq')
# 搜索不到sep
>>>print('abcxyzxyopq'.partition('xyc'))
('abcxyzxyopq', '', '')
>>>print('abcxyzxyopq'.partition('xyc'))
( '', '','abcxyzxyopq')
-
S. join(iterable)
- 将可迭代对象(iterable)中的元素使用S连接起来。注意，iterable中必须全部是字符串类型，否则报错。
- 字符串
>>>L= 'Python'
>>>'_'.join(L)
'P_y_t_h_o_n'
- 元组
>>>L1 = ('1','2','3')
>>>'_'.join(L1)
'1_2_3'
- 集合。注意，集合无序。
>>>L2 = ('p','y','t','h','o','n')
>>>'_'.join(L2)
'p_y_t_h_o_n'
- 列表
>>>L2 = ['py','th','o','n']
>>>'_'.join(L2)
'py_th_o_n'
- 字典
>>>L3 = {'name':"malongshuai",'gender':‘male','from':'China','age':18}
>>>'_'.join(L3)
'name_gender_from_age'
- iterable参与迭代的每个元素必须是字符串类型，不能包含数字或其他类型。
>>>L1= (1,2,3)
>>>'_'.join(L1)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in ()
1 L1= (1,2,3)
----> 2 '_'.join(L1)
TypeError: sequence item 0: expected str instance, int found