Python3.9全部47个字符串函数的说明

作为脚本语言，Python具有强大的字符串处理能力，下面是Python3.9全部47个字符串函数的说明(函数名中用中括号[]括起来的部分表示可选的语法成分)：

	函数	说明	示例
1	s.capitalize()	返回s首字母大写的结果	‘abc'.capitalize()=='Abc' '中国abc'.capitalize()=='中国abc'
2	s.casefold()	返回与s等价的一个字符串以便在忽略大小写的情况下比较s与其他字符串	‘abc'.casefold()=='abc' 'ABC'.casefold()=='abc' '中国Abc'.casefold()=='中国abc‘ 'ab'.casefold()=='AB'.casefold()
3	s.center(width, fillchar = ' ')	返回一个s居中，宽度为width的字符串, 两头以字符fillchar填充。fillchar中只能有1个字符，否则抛出TypeError异常	'abc'.center(9)=='   abc   ' 'abcde'.center(5)=='abcde' 'abc'.center(8)=='  abc   ' 'abc'.center(9, '*')=='***abc***' 'abc'.center(8, '中')=='中中abc中中中'
4	s.count(sub[, start[, end]])	在s[start:end]中查找不重叠的子串sub，返回其数量。当end省略时，表示从start开始的所有字符，当start也省略时，表示整个字符串	'abababb'.count('ab')=3 'ababababa'.count('aba')==2
5	s.encode(encoding = 'utf-8', errors = 'strict')	返回把s用encoding编码后得到的字节序列(bytes)。errors=‘strict'表示如果出错就抛出UnicodeEncodeError错误。其他可能的值有‘ignore'、'replace'、'xmlcharrefreplace'等。codecs.register_error()可被用来注册错误	'abc'.encode()==b'abc' '中国'.encode() == b'\xe4\xb8\xad\xe5\x9b\xbd' '中国'.encode('GB2312') == b'\xd6\xd0\xb9\xfa'
6	s.endswith(suffix[, start[, end]])	判断字符串s[start:end]是不是以子串suffix结尾的, suffix可以是字符串的元组，只要其中一个满足要求即可。	'abc'.endswith('bc')==True 'abc'.endswith('bc', 0, 2) == False 'abcd'.endswith(('ab', 'c')) == False 'abcd'.endswith(('ab', 'cd')) == True
7	s.expandtabs(tabsize = 8)	返回s的一个拷贝，其中的制表符'\t'都被替换为tabsize个空格	'a\tb\tc'.expandtabs(2) == 'a  b  c'
8	s.find(sub[, start[, end]])	从左往右在s[start:end]中搜索sub，返回找到的第一个sub的下标(从0开始计算)。找不到返回-1。参阅.rfind()函数	'abcabc'.find('c') == 2 'abc'.find('xyz') == -1
9	s.format(*args, **kwargs)	返回s的一个拷贝，其中的用花括号括起来的变量用可变参数args和关键字参数kwargs所定义的参数替换。	'a{}bc{}'.format(123, 456) == 'a123bc456' 'a{}bc{xy}'.format(123, xy=456) == 'a123bc456) 'a{xy}bc{}'.format(123, xy=456) == 'a456bc123' '{x}{}{}{y}'.format(1, 2, x='a', y='b') == 'a12b'
10	s.format_map(**a)	等价于s.format(**a)	'{x}ab{yy}'.format_map(x=1.5, yy=True) == '1.5abTrue'
11	s.index(sub[, start[, end]])	同s.find()函数，不同点在于如果没有找到子串sub则抛出ValueError错误	'abcabc'.index('c') == 2 'abc'.index('xyz')抛出错误
12	s.isalnum()	如果s不是空串，并且所有的字符都是数字字符(0~9)或者字母(a~z, A~Z)，则返回True；否则返回False	'aAzZ19'.isalnum() == True ''.isalnum() == False '-_123'.isalnum() == False
13	s.isalpha()	如果s不是空串，并且所有的字符都是字母(a~z, A~Z)，则返回True；否则返回False	'aAzZ'.isalpha() == True ''.isalpha() == False 'aAzZ9'.isalpha() == False
14	s.isascii()	如果s不是空串，并且所有的字符都是ASCII字符，则返回True；否则返回False	' 19aA~`!@#$%^&*()<>:;"/|\\[]{},.'.isascii() == True
15	s.isdecimal()	如果s不是空串，并且所有的字符都是decimal字符(0~9)，则返回True；否则返回False	'0123456789'.isdecimal() == True b'0123456789'.isdecimal() 抛出AttributeError错误，因为bytes没有.isdecimal()函数
16	s.isdigit()	如果s不是空串，并且所有的字符都是digit字符(0~9，字节数字)，则返回True；否则返回False	'0123456789'.isdigit() == True b'0123456789'.isdigit() == True
17	s.isidentifier()	如果s不是空串，并且所有的字符都是数字字符(0~9)、大小写字母、下划线或者汉字，且以大小写字母或者下划线打头，则返回True，表示s是个合法的构造标；否则返回False	'_123abcABC赵钱孙李'.isidentifier() == True '$'.isidentifier() == False '123abc'.isidentifier() == False
18	s.islower()	如果s中所有的字母都是小写字母，且至少含有一个字母，则返回True；否则返回False。参见.isupper()函数。	'abcxyz'.islower() == True '123'.islower() == False '123abc'.islower() == True 'aA'.islower() == False
19	s.isnumeric()	如果s不是空串，并且所有的字符都是digit字符(0~9，汉字数字，大写汉字数字)，则返回True；否则返回False	'0123456789'.isnumeric() == True '零一二三四五六七八九十百千万亿'.isnumeric() == True '壹贰叁肆伍陆柒捌玖拾佰仟'.isnumeric() == True 'IVX'.isnumeric() == False，罗马数字不包括在内
20	s.isprintable()	如果s不是空串，并且所有的字符都是可打印字符(包括汉字)，则返回True；否则返回False	' 123abc中国$!'.isprintable() == True '\t\r\n\a'.isprintable() == False '\u0020'.isprintable() == True '\u0001'.isprintable() == False
21	s.isspace()	如果s不是空串，并且所有的字符都是空白字符(' '、'\t'、'\r'或'\n')，则返回True；否则返回False	' \t\r\n'.isspace() == True '\a'.isspace() == False '123'.isspace() == False
22	s.istitle()	如果s不是空串，并且其中的每个单词都是以大写字母打头，剩下字母都是小写字母的，则返回True；否则返回False	'Abc'.istitle() == True 'Abc Xyz'.istitle() == True 'abc'.istitle() == False 'abc Xyz'.istitle() == False 'AbcXyz'.istitle() == False 'Abc\nXyz'.istitle() == True
23	s.isupper()	如果s中所有的字母都是小写字母，且至少含有一个字母，则返回True；否则返回False。参见.islower()函数	'ABCXYZ'.isupper() == True '123'.isupper() == False '123ABC'.isupper() == True 'aA'.isupper() == False
24	s.join(iterable)	把字符串序列iterable中的每个字符串用s相连然后返回结果。	','.join(('ab', 'cd', 'ef')) == 'ab,cd,ef' ''.join(('ab', 'cd', 'ef')) == 'abcdef'
25	s.ljust(width, fillchar=' ')	返回s的一个拷贝，总长度为width，长度不够的右边填上fillchar字符。如果长度大于width，则不截断。fillchar中有且仅有一个字符，否则抛出TypeError。参见.rjust()函数	'abc'.ljust(5) == 'abc  ' '  a'.ljust(5, '\n') == '  a\n\n' '  a  '.ljust(7, '*') == '  a  **'
26	s.lower()	返回s的一个拷贝，其中的大写字母都转为了小写字母。参见.upper()	'123AbC'.lower() == '123abc' 'XY中国123'.lower() == 'xy中国123'
27	s.lstrip(chars=None)	返回s的一个拷贝，其中左边打头的空白字符(' '、'\t'、'\r'或'\n')都被删除。如果提供了chars字符串，则仅删除chars中的字符。参见.rstrip()和.strip()	'   \tabc'.lstrip() == 'abc' 'abcd   '.lstrip() == 'abcd   ' 'abc'.lstrip('ab') == 'c' 'abcabc'.lstrip('ba')=='cabc' ' \nabc xyz'.lstrip() == 'abc xyz'
28	str.maketrans(d)	用字典d定义一个替换表，以便用在s.translate()中以替换s中的字符。d的键必须是字符的unicode编码(调用ord()函数)，值是一个字符串或者unicode或者None，None表示删除字符。注意这个方法是str的静态方法	t = str.maketrans({ord('a'): '123', ord('b'): ord('x')}) 'ab'.translate(t)  # 结果是'123x'
28*	str.maketrans(s1, s2[, s3])	用字符串s1和s2构成一个替换表，以便用在s.translate()中以替换s中的字符。字符串s1和s2长度必须相等，s1中的每个字符将被s2中相同位置处的字符替换。如果s3提供的话，其中的每个字符都会被从结果中删除	t = str.maketrans('ab', 'xy') 'abcab'.translate(t)  # 结果是'xycxy'
29	s.partition(sep)	在s中从左往右搜索子串sep的第一次出现，返回一个三元组(a, b, c)，其中a是s中sep之左的部分，b就是sep，c是sep之右的部分。如果s中找不到sep，则返回(s, '', '')。参见.rpartition()	'ab,cd,ef'.partition(',') == ('ab', ',', 'cd,ef') 'abcdef'.partition('cd') == ('ab', 'cd', 'ef') 'abc'.partition('xyz') == ('abc', '', '')
30	s.removeprefix(prefix)	如果s以prefix打头，返回把prefix删除后得到的新字符串；否则返回s本身	'abcd'.removeprefix('ab') == 'cd' 'abcd'.removeprefix('aa') == 'abcd'
31	s.removesuffix(suffix)	如果s以prefix打头，返回把suffix删除后得到的新字符串；否则返回s本身	'abcd'.removesuffix('cd') == 'ab' 'abcd'.removesuffix('aa') == 'abcd'
32	s.replace(old, new, count=-1)	返回把s中出现的old不重叠子串替换为new之后的结果。count=-1表示所有这样的子串都替换，否则替换从左往右count个不重叠子串	'abcdeabcd'.replace('ab', '*') == '*cde*cd' 'abcdeabcd'.replace('ab', '*', 1) == '*cdeabcd' 'abababa'.replace('aba', '12') == '12b12'
33	s.rfind(sub[, start[, end]])	从右往左在s[start:end]中搜索sub，返回找到的第一个sub的下标(从0开始从左往右计算)。找不到返回-1。参阅.find()函数	'abcdabcd'.rfind('cd') == 6 'abc'.rfind('xyz') == -1 'abcdabcd'.rfind('cd', 2, 6) == 2
34	s.rindex(sub[, start[, end]])	同.rfind()函数，不同点在于如果没有找到子串sub则抛出ValueError错误	'abcabc'.rindex('c') == 5 'abc'.rindex('xyz')抛出错误
35	s.rjust(width, fillchar=' ')	返回s的一个拷贝，总长度为width，长度不够的左边填上fillchar字符。如果s长度大于width，则不截断。fillchar中有且仅有一个字符，否则抛出TypeError。参见.ljust()函数	'abc'.rjust(5) == '  abc' '  a'.rjust(5, '\n') == '\n\n  a' '  a  '.rjust(7, '*') == '**  a  '
36	s.rpartition(sep)	在s中从右往左搜索子串sep的第一次出现，返回一个三元组(a, b, c)，其中a是s中sep之左的部分，b就是sep，c是sep之右的部分。如果s中找不到sep，则返回('', '', s)。参见.partition()函数	'ab,cd,ef'.rpartition(',') == ('ab,cd', ',', 'ef') 'abcdef'.rpartition('cd') == ('ab', 'cd', 'ef') 'abc'.rpartition('xyz') == ('', '', 'abc')
37	s.rsplit(sep=None, maxsplit=-1)	把字符串sep看作是分隔符，返回把s分割后得到的字符串列表。搜索时s中从右往左搜索。maxsplit=-1表示搜索所有的sep，否则最多搜索maxsplit次。如果sep省略，则把任意空白字符(' '，'\t'，'\n'或'\r')看作是分隔符，并且删除左右两端的空白字符。参见.split()函数	'  a bc\tde  \r'.rsplit() == ['a', 'bc', 'de'] 'abcdaabcaa'.rsplit('ab') == ['', 'cda', 'caa'] 'abcdaabcaa'.rsplit('a') == ['', 'bcd', '', 'bc', '', ''] 'abcdaabcaa'.rsplit('a', 2) == ['abcdaabc', '', '']
38	s.rstrip(chars=None)	返回s的一个拷贝，其中右边打头的空白字符(' '、'\t'、'\r'或'\n')都被删除。如果提供了chars字符串，则仅删除chars中的字符。参见函数.lstrip()和.strip()	'abc   \t'.rstrip() == 'abc' '   abcd'.rstrip() == '   abcd' 'abc'.rstrip('cb') == 'a' 'abcabc'.rstrip('cb') == 'abca' 'abc xyz \n'.rstrip() == 'abc xyz'
39	s.split(sep=None, maxsplit=-1)	把字符串sep看作是分隔符，返回把s分割后得到的字符串列表。搜索时s中从左往右搜索。maxsplit=-1表示搜索所有的sep，否则最多搜索maxsplit次。如果sep省略，则把任意空白字符(' '，'\t'，'\n'或'\r')看作是分隔符，并且删除左右两端的空白字符。参见.rsplit()函数	'  a bc\tde  \r'.split() == ['a', 'bc', 'de'] 'abcdaabcaa'.split('ab') == ['', 'cda', 'caa'] 'abcdaabcaa'.split('a') == ['', 'bcd', '', 'bc', '', ''] 'abcdaabcaa'.split('a', 2) == ['', 'bcd', 'abcaa']
40	s.splitlines(keepends=False)	把s用行分隔符('\n', '\r')分割，返回所得到的字符串列表。列表中每个字符串的不包含行分隔符，除非keepends=True。'\r\n'被看成是一个分隔符，'\n\r'被看成是两个分隔符。如果len(s) > 1且s以行分隔符结尾，则该分隔符被忽略。	'abc'.spllitlines() == ['abc'] ''.splitlines() == [] '\n'.splitlines() == [''] '\n\n'.splitlines() == ['', ''] 'ab\ncd'.splitlines() == ['ab', 'cd'] 'ab\rcd'.splitlines() == ['ab', 'cd'] 'ab\r\ncd'.splitlines() == ['ab', 'cd'] 'ab\n\rcd'.splitlines() == ['ab', '', 'cd']
41	s.startswith(prefix[, start[, end]])	判断字符串s[start:end]是不是以子串prefix打头的, prefix可以是字符串的元组，只要其中一个满足要求即可。	'abc'.startswith('ab')==True 'abc'.startswith('ab', 1, 3) == False 'abcd'.startswith(('bc', 'c')) == False 'abcd'.startswith(('ab', 'c')) == True
42	s.strip(chars=None)	返回s的一个拷贝，其中左右两边打头的空白字符(' '、'\t'、'\r'或'\n')都被删除。如果提供了chars字符串，则仅删除chars中的字符。参见函数.lstrip()和.rstrip()	'  abc   \t'.strip() == 'abc' '   abcd   '.strip() == 'abcd' 'bcabc'.strip('cb') == 'a' 'abcabc'.strip('cb') == 'abca' '\tabc xyz \n'.strip() == 'abc xyz'
43	s.swapcase()	s中的大写字母转为小写字母，小写字母转为大写字母，返回所得到的新字符串	'AaBbCc'.swapcase() == 'aAbBcC'
44	s.title()	把s中每个单词的首字母大写，其他字母小写，返回得到的新字符串	'abc xYZ'.title() == 'Abc Xyz'
45	s.translate(table)	用调用str.maketrans()得到的替换表table替换s中的字符，返回得到的结果。被替换的只能是单个字符，不能是子串。详见.maketrans()函数	t = str.maketrans({ord('a'): '123', ord('b'): ord('x')}) 'ab'.translate(t)  # 结果是'123x' t = str.maketrans('ab', 'xy') 'abcab'.translate(t)  # 结果是'xycxy'
46	s.upper()	返回s的一个拷贝，其中的小写字母都转为了大写字母。参见.lower()函数	'123AbC'.lower() == '123ABC' 'xy中国123'.lower() == 'XY中国123'
47	s.zfill(width)	在s的左边填上0，使得总长度等于width。如果len(s)>=width，则返回s本身	'12.45'.zfill(7) == '0012.45' 'abc'.zfill(5) == '00abc' 'abcxyz'.zfill(4) == 'abcxyz'