Python之字符串函数常用操作

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 "", line 1, in 
    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 "", line 1, in 
    "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 "", line 1, in 
    "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.'

原文链接：https://blog.csdn.net/weixin_37311728/article/details/106054223