[Python知识库]007、Python字符串方法详解

Python数据类型之字符串

参考： https://blog.csdn.net/Michael177/article/details/123451738

1、字符串介绍

1. 字符与字节

一个字符不等价于一个字节，字符是人类能够识别的符号，而这些符号要保存到计算的存储中就需要用计算机能够识别的字节来表示。一个字符往往有多种表示方法，不同的表示方法会使用不同的字节数。这里所说的不同的表示方法就是指字符编码，比如字母A-Z都可以用ASCII码表示（占用一个字节），也可以用UNICODE表示（占两个字节），还可以用UTF-8表示（占用一个字节）。字符编码的作用就是将人类可识别的字符转换为机器可识别的字节码，以及反向过程。

2. 字符串定义

字符串(String)是由数字、字母、下划线组成的一串字符。一般记为 s=“a1a2···an”(n>=0)。它是编程语言中表示文本的数据类型。在程序设计中，字符串（string）为符号或数值的一个连续序列，如符号串（一串字符）或二进制数字串（一串二进制数字）。

3. python中字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 " )来创建字符串。

4. 字符串定义

# 定义字符串用 单引号 或者 双引号 引起来
s = "abcdef"

2、字符串操作方法详解

1. 字符串查找

1>. find()

描述：查找字符串中指定的子字符串sub第一次出现的位置，可以规定字符串的索引查找范围。若无则返回 -1。
语法：str.find(sub,start,end) -> int 返回整数

sub 要索引的子字符串。
start 索引的起始位置。默认值为0。
end 索引的结束位置。默认值为字符串长度len(str)。[start,end) 不包括end。

str01 = "I like python"
# 查找字符串“o”所在的位置
print(str01.find("o"))  # 11
# 从索引为5的位置开始查找字符串“i”
print(str01.find("i", 5))  # -1
# 从索引为2的位置开始到最后一位结束，查找字符串“i”
print(str01.find("i", 2, -1))  # 3

2>. rfind()

描述：查找字符串中指定的子字符串sub最后一次出现的位置，可以规定字符串的索引查找范围。若无则返回 -1。
语法：str.rfind(sub,start,end) -> int 返回整数

sum — 要索引的子字符串。
start —索引的起始位置。默认值为0。
end —索引的结束位置。默认值为字符串长度len(str)。[start,end) 不包括end。

str01 = "I like python"
# 查找字符串“i”最后一次出现的位置
print(str01.rfind("i"))  # 3
# 从索引为5的位置开始查找字符串“i”最后一次出现的位置
print(str01.rfind("i", 5))  # -1 没有查找到
# 从索引为2的位置开始到最后一位结束，查找字符串“i”最后出现的位置
print(str01.rfind("i", 2, -1))  # 3

**注：**rfind()函数用法与find()函数相似，rfind()函数返回指定子字符串最后一次出现的位置，find()函数返回指定子字符串第一次出现的位置。

3>. index()

描述：查找字符串中第一次出现的子字符串的位置，可以规定字符串的索引查找范围[star,end)。若无则会报错。
语法：str.index(sub, start, end) -> int 返回整数

sub —— 查找的子字符串。
start —— 索引的起始位置，默认为0。
end —— 索引的结束位置，默认为字符串的长度。

str01 = "I like python"
# 查找字符串“k”所在的索引位置
print(str01.index("k"))  # 4
# 从索引为3的位置开始查找字符串“k”所在的索引位置
print(str01.index("k", 3))  # 4
# 从索引为3的位置开始到索引为-1的位置结束，查找字符串“o”
print(str01.index("o", 3, -1))  # 11
# 查找索引不存在，会抛出异常
print(str01.index("a"))  # ValueError: substring not found

4>. rindex()

描述： rindex() 方法返回子字符串最后一次出现在字符串中的索引位置，该方法与 rfind() 方法一样，可以规定字符串的索引查找范围[star,end)，只不过如果子字符串不在字符串中会报一个异常。
语法：str.rindex(sub, start, end) -> int 返回整数。

sub —— 查找的子字符串。
start —— 索引的起始位置，默认为0。
end —— 索引的结束位置，默认为字符串的长度。

str01 = "I like python"
# 查找字符串“k”所在的索引位置
print(str01.rindex("k"))  # 4
# 从索引为3的位置开始查找字符串“k”所在的索引位置
print(str01.rindex("k", 3))  # 4
# 从索引为3的位置开始到索引为-1的位置结束，查找字符串“o”
print(str01.rindex("o", 3, -1))  # 11
# 查找索引不存在，会抛出异常
print(str01.rindex("a"))  # ValueError: substring not found

2. 字符串格式化

1>. format()

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。使用format()来格式化字符串时，使用在字符串中使用{}作为占位符，占位符的内容将引用format()中的参数进行替换。可以是位置参数、命名参数或者兼而有之。format 函数可以接受不限个参数，位置可以不按顺序。
语法：format(value, format_spec)

a = "Hello"
b = "world"

print("{} {}".format(a, b))  # 不设置指定位置，按默认顺序填充

print("{1} {0}".format(b, a))  # 设置指定位置，按指定的位置进行填充

print("{} {} {}".format(a, b))  # 设置指定位置，按指定的位置进行填充

------------------------------------------------------------------

print("姓名： {name}， 年龄： {age}".format(name="Jack", age=20))

# 通过字典设置参数
site = {"name": "Jack", "age": 20}
print("姓名： {name}， 年龄： {age}".format(**site))

list_ = ["Jack", 20]
print("姓名： {0[0]}， 年龄： {0[1]}".format(list_))  # 0代表format当中的第0个位置的参数，[]为列表的索引位置

------------------------------------------------------------------

格式化数字
pi = 3.1415926
print("{:.2f}".format(pi))

2>. format_map()

返回字符串的格式化版本。在Python3中使用format和format_map方法都可以进行字符串格式化，但format是一种所有情况都能使用的格式化方法，format_map仅使用于字符串格式中可变数据参数来源于字典等映射关系数据时才可以使用。
语法：str.format_map(mapping) -> str 返回字符串

mapping 是一个字典对象

People = {"name": "john", "age": 33}
"My name is {name},i am {age} old".format_map(People)

student = {'name': 'zhangsan', 'class': '20220531', 'score': 748}
format_map方法后如下
'{class}班的{name}同学，总分：{score}'.format_map(student)

3. 大小写转换

1>. capitalize()

描述：将字符串的第一个字母变成大写，其余字母变为小写。
语法：str.capitalize()

str02 = "i Like python"
print(str02.capitalize())  # 'I like python'

2>. title()

描述：返回一个满足标题格式的字符串。即所有英文单词首字母大写，其余英文字母小写。
语法：str.title()

str02 = "i Like python"
print(str02.title())  # 'I Like Python'

3>. swapcase()

描述：将字符串str中的大小写字母同时进行互换。即将字符串str中的大写字母转换为小写字母，将小写字母转换为大写字母。
语法：str.swapcase()

str02 = "I Like python"
print(str02.swapcase())  # "i lIKE PYTHON"

4>. lower()

描述：将字符串中的所有大写字母转换为小写字母。
语法：str.lower()

str02 = "I Like python"
print(str02.lower())  # "i like python"

5>. upper()

描述：将字符串中的所有小写字母转换为大写字母。
语法： str.upper()

str02 = "I Like python"
print(str02.upper())  # "I LIKE PYTHON"

6>. casefold()

描述：将字符串中的所有大写字母转换为小写字母。也可以将非英文语言中的大写转换为小写。
语法：str.casefold()

str02 = "I Like python"
str02.casefold()  # "i like python"

lower()函数和casefold()函数的区别：lower() 方法只对ASCII编码，即‘A-Z’有效，对于其它语言中把大写转换为小写的情况无效，只能用 casefold() 函数。

4. 字符串编码

1>. encode()

描述：以指定的编码格式编码字符串，默认编码为 ‘utf-8’。encode英文原意编码。

语法：str.encode(encoding=‘utf-8’, errors=‘strict’)

encoding 参数可选，即要使用的编码，默认编码为 ‘utf-8’。字符串编码常用类型有：utf-8，gb2312，cp936，gbk等。

errors 参数可选，设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeEncodeError。 其它可能值有 ‘ignore’, ‘replace’, 'xmlcharrefreplace’以及通过 codecs.register_error() 注册其它的值。

str02 = "人生苦短，我用python"
print(str02.encode(encoding="utf-8"))
# b'\xe4\xba\xba\xe7\x94\x9f\xe8\x8b\xa6\xe7\x9f\xad\xef\xbc\x8c\xe6\x88\x91\xe7\x94\xa8python'

str03 = "I Like Python"
print(str03.encode(encoding="utf-8"))
# b'I Like Python'

2>. decode()

描述：以 encoding 指定的编码格式解码字符串，默认编码为字符串编码。decode英文意思是 解码

语法：str.decode(encoding=‘utf-8’, errors=‘strict’)

encoding ——要使用的编码，如：utf-8,gb2312,cp936,gbk等。

errors ——设置不同解码错误的处理方案。默认为 ‘strict’,意为编码错误引起一个 UnicodeDecodeError。 其它可能得值有 ‘ignore’, 'replace’以及通过 codecs.register_error() 注册的1其它值。

str02 = "人生苦短，我用python".encode(encoding="utf-8")
print(str02.decode())  # 人生苦短，我用python

5. 字符串替换

1>. replace()函数

描述：把str.中的 old 替换成 new,如果 count 指定，则替换不超过 count次.。

语法：str.replace(old, new, count)

old --—— 将被替换的子字符串。

new --—— 新子字符串，用于替换old子字符串。

count —— 替换的次数，默认全部替换。

str04 = "I Like Python"
print(str04.replace("Python", "golang"))
# I Like golang

6. 解决问题

1>. endswith()

描述：判断字符串是否以指定字符或子字符串结尾。

语法：str.endswith(“suffix”, start, end) 或str[start,end].endswith(“suffix”) 用于判断字符串中某段字符串是否以指定字符或子字符串结尾。—> bool 返回值为布尔类型（True,False）

suffix — 后缀，可以是单个字符，也可以是字符串，还可以是元组（"suffix"中的引号要省略，常用于判断文件类型）。

start —索引字符串的起始位置。

end — 索引字符串的结束位置。

注意：空字符的情况。返回值通常为True

str06 = "I Like Python"
print(str06.endswith('n'))  # True

print(str06.endswith("python"))  # True

print(str06.endswith("n", 0, 6))  # False 索引0, 6是 I Like， 判断是否以“n”结尾。

print(str06.endswith(""))  # 空字符 True

print(str06.endswith(("n", "z")))  # True 遍历元组的元素，存在即返回True，否者返回False

#元组案例
file = "python.txt"
if file.endswith("txt"):
    print("该文件是文本文件")
elif file.endswith(("AVI", "WMV", "RM")):
    print("该文件为视频文件")
else:
    print("文件格式未知

2>. startswith()

描述：判断字符串是否以指定字符或子字符串开头。

语法：str.endswith(“suffix”, start, end) 或str[start,end].endswith(“suffix”) 用于判断字符串中某段字符串是否以指定字符或子字符串结尾。—> bool 返回值为布尔类型（True,False）

suffix — 后缀，可以是单个字符，也可以是字符串，还可以是元组（"suffix"中的引号要省略）。
start —索引字符串的起始位置。
end — 索引字符串的结束位置。
注意：空字符的情况。返回值通常也为True

str06 = "hi, I Like Python"
print(str06.startswith('h'))  # True

print(str06.startswith("hi"))  # True

print(str06.startswith("n", 2, 10))  # False 索引0, 6是 I Like， 判断是否以“n”结尾。

print(str06.startswith(""))  # 空字符 True

print(str06.startswith(("n", "z")))  # False 遍历元组的元素，存在即返回True，否者返回False

3>. isalnum()

描述：检测字符串是否由字母和数字组成。str中至少有一个字符且所有字符都是字母或数字则返回 True,否则返回 False

语法：str.isalnum() -> bool 返回值为布尔类型（True,False）

str07 = "python123"
str08 = "python%$#s123"
print(str07.isalnum())  # True
print(str08.isalnum())  # False

4>. isalpha()

描述：检测字符串是否只由字母组成。字符串中至少有一个字符且所有字符都是字母则返回 True,否则返回 False。

语法：str.isalpha() -> bool 返回值为布尔类型（True,False）

str07 = "python123"
str08 = "python%$#s"
str09 = "python"

print(str07.isalpha())  # False
print(str08.isalpha())  # False
print(str09.isalpha())  # True

5>. isdecimal()

描述：检查字符串是否只包含十进制字符。字符串中若只包含十进制字符返回True，否则返回False。该方法只存在于unicode对象中。注意:定义一个十进制字符串，只需要在字符串前添加前缀 ‘u’ 即可。
语法： str.isdecimal() -> bool 返回值为布尔类型（True,False）

str10 = "1234"
print(str10.isdecimal())  # True

str11 = u"1123"
print(str11.isdecimal())  # True

6>. isdigit()

描述：检测字符串是否只由数字组成.字符串中至少有一个字符且所有字符都是数字则返回 True,否则返回 False。

语法：str.isdigit() -> bool 返回值为布尔类型（True,False）

注：能判断“①”，不能判断中文数字。但 isnumeric() 函数可以。

str12 = “python”  
print(str12.isdigit())  # False  全为字母

str13 = "123"
print(str13.isdigit())  # True 全为数字

str14 = "一二三"
print(str15.isdigit())  # False  中文数字输出False

str15 = "①"
print(str16.isdigit())  # True

7>. isidentifier()

描述：判断str是否是有效的标识符。str为符合命名规则的变量，保留标识符则返回True,否者返回False。

语法：str.isidentifier() -> bool 返回值为布尔类型（True,False）

str16 = "123"
print(str16.isidentifier())  # False

str17 = "def"
print(str17.isidentifier())  # True 变量名为保留字

str18 = "_abc"
print(str18.isidentifier())  # True 

str19 = "student"
print(str19.isidentifier())  # True

str20 = "id"
print(str20.isidentifier())  # True

8>. islower()

描述：检测字符串中的字母是否全由小写字母组成。（字符串中可包含非字母字符）字符串中包含至少一个区分大小写的字符，且所有这些区分大小写的字符都是小写，则返回 True，否则返回 False。

语法：str.islower() -> bool 返回值为布尔类型（True,False）

str21 = "I like python"
print(str21.islower())  # False

str22 = "i like python"
print(str22.islower())  # True

9>. isnumeric()

描述：测字符串是否只由数字组成。这种方法是只适用于unicode对象。字符串中只包含数字字符，则返回 True，否则返回 False。

语法：str.isnumeric() -> bool 返回值为布尔类型（True,False）

str23 = u"12345"
print(str23.isnumeric())  # True

str24 = "12345"
print(str24.isnumeric())  # True

str25 = "python123"
print(str25.isnumeric())  False

str26 = "一二三"
print(str26.isnumeric())  # True

str27 = "①"
print(str27.isnumeric())  # True

10>. isspace()

描述： 检测字符串是否只由空格组成。若字符串中只包含空格，则返回 True，否则返回 False。

语法：str.isspace() -> bool 返回值为布尔类型（True,False）

str28 = " "#空格
print(str1.isspace())  # True

str29 = “i like python”
print(str2.isspace())  # False

11>. istitle()

描述：检测判断字符串中所有单词的首字母是否为大写，且其它字母是否为小写，字符串中可以存在其它非字母的字符。若字符串中所有单词的首字母为大写，且其它字母为小写，则返回 True，否则返回 False.

语法：str.istitle() -> bool 返回值为布尔类型（True,False）

str30 = "I Like Python"
print(str30.istitle())  # True 各单词的首字母均为大写，其余字母为小写

str31 = "I like python"
print(str31.istitle())  # False

str32 = "I Like PYTHON"
print(str32.istitle())  #False

12>. isprintable()

描述：判断字符串中是否有打印后不可见的内容。如：\n \t 等字符。若字符串中不存在\n \t 等不可见的内容，则返回True,否者返回False。

语法： str.isprintable() -> bool 返回值为布尔类型（True,False）

# 不存在用print()打印后不可见的内容
str33 = "I like python"
print(str33.isprintable())  # True

# 存在用print()打印后不可见的内容 \n
str34 = "I like python \n"
print(str34.isprintable())  # False

7. 字符串替换

1>. strip()

描述：该函数的作用是去除字符串开头和结尾处指定的字符，不会去除字符串中间对应的字符

语法：str.strip(chars)

参数：chars – 要去除的字符 默认为空格或换行符。

str35 = "  I like python   "
print(str35.strip())  # I like python

str36 = "% I Like Python %" 
print(str36.strip("% "))  # I Like Python  去除两端指定字符

2>. lstrip()

描述：lstrip() 方法用于截掉字符串左边的空格或指定字符。

语法：str.lstrip(chars)

参数：chars–要去除的字符 默认为空格或换行符。

str37 = "--% I like python %%"
print(str37.lstrip("-% "))  # I like python %% 

3>. rstrip()

描述： 删除 str 字符串末尾的指定字符（默认为空格）

语法：str.rstrip(chars)

参数：chars --要去除的字符 默认为空格或换行符。

str37 = "--% I like python %%"
print(str37.rstrip(" %"))  # --% I like python

8. 字符串切割

1>. partition()

描述：根据指定的分隔符(sep)将字符串进行分割。从字符串左边开始索引分隔符sep,索引到则停止索引。

语法： str.partition(sep)

参数：sep —— 指定的分隔符。

返回值：(head, sep, tail) 返回一个三元元组，head:分隔符sep前的字符串，sep:分隔符本身，tail:分隔符sep后的字符串。如果字符串包含指定的分隔符sep，则返回一个三元元组，第一个为分隔符sep左边的子字符串，第二个为分隔符sep本身，第三个为分隔符sep右边的子字符串。如果字符串不包含指定的分隔符sep,仍然返回一个三元元组，第一个元素为字符串本身，第二第三个元素为空字符串

str38 = "I Like ii % Python"
print(str38.partition("ii"))  # ('I Like ', 'ii', ' % Python')

I LIke为分割后的head

ii分割符本身

% Python分割后的tail

2>. rpartition()

描述：根据指定的分隔符(sep)将字符串进行分割。从字符串右边(末尾)开始索引分隔符sep,索引到则停止索引。

语法： str.rpartition(sep)

参数：sep —— 指定的分隔符。

返回值： (head, sep, tail) 返回一个三元元组，head:分隔符sep前的字符串，sep:分隔符本身，tail:分隔符sep后的字符串。如果字符串包含指定的分隔符sep，则返回一个三元元组，第一个为分隔符sep左边的子字符串，第二个为分隔符sep本身，第三个为分隔符sep右边的子字符串。如果字符串不包含指定的分隔符sep,仍然返回一个三元元组，第一个元素为字符串本身，第二第三个元素为空字符串。

注：rpartition()函数与partition()函数用法相似，rpartition()函数从右边(末尾)开始索引，partition()函数从左边开始索引。

str39 = "I Like ii % Python"
print(str39.partition("%"))  # ('I Like ii ', '%', ' Python')

3>. split()

描述：拆分字符串。通过指定分隔符sep对字符串进行分割，并返回分割后的字符串列表。

语法： str.split(sep=None, maxsplit=-1) [n]

sep —— 分隔符，默认为空格,但不能为空即(")。
maxsplit —— 最大分割参数，默认参数为-1。
[n] —— 返回列表中下标为n的元素。列表索引的用法。

str40 = "I like python"
print(str40.split())  # ['I', 'like', 'python']

str41 = "www.donghaiming.cn"
print(str41.split("."))  # ['www', 'donghaiming', 'cn'] 按指定字符进行分割

4>. rsplit()

描述：拆分字符串。通过指定分隔符sep对字符串进行分割，并返回分割后的字符串列表,类似于split()函数，只不过 rsplit()函数是从字符串右边(末尾)开始分割。

语法：str.rsplit(sep=None, maxsplit=-1) -> list of strings 返回 字符串列表 或str.rsplit(sep=None, maxsplit=-1)[n]

sep —— 分隔符，默认为空格,但不能为空即(")。
maxsplit —— 最大分割参数，默认参数为-1。
[n] —— 返回列表中下标为n的元素。列表索引的用法。

str42 = "www.donghaiming.cn"
print(str42.rsplit("."))  # ['www', 'donghaiming', 'cn'] 按指定字符进行分割

5>. splitlines()

描述：按照(‘\n’, ‘\r’, \r\n’等)分隔，返回一个包含各行作为元素的列表，默认不包含换行符。\n 换行符 \r 回车符 \r\n 回车+换行
语法：S.splitlines([keepends=False])

参数：keepends – 在输出结果里是否去掉行界符(‘\r’, ‘\r\n’, \n’等)，默认为 False，不包含行界符，如果为 True，则保留行界符。

str43 = "Hello \nWorld \n"

print(str43.splitlines())  # ['Hello ', 'World ']

print(str43.splitlines(keepends=True))  # ['Hello \n', 'World \n'] keepends=True,可以保留换行符

6>. join()

描述：将iterable变量的每一个元素后增加一个str字符串。

语法： sep.join(iterable) sep——分隔符。可以为空。 iterable—— 要连接的变量 ，可以是 字符串，元组，字典，列表等。

# 字符串连接
str44 = 'python'
print('-'.join(str44))  # p-y-t-h-o-n

# 元组连接
tuple01 = ("I", "Like", "Python")
print(" ".join(tuple01))  # I Like Python

# 集合连接
set01 = {"I", "Like", "Python"}
print(" ".join(set01))  # Like Python I  注意： 集合是无序的，所以在连接时，顺序会出现错乱。

# 列表连接
list01 = ["I", "Like", "Python"]
print(" ".join(list01))
list02 = [1, 3, 5, 7]
print("".join(list02))  # TypeError: sequence item 0: expected str instance, int found
# 注意： 列表可以存放的数据，一定要是字符串，才可以进行连接，否则会报错。

# 字典连接
str45 = {'name': "Jack", 'gender': 'male', 'from': 'China', 'age': 18}
print(" ".join(str45))  # name gender from age

9. 字符串统计

1>. count()

描述：统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。

语法：str.count(“char”, start,end) 或 str.count(“char”)

str —— 为要统计的字符(可以是单字符，也可以是多字符)。
star —— 为索引字符串的起始位置，默认参数为0。
end —— 为索引字符串的结束位置，默认参数为字符串长度即len(str)。

str46 = "I Like Python Jack Tom Tony"
print(str46.count("o"))  # 3 统计字符o在本字符串中出现的次数

str47 = "Like OK Like OK Jack OK Tom OK"
print(str47.count("OK"))  # 4