​​Python​​之字符串函数

起始字符串：​​Hello World​​

函数名

描述

​​find()​​

检测字符串返回字符串位置，不包含返回-1

​​isdigit()​​

判断字符串是否全部由数字组成

​​isalpha()​​

判断字符串是否全部由字母组成

​​isalnum()​​

判断字符串是否全部字符串组成

​​isdecimal()​​

判断字符串是否全部由十进制数字组成，和​​isdigit​​​的区别在于，​​isdigit​​​可用于​​byte​​​类型，而​​isdecimal​​不可以

​​isnumeric()​​

判断字符串是否全部由数字字符组成

​​isupper()​​

判断字符串是否全部由大写字母组成

​​islower()​​

判断字符串是否由小写字母组成

​​isspace()​​

判断字符串是否全部由空白字符组成

​​isidentifier()​​

判断字符串是否是有效标识符（仅包含字母数字或下划线，不能以数字开头或包含任何空格）

​​isprintable()​​

判断字符串是否是可打印的，不可打印的包括回车符，换行符，制表符

​​istitle()​​

判断字符串是否是标题样式（所有英文单词首字母大写，其他字母小写）

​​split()​​

从左侧切割字符串，返回列表

​​rsplit()​​

从右侧切割字符串，返回列表

​​splitlines()​​

按行切割字符串（​​\n​​​,​​\r​​​,​​\r\n​​），返回列表

​​index()​​

检索子串在字符串中首次出现位置，不存在会报错

​​rindex()​​

检索子串在字符串最后一次出现的位置，不存在会报错

​​find()​​

检索子串在字符串中首次出现的位置，不存在则返回-1

​​rfind()​​

检索子串在字符串中最后一次出现的位置，不存在则返回-1

​​title()​​

每个英文首字母大写，其他字母小写

​​encode()​​

对字符串进行编码(​​Python3​​​中字符串默认是​​unicode​​​，中文字符串编码跟随系统，​​windows​​​下是​​gbk​​)

​​repace()​​

将字符串中指定的子串替换为别的字符串

​​maketrans()​​

该函数是类函数

​​translate()​​

将字符串中出现在映射表key中的字符替换为映射后的字符串

​​join()​​

将序列中的每个元素用原字符串连接起来组成一个新的字符串

​​lstrip()​​

截断字符串中最左边出现的指定字符

​​rstrip()​​

截断字符串中最右边出现的指定字符

​​strp()​​

截断字符串中两端出现的指定字符

​​ljust()​​

向字符串右边填充指定字符直到字符串长度为指定的长度

​​rjust()​​

向字符串左边填充指定字符直到字符串长度为指定的长度

​​center()​​

向字符串两边填充指定字符直到字符串长度为指定的长度（按照右-左的顺序依次填充）

​​zfill()​​

向字符串左边填充“0”直到字符串长度为指定的长度

​​capitalize()​​

将字符串中第一个字母变为大写，其他字母变为小写

​​casefold()​​

将字符串中所有字母变为小写。和​​lower()​​​的区别在于，​​lower()​​​只会转换英文字母，​​casefold()​​可以转换非汉语和英语的字母

​​endswith()​​

判断字符串是否以指定后缀结尾

​​startswith()​​

判断字符串是否以指定前缀开始

​​count()​​

计算子串在字符串中出现的次数

​​expandtabs()​​

将字符串中制表符替换为指定数量的空格

​​partition()​​

将字符串根据首次出现的分隔符分成三部分，以元组形式返回

​​rpartition()​​

将字符串根据最后一次出现的分隔符分成三部分，以元组形式返回

​​upper()​​

将字符串中所有英文字母转为大写

​​lower()​​

将字符串中所有英文字母转为小写

​​swapcase()​​

将字符串中所有英文字母大小写互换

​​format_map()​​

用字典进行字符串格式化

详细介绍

​​isdigit​​

参数：无
用途：判断字符串是否全部由数字组成

>>> "12".isdigit()
True
>>> "a".isdigit()
False
>>> "".isdigit()
False
123456

​​isalpha​​

参数：无
用途：判断字符串是否全部由字母组成

>>> "a".isalpha()
True
>>> "a1".isalpha()
False
>>> "".isalpha()
False
123456

​​isalnum​​

参数：无
用途：判断字符串是否全部由字母或数字组成

>>> "a1".isalnum()
True
>>> "a1.".isalnum()
False
>>> "".isalnum()
False
123456

​​isdecimal​​

参数：无
用途：判断字符串是否全部由十进制数字组成，和​​isdigit​​​的区别在于，​​isdigit​​​可用于​​byte​​​类型，而​​isdecimal​​不可以

>>> b"1".isdigit()
True
>>> "1".isdecimal()
True
>>> b"1".isdecimal()
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    b"1".isdecimal()
AttributeError: 'bytes' object has no attribute 'isdecimal'
>>> "".isdecimal()
False
1234567891011

​​isnumeric​​

参数：无
用途：判断字符串是否全部由数字字符组成，和​​isdigit​​​的区别在于，​​isdigit​​​只能检测阿拉伯数字，​​isnumeric​​还可以检测汉字数字（大小写均可），罗马数字

>>> "1二叁".isnumeric()
True
>>> "1Ⅲ".isnumeric()
True
>>> "".isnumeric()
False
123456

注意：上面例子中罗马数字是Ⅲ不是三个I

​​isupper​​

参数：无
用途：判断字符串是否全部由大写字母组成

>>> "ABC".isupper()
True
>>> "ABc".isupper()
False
>>> "".isupper()
False
123456

​​islower​​

参数：无
用途：判断字符串是否全部由小写字母组成

>>> "abc".islower()
True
>>> "ABc".islower()
False
>>> "".islower()
False
123456

​​isspace​​

参数：无
用途：判断字符串是否全部由空白字符组成

>>> " ".isspace()   #一个空格
True
>>> "  ".isspace()   #一个制表符
True
>>> "\n".isspace()  #换行符
True
>>> "\r".isspace()  #回车符
True
>>> "".isspace()
False
12345678910

​​isidentifier​​

参数：无
用途：判断字符串是否是有效标识符（仅包含字母数字或下划线，不能以数字开头或包含任何空格）。

>>> "def".isidentifier()
True
>>> "def1".isidentifier()
True
>>> "def 1".isidentifier()
False
>>> "$def".isidentifier()
False
>>> "1def".isidentifier()
False
>>> "def_1".isidentifier()
True
>>> "".isidentifier()
False
1234567891011121314

​​isprintable​​

参数：无
用途：判断字符串是否是可打印的。不可打印的包括回车符，换行符，制表符

>>> "a_1 ~".isprintable()
True
>>> "\n".isprintable()
False
>>> "\r".isprintable()
False
>>> "  ".isprintable()    #制表符
False
>>> " ".isprintable()     #空格
True
>>> "☎".isprintable()
True
>>> "ど".isprintable()
True
>>> "".isprintable()
True
12345678910111213141516

​​istitle​​

参数：无
用途：判断字符串是否是标题样式（所有英文单词首字母大写，其他字母小写）

>>> "To Be Or Not".istitle()
True
>>> "ToBe Or Not".istitle()
False
1234

​​split​​

参数：
seq:分隔符，默认为空白符（空格，制表符，回车符，换行符）
​​​maxsplit​​​：分割次数，默认-1，即分割所有
用途：从左开始切割字符串，返回列表

>>> "a,b,c".split(",")
['a', 'b', 'c']
>>> "a,b,c".split(",",1)
['a', 'b,c']
>>> "a,b,c".split()
['a,b,c']
>>> "a b c".split()
['a', 'b', 'c']
>>> "".split()
[]
12345678910

​​rsplit​​

参数：
seq:分隔符，默认为空白符（空格，制表符，回车符，换行符）
​​​maxsplit​​​：分割次数，默认-1，即分割所有
用途：从右开始切割字符串，返回列表

>>> "a,b,c".rsplit(",")
['a', 'b', 'c']
>>> "a,b,c".rsplit(",",1)
['a,b', 'c']
>>> "a,b,c".rsplit()
['a,b,c']
>>> "a b c".rsplit()
['a', 'b', 'c']
>>> "".rsplit()
[]
12345678910

​​splitlines​​

参数：
​​​keepends​​​:是否保留换行符,默认False
用途：按行切割字符串("\n","\r","\r\n")，返回列表

>>> "a\nb\rc\r\nd".splitlines()
['a', 'b', 'c', 'd']
>>> "a\nb\rc\r\nd".splitlines(True)
['a\n', 'b\r', 'c\r\n', 'd']
>>> "a\nb\rc\n\rd".splitlines()
['a', 'b', 'c', '', 'd']
123456

​​index​​

参数：
sub:子字符串
start:开始索引，默认为0
end:结束索引，默认为字符串的长度
用途：检索子串在字符串中首次出现的位置，不存在会报错

>>> "ab12cd12".index("12")
2
>>> "ab12cd12".index("12",3)
6
>>> "ab12cd12".index("")
0
>>> "ab12cd12".index("12",3,6)
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    "ab12cd12".index("12",3,6)
ValueError: substring not found
1234567891011

​​rindex​​

参数：
sub:子字符串
start:开始索引，默认为0
end:结束索引，默认为字符串的长度
用途：检索子串在字符串中最后一次出现的位置，不存在会报错

>>> "ab12cd12".rindex("12")
6
>>> "ab12cd12".rindex("12",1,6)
2
>>> "ab12cd12".rindex("")
8
>>> "ab12cd12".rindex("g")
Traceback (most recent call last):
  File "<pyshell#68>", line 1, in <module>
    "ab12cd12".rindex("g")
ValueError: substring not found
1234567891011

​​find​​

参数：
sub:子字符串
start:开始索引，默认为0
end:结束索引，默认为字符串的长度
用途：检索子串在字符串中首次出现的位置，不存在则返回-1

>>> "ab12cd12".find("12")
2
>>> "ab12cd12".find("f")
-1
1234

​​rfind​​

参数：
sub:子字符串
start:开始索引，默认为0
end:结束索引，默认为字符串的长度
用途：检索子串在字符串中最后一次出现的位置，不存在则返回-1

>>> "ab12cd12".rfind("12")
6
>>> "ab12cd12".rfind("f")
-1
1234

​​title​​

参数：无
用途：返回标题化的字符串（每个英文单词首字母大写，其他字母小写）

>>> "to bE or nOT".title()
'To Be Or Not'
>>> "1to测试bE or nOT".title()
'1To测试Be Or Not'
1234

​​encode​​

参数：
​​​encoding​​​：编码格式
​​​errors​​​：对于错误的处理方式，默认为“​​strict​​​”，编码错误时会抛出​​UnicodeEncodeError​​​，其他可选参数包括’​​ignore​​​’, ‘​​replace​​​’，’​​xmlcharrefreplace​​​’以及其他在​​codecs.register_error​​​中注册过的，可以处理​​UnicodeEncodeErrors​​​的值
用途：对字符串进行编码(​​Python3​​​中字符串默认是​​unicode​​​，中文字符串编码跟随系统，​​windows​​​下是​​gbk​​)

>>> "你好".encode(encoding="utf8")
b'\xe4\xbd\xa0\xe5\xa5\xbd'
>>> "你好".encode(encoding="gbk")
b'\xc4\xe3\xba\xc3'
1234

注意：和encode()相对的是decode()，decode()不是字符串的函数，但是用法相同

>>> b'\xe4\xbd\xa0\xe5\xa5\xbd'.decode(encoding="utf8")
'你好'
12

​​replace​​

参数：
old:被替换的子串
new:用于替换的子串
count:替换次数，默认-1，即全部替换
用途：将字符串中指定的子串替换为别的字符串

>>> "ab12ef12".replace("12","cd")
'abcdefcd'
>>> "ab12ef12".replace("12","cd",1)
'abcdef12'
1234

​​maketrans​​

参数：
x:映射关系字典，key为待替换字符，长度为1，value为替换后的字符串
用途：生成translate()用的映射表
注意：该函数是类函数

>>> str.maketrans({"a":"12"})
{97: '12'}
12

​​translate​​

参数：
table:替换关系映射表
用途：将字符串中出现在映射表key中的字符替换为映射后的字符串

>>> t=str.maketrans({"a":"12","b":"3"})
>>> "ab".translate(t)
'123'
123

​​join​​

参数：
iterable:待连接的序列对象，内部元素必须均为字符串
用途：将序列中的每个元素用原字符串连接起来组成一个新的字符串

>>> ",".join(["1","2","3"])
'1,2,3'
>>> "，".join(["1"])
'1'
>>> ",".join([])
''
123456

​​lstrip​​

参数：
chars:指定待截断的字符，默认为空白符（空格，制表符，回车符，换行符）
用途：截断字符串中最左边出现的指定字符

>>> "\t \n\rabc".lstrip()
'abc'
>>> "aabb12ab".lstrip("ab")
'12ab'
1234

​​rstrip​​

参数：
chars:指定待截断的字符，默认为空白符（空格，制表符，回车符，换行符）
用途：截断字符串中最右边出现的指定字符

>>> "abc\t \n\r".rstrip()
'abc'
>>> "aabb12aabb".rstrip("ab")
'aabb12'
1234

​​strip​​

参数：
chars:指定待截断的字符，默认为空白符（空格，制表符，回车符，换行符）
用途：截断字符串中两端出现的指定字符

>>> "\t \n\rabc\t \n\r".strip()
'abc'
>>> "aabb12aabb".strip("ab")
'12'
1234

​​ljust​​

参数：
width:字符串填充后的长度。若长度不大于原字符串长度则不进行填充
fillchar:用于填充的字符，长度为1，默认为空格
用途：向字符串右边填充指定字符直到字符串长度为指定的长度

>>> "abc".ljust(5)
'abc  '
>>> "abc".ljust(5,"1")
'abc11'
>>> "abc".ljust(2,"1")
'abc'
123456

​​rjust​​

参数：
width:字符串填充后的长度。若长度不大于原字符串长度则不进行填充
fillchar:用于填充的字符，长度为1，默认为空格
用途：向字符串左边填充指定字符直到字符串长度为指定的长度

>>> "abc".rjust(5)
'  abc'
>>> "abc".rjust(5,"1")
'11abc'
>>> "abc".rjust(2,"1")
'abc'
123456

​​center​​

参数：
width:字符串填充后的长度。若长度不大于原字符串长度则不进行填充
fillchar:用于填充的字符，长度为1，默认为空格
用途：向字符串两边填充指定字符直到字符串长度为指定的长度（按照右-左的顺序依次填充）

>>> "abc".center(6,"1")
'1abc11'
>>> "abc".center(2,"1")
'abc'
1234

​​zfill​​

参数：
width:字符串填充后的长度。若长度不大于原字符串长度则不进行填充
用途：向字符串左边填充“0”直到字符串长度为指定的长度

>>> "abc".zfill(6)
'000abc'
>>> "abc".zfill(2)
'abc'
1234

​​capitalize​​

参数：无
用途：将字符串中第一个字母变为大写，其他字母变为小写

>>> "a,B测试C1".capitalize()
'A,b测试c1'
12

​​casefold​​

参数：无
用途：将字符串中所有字母变为小写。和lower()的区别在于，lower()只会转换英文字母，casefold()可以转换非汉语和英语的字母

>>> "Groß - α".casefold()    #德语
'gross - α'
12

​​endswith​​

参数：
suffix:待判断的后缀，可以是字符串或是元素为字符串的元组，若是元组，则会对内部元素依次判断，只要有一个符合即返回True
start:字符串的起始位置，默认从第一个字符开始
end:字符串的结束位置，默认到最后一个字符结束
用途：判断字符串是否以指定后缀结尾

>>> "abc".endswith("c")
True
>>> "abc".endswith("c",0,2)
False
>>> "abc".endswith(("c","1"))
True
123456

​​startswith​​

参数：
prefix:待判断的前缀，可以是字符串或是元素为字符串的元组，若是元组，则会对内部元素依次判断，只要有一个符合即返回True
start:字符串的起始位置，默认从第一个字符开始
end:字符串的结束位置，默认到最后一个字符结束
用途：判断字符串是否以指定前缀开始

>>> "abc".endswith("a")
True
>>> "abc".endswith("a",1,3)
False
>>> "abc".endswith(("a","1"))
True
123456

​​count​​

参数：
sub:子串，若为空则返回字符串长度
start:字符串的起始位置，默认从第一个字符开始
end:字符串的结束位置，默认到最后一个字符结束
用途：计算子串在字符串中出现的次数

>>> "to be or not to be".count("to")
2
>>> "to be or not to be".count("1")
0
>>> "to be or not to be".count("")
19
>>> "to be or not to be".count("to",3)
1
12345678

​​expandtabs​​

参数：
tabsize:替换的空格数，默认8
用途：将字符串中制表符替换为指定数量的空格

>>> "a\tb".expandtabs()
'a       b'
>>> "a\tb".expandtabs(4)
'a   b'
1234

​​partition​​

参数：
sep:分隔符
用途：将字符串根据首次出现的分隔符分成三部分，以元组形式返回

>>> "a b c".partition(" ")
('a', ' ', 'b c')
>>> "a b".partition(",")
('a b c', '', '')
1234

​​rpartition​​

参数：
sep:分隔符
用途：将字符串根据最后一次出现的分隔符分成三部分，以元组形式返回

>>> "a b c".rpartition(" ")
('a b', ' ', 'c')
>>> "a b c".rpartition(",")
('', '', 'a b c')
1234

​​upper​​

参数：无
用途：将字符串中所有英文字母转为大写

>>> "abC".upper()
'ABC'
12

​​lower​​

参数：无
用途：将字符串中所有英文字母转为小写

>>> "abC".lower()
'abc'
12

​​swapcase​​

参数：无
用途：将字符串中所有英文字母大小写互换

>>> "abC".swapcase()
'ABc'
12

​​format_map​​

参数：
mapping:待替换参数变量和字符串的映射字典
用途：用字典进行字符串格式化

>>> dict={"name":"Tom","age":15}
>>> "{name} is {age} years old.".format_map(dict)
'Tom is 15 years old.'