序言:
字符串属于序列类型,根据字符串内容的多少可以将字符串分为单行字符串和多行字符串。其中单行字符串可以由一对双引号(" ")或一对单引号(' ')表示,单引号和双引号等效。多行字符串可由一对三单引号(''' ''')或一对三双引号(""" """)表示,三单引号和三双引号也等效。
1. capitalize()函数
描述:将字符串的第一个字母变成大写,其余字母变为小写。
语法:str.capitalize() —> str 返回字符串
程序示例:
str1 = "i Love python"
str2 = " i Love python"
str3 = "I Love python"
print(str1.capitalize())
print(str2.capitalize())
print(str3.capitalize())
程序运行结果:
I love python
i love python
I love python
2. title()函数
描述:返回一个满足标题格式的字符串。即所有英文单词首字母大写,其余英文字母小写。
语法:str.title() -> str 返回一个字符串
程序示例:
str = "i love python"
print(str.title())
程序运行结果:
I Love Python
3. swapcase()函数
描述:将字符串str中的大小写字母同时进行互换。即将字符串str中的大写字母转换为小写字母,将小写字母转换为大写字母。
语法:str.swapcase() -> str 返回字符串
程序示例:
str1="I Love PYTHON"
str2="我爱python Python pYTHON"
print(str1.swapcase())
print(str2.swapcase())
程序运行结果:
i lOVE python
我爱PYTHON pYTHON Python
4. lower()函数
描述:将字符串中的所有大写字母转换为小写字母。
语法:str.lower() -> str 返回字符串
程序示例:
str1 = "I Love Python"
str2 = "Groß - α"
print(str1.casefold())
print(str1.lower())
print(str2.casefold())
print(str2.lower())
程序运行结果:
i love python
i love python
gross - α
groß - α
注意 lower()函数和casefold()函数的区别:
lower() 方法只对ASCII编码,即‘A-Z’有效,对于其它语言中把大写转换为小写的情况无效,只能用 casefold() 函数。
5. upper()函数
描述:将字符串中的所有小写字母转换为大写字母。
语法:str.upper() -> str 返回字符串
程序示例:
str1 = "i love python"
str2 = "I Love Python"
print(str1.upper())
print(str2.upper())
程序运行结果:
I LOVE PYTHON
I LOVE PYTHON
6. casefold()函数
描述:将字符串中的所有大写字母转换为小写字母。也可以将非英文 语言中的大写转换为小写。
注意 lower()函数和casefold()函数的区别:lower() 方法只对ASCII编码,即‘A-Z’有效,对于其它语言中把大写转换为小写的情况无效,只能用 casefold() 函数。
语法:str.casefold() -> str 返回字符串
程序示例:
str1 = "I Love Python"
str2 = "Groß - α" #德语 大写α
print(str1.casefold())
print(str1.lower())
print(str2.casefold())
print(str2.lower())
程序运行结果:
i love python
i love python
gross - α
groß - α
解决字符串填充问题:
7. center()函数
描述:返回一个长度为width,两边用fillchar(单字符)填充的字符串,即字符串str居中,两边用fillchar填充。若字符串的长度大于width,则直接返回字符串str。
语法:str.center(width , "fillchar") -> str 返回字符串 注意:引号不可省
width —— 指定字符串长度。
fillchar —— 要填充的单字符,默认为空格。
程序示例:
str = "i love python"
print(str.center(20,"*"))
print(str.center(1,"*"))
print(str.center(20,"8"))
print(str.center(20))
程序运行结果:
***i love python****
i love python
888i love python8888
i love python
8. ljust()函数
描述:返回一个原字符串左对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
语法:str.ljust(width, fillchar) -> str 返回一个新的字符串
width —— 指定字符串的输出长度。
fillchar—— 将要填充的单字符,默认为空格。
程序示例:
str = "python"
print(str.ljust(30,"*"))
print(str.ljust(30))
print(str.ljust(30),"1")
程序运行结果:
python************************
python
python 1
9. rjust()函数
描述:返回一个原字符串右对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
语法:str.ljust(width, fillchar) -> str 返回一个新的字符串
width —— 指定字符串的输出长度。
fillchar—— 将要填充的单字符,默认为空格。
程序示例:
str = "python"
print(str.rjust(30,"*"))
print(str.rjust(30))
print("1",str.rjust(30))
程序运行结果:
************************python
python
1 python
10. zfill()函数
描述:返回指定长度的字符串,使原字符串右对齐,前面用0填充到指定字符串长度。
语法:str.zfill(width) -> str 返回一个字符串
width —— 指定字符串的长度,但不能为空。若指定长度小于字符串长度,则直接输出原字符串。
程序示例:
str = "i love python"
print(str.zfill(30))
print(str.zfill(2))
print(str.zfill())
程序运行结果:
i love python
Traceback (most recent call last):
File "D:/python/work/chaper01/字符串.py", line 10, in print(str.zfill())
TypeError: zfill() takes exactly one argument (0 given)
解决统计字符次数问题:
11. count()函数
描述:统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。
语法:str.count("char", start,end) 或 str.count("char") -> int 返回整数
str —— 为要统计的字符(可以是单字符,也可以是多字符)。
star —— 为索引字符串的起始位置,默认参数为0。
end —— 为索引字符串的结束位置,默认参数为字符串长度即len(str)。
程序示例:
str = "i love python,i am learning python"
print(str.count("i"))
print(str.count("i",2))
print(str.count("i",2,5))
print(str.count("am"))
程序运行结果:
3
2
0
1
解决编码问题:
12. encode()函数
描述:以指定的编码格式编码字符串,默认编码为 'utf-8'。
语法:str.encode(encoding='utf-8', errors='strict') -> bytes (获得bytes类型对象)
encoding 参数可选,即要使用的编码,默认编码为 'utf-8'。字符串编码常用类型有:utf-8,gb2312,cp936,gbk等。
errors 参数可选,设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeEncodeError。其它可能值有 'ignore', 'replace', 'xmlcharrefreplace'以及通过 codecs.register_error() 注册其它的值。
程序示例:
str1 = "我爱祖国"str2 = "I love my country"print("utf8编码:",str1.encode(encoding="utf8",errors="strict"))print("utf8编码:",str2.encode(encoding="utf8",errors="strict"))print("gb2312编码:",str1.encode(encoding="gb2312",errors="strict"))print("gb2312编码:",str2.encode(encoding="gb2312",errors="strict"))print("cp936编码:",str1.encode(encoding="cp936",errors="strict"))print("cp936编码:",str2.encode(encoding="cp936",errors="strict"))print("gbk编码:",str1.encode(encoding="gbk",errors="strict"))print("gbk编码:",str2.encode(encoding="gbk",errors="strict"))
程序运行结果:
utf8编码:b'\xe6\x88\x91\xe7\x88\xb1\xe7\xa5\x96\xe5\x9b\xbd'
utf8编码:b'I love my country'
gb2312编码:b'\xce\xd2\xb0\xae\xd7\xe6\xb9\xfa'
gb2312编码:b'I love my country'
cp936编码:b'\xce\xd2\xb0\xae\xd7\xe6\xb9\xfa'
cp936编码:b'I love my country'
gbk编码:b'\xce\xd2\xb0\xae\xd7\xe6\xb9\xfa'
gbk编码:b'I love my country'
13. decode()函数
描述:以 encoding 指定的编码格式解码字符串,默认编码为字符串编码。
语法:str.decode(encoding='utf-8', errors='strict')
encoding ——要使用的编码,如:utf-8,gb2312,cp936,gbk等。
errors ——设置不同解码错误的处理方案。默认为 'strict',意为编码错误引起一个 UnicodeDecodeError。其它可能得值有 'ignore', 'replace'以及通过 codecs.register_error() 注册的1其它值。
程序示例:
s = "我爱祖国"str1 = s.encode(encoding="utf-8",errors="strict")str2 = s.encode("gb2312")str3 = s.encode("gbk")print(str1.decode(encoding="utf-8",errors="strict"))print(str1.decode(encoding="gbk",errors="ignore"))print(str1.decode(encoding="gbk",errors="strict"))print(str1.decode(encoding="gbk",errors="replace"))print("\n")print(str2.decode("gb2312"))print(str3.decode("gbk"))
程序运行结果:
我爱祖国
鎴戠埍绁栧浗
鎴戠埍绁栧浗
鎴戠埍绁栧浗
我爱祖国
我爱祖国
注:在python3.x中,encode()函数只能用于字符串类型,而decode()函数只能用于字节数据类型。
程序示例中 str1,str2,str3都是字节数据类型(通过encode()函数把 字符串类型s 转换为字节数据类型)。
14. expandtabs()函数
描述:返回一个字符串的副本。使原字符串中的制表符("\t")的使用空间变大。使用空格来扩展空间。
语法:str.expandtabs(tabsize=8) —> str 返回字符串
tabsize 的默认值为8。tabsize值为0到7等效于tabsize=8。tabsize每增加1,原字符串中“\t”的空间会多加一个空格。
程序示例:
str = "i love\tpython"
print(str.expandtabs())
print(str.expandtabs(tabsize=8))
print(str.expandtabs())
print(str.expandtabs(2))
print(str.expandtabs(tabsize=2))
print(str.expandtabs(tabsize=9))
print(str.expandtabs(tabsize=10))
程序运行结果:
i love python
i love python
i love python
i love python
i love python
i love python
i love python
解决查找指定字符(子字符串)位置问题:
15. find()函数
描述:查找字符串中指定的子字符串sub第一次出现的位置,可以规定字符串的索引查找范围。若无则返回 -1。
语法:str.find(sub,start,end) -> int 返回整数
sum —要索引的子字符串。
start —索引的起始位置。默认值为0。
end —索引的结束位置。默认值为字符串长度len(str)。
[start,end) 不包括end。
程序示例:
str = "i love python"
print(str.find("o"))
print(str.find("0",4))
print(str.find("o",4,12))
print(str.find(""))
print(str.find(" "))
print(str.find("k"))
程序运行结果:
3
-1
11
0
1
-1
16. rfind()函数
描述:查找字符串中指定的子字符串sub最后一次出现的位置,可以规定字符串的索引查找范围。若无则返回 -1。
语法:str.rfind(sub,start,end) -> int 返回整数
sum —要索引的子字符串。
start —索引的起始位置。默认值为0。
end —索引的结束位置。默认值为字符串长度len(str)。
[start,end) 不包括end。
注:rfind()函数用法与find()函数相似,rfind()函数返回指定子字符串最后一次出现的位置,find()函数返回指定子字符串第一次出现的位置。
程序示例:
str = "i love python python"
print(str.rfind("o"))
print(str.rfind("o",11))
print(str.rfind("o",0,12))
print(str.rfind("python"))
print(str.rfind(""))
print(str.rfind(" "))
print(str.rfind("2"))
程序运行结果:
18
18
11
14
20
13
-1
17. index()函数
描述:查找字符串中第一次出现的子字符串的位置,可以规定字符串的索引查找范围[star,end)。若无则会报错。
语法:str.index(sub, start, end) -> int 返回整数
sub —— 查找的子字符串。
start —— 索引的起始位置,默认为0。
end —— 索引的结束位置,默认为字符串的长度。
[star,end)
程序示例:
str = "i love python"
print(str.index("o"))
print(str.index("o",4))
print(str.index("o",4,12))
print(str.index("love"))
print(str.index("k"))
程序运行结果:
Traceback (most recent call last):
File "D:/python/work/chaper01/字符串.py", line 16, in
print(str.index("k"))ValueError: substring not found
3
11
11
2
注:index()函数和find()函数类似,但index()函数没有找到子字符串会报错。
18. rindex()函数
描述:查找字符串中最后一次出现的子字符串的位置,可以规定字符串的索引查找范围[star,end),若无则会报错。
语法:str.rindex(sub, start, end) -> int 返回整数。
sub —— 查找的子字符串。
start —— 索引的起始位置,默认为0。
end —— 索引的结束位置,默认为字符串的长度。
[star,end)
注:rindex()函数用法与index()函数相似,rindex()函数返回指定子字符串最后一次出现的位置,index()函数返回指定子字符串第一次出现的位置。
程序示例:
str = "i love python python"
print(str.rindex("p"))
print(str.rindex("o",5))
print(str.rindex("o",5,13))
print(str.rindex("python"))
print(str.rindex("k"))
len(str),str[5:13]
程序运行结果:
14
18
11
14
Traceback (most recent call last):
File "D:/python/work/chaper01/字符串.py", line 16, in
print(str.rindex("k"))ValueError: substring not found
解决判断问题(返回bool类型)
21. endswith()函数
描述:判断字符串是否以指定字符或子字符串结尾。
语法:str.endswith("suffix", start, end) 或
str[start,end].endswith("suffix") 用于判断字符串中某段字符串是否以指定字符或子字符串结尾。
—> bool 返回值为布尔类型(True,False)
suffix — 后缀,可以是单个字符,也可以是字符串,还可以是元组("suffix"中的引号要省略,常用于判断文件类型)。
start —索引字符串的起始位置。
end — 索引字符串的结束位置。
str.endswith(suffix) star默认为0,end默认为字符串的长度len(str)
注意:空字符的情况。返回值通常为True
程序示例:
str = "i love python"
print("1:",str.endswith("n"))
print("2:",str.endswith("python"))
print("3:",str.endswith("n",0,6))
print("4:",str.endswith(""))
print("5:",str[0:6].endswith("n"))
print("6:",str[0:6].endswith("e"))
print("7:",str[0:6].endswith(""))
print("8:",str.endswith(("n","z")))
print("9:",str.endswith(("k","m")))
file = "python.txt"
if file.endswith("txt"):
print("该文件是文本文件")
elif file.endswith(("AVI","WMV","RM")):
print("该文件为视频文件")
else:
print("文件格式未知")
程序运行结果:
1: True
2: True
3: False
4: True
5: False
6: True
7: True
8: True
9: False
该文件是文本文件
22. startswith()函数
描述:判断字符串是否以指定字符或子字符串开头。
语法:str.endswith("suffix", start, end) 或
str[start,end].endswith("suffix") 用于判断字符串中某段字符串是否以指定字符或子字符串结尾。
—> bool 返回值为布尔类型(True,False)
suffix — 后缀,可以是单个字符,也可以是字符串,还可以是元组("suffix"中的引号要省略)。
start —索引字符串的起始位置。
end — 索引字符串的结束位置。
str.endswith(suffix) star默认为0,end默认为字符串的长度减一(len(str)-1)。
注意:空字符的情况。返回值通常也为True
程序示例:
str = "hello,i love python"
print("1:",str.startswith("h"))
print("2:",str.startswith("l",2,10))
print("3:",str.startswith(""))
print("4:",str[0:6].startswith("h"))
print("5:",str[0:6].startswith("e"))
print("6:",str[0:6].startswith(""))
print("7:",str.startswith(("h","z")))
print("8:",str.startswith(("k","m")))
程序运行结果:
1: True
2: True
3: True
4: True
5: False
6: True
7: True
8: False
23. isalnum()函数
描述:检测字符串是否由字母和数字组成。
语法:str.isalnum() -> bool 返回值为布尔类型(True,False)
str中至少有一个字符且所有字符都是字母或数字则返回 True,否则返回 False
程序示例:
str1 = "i love python 666"
str2 = "python" #全为字母
str3 = "123" #全为数字
str4 = "python666"
print(str1.isalnum())
print(str2.isalnum())
print(str3.isalnum())
print(str4.isalnum())
程序运行结果:
False
True
True
True
24. isalpha()函数
描述:检测字符串是否只由字母组成。
语法:str.isalpha() -> bool 返回值为布尔类型(True,False)
字符串中至少有一个字符且所有字符都是字母则返回 True,否则返回 False。
程序示例:
str1 = "python" #全为字母
str2 = " python" #存在空格
str3 = "123" #全为数字
str4 = "python666"
print(str1.isalpha())
print(str2.isalpha())
print(str3.isalpha())
print(str4.isalpha()
程序运行结果:
True
False
False
False
25. isdecimal()函数
描述:检查字符串是否只包含十进制字符。该方法只存在于unicode对象中。
注意:定义一个十进制字符串,只需要在字符串前添加前缀 'u' 即可。
语法:str.isdecimal() -> bool 返回值为布尔类型(True,False)
字符串中若只包含十进制字符返回True,否则返回False。
程序示例:
str1 = u"123456"
str2 = u"python666"
str3 = "123456"
str4 = "python666"
print(str1.isdecimal())
print(str2.isdecimal())
print(str3.isdecimal())
print(str4.isdecimal())
程序运行结果:
True
False
True
False
26. isdigit()函数
描述:检测字符串是否只由数字组成.
语法:str.isdigit() -> bool 返回值为布尔类型(True,False)
字符串中至少有一个字符且所有字符都是数字则返回 True,否则返回 False。
注:能判断“①”,不能判断中文数字。但 isnumeric() 函数可以。
程序示例:
str1 = "python" #全为字母
str2 = " python" #存在空格
str3 = "123" #全为数字
str4 = "python666"
str5 = "一二三四五六七"
str6 = "①"
print(str1.isdigit())
print(str2.isdigit())
print(str3.isdigit())
print(str4.isdigit())
print(str5.isdigit())
print(str6.isdigit())
程序运行结果:
False
False
True
False
False
True
27. isidentifier()函数
描述:判断str是否是有效的标识符。str为符合命名规则的变量,保留标识符则返回True,否者返回False。
语法:str.isidentifier() -> bool 返回值为布尔类型(True,False)
程序示例:
str1 = "123" #变量名为123
str2 = "def" #变量名为保留字
str3 = "_123" #变量名有下划线开头
str4 = "student"#变量名由字母开端
print(str1.isidentifier())
print(str2.isidentifier())
print(str3.isidentifier())
print(str4.isidentifier())
程序运行结果:
False
True
True
True
28. islower()函数
描述:检测字符串中的字母是否全由小写字母组成。(字符串中可包含非字母字符)
语法:str.islower() -> bool 返回值为布尔类型(True,False)
字符串中包含至少一个区分大小写的字符,且所有这些区分大小写的字符都是小写,则返回 True,否则返回 False。
程序示例:
str1 = "i love python"
str2 = "我爱python!"
str3 = "I love python"
print(str1.islower())
print(str2.islower())
print(str3.islower())
程序运行结果:
True
True
False
29. isupper()函数
描述:检测字符串中的字母是否全由大写字母组成。(字符串中可包含非字母字符)。
语法:str.isupper() -> bool 返回值为布尔类型(True,False)
字符串中包含至少一个区分大小写的字符,且所有这些区分大小写的字符都是大写,则返回 True,否则返回 False。
程序示例:
str1 = "I LOVE PYTHON" #全为大写字母
str2 = "i LOVE PYTHON" #存在小写字母
str3 = "我爱PYTHON" #存在非字母的字符
print(str1.isupper())
print(str2.isupper())
print(str3.isupper())
程序运行结果:
True
False
True
30. isnumeric()函数
描述:测字符串是否只由数字组成。这种方法是只适用于unicode对象。
注:把一个字符串定义为Unicode,只需要在字符串前添加 前缀 'u'
语法:str.isnumeric() -> bool 返回值为布尔类型(True,False)
字符串中只包含数字字符,则返回 True,否则返回 False。
与isdigit()函数类似,但isnumeric()函数可以判断中文数字,功能更强大。
程序示例:
str1 = u"123456" #全为数字
str2 = "123456"
str3 = "python666" #字母数字组合
str4 = "一二三四五六" #中文数字
str5 = "①"
print(str1.isnumeric())
print(str2.isnumeric())
print(str3.isnumeric())
print(str4.isnumeric())
print(str5.isnumeric())
程序运行结果:
True
True
False
True
True
31. isprintable()函数
描述:判断字符串中是否有打印后不可见的内容。如:\n \t 等字符。
语法: str.isprintable() -> bool 返回值为布尔类型(True,False)
若字符串中不存在\n \t 等不可见的内容,则返回True,否者返回False。
程序示例:
str1 = "i love python"
str2 = "i love python \n"
str3 = "i love \t python"
print(str1.isprintable())
print(str2.isprintable())
print(str3.isprintable())
程序运行结果:
True
False
False
32. isspace()函数
描述: 检测字符串是否只由空格组成。
语法:str.isspace() -> bool 返回值为布尔类型(True,False)
若字符串中只包含空格,则返回 True,否则返回 False。
程序示例:
str1 = " "#空格
str2 = "i love python"
print(str1.isspace())
print(str2.isspace())
print(str2[1].isspace())
程序运行结果:
True
False
True
33. istitle()函数
描述:检测判断字符串中所有单词的首字母是否为大写,且其它字母是否为小写,字符串中可以存在其它非字母的字符。
语法:str.istitle() -> bool 返回值为布尔类型(True,False)
若字符串中所有单词的首字母为大写,且其它字母为小写,则返回 True,否则返回 False.
程序示例:
str1 = "I Love Python"
str2 = "I love python"
str3 = "I LOVE PYTHON"
str4 = "我爱Python"
print(str1.istitle())
print(str2.istitle())
print(str3.istitle())
print(str4.istitle())
程序运行结果:
True
False
False
True
解决字符串两端:
34. strip()函数
描述:从字符串str中去掉在其左右两边chars中列出的字符。
注:chars传入的是一个字符数组,编译器去除两端所有相应的字符,直到出现第一个在chars中不匹配的字符。详看示例。
语法:str.strip(chars) -> str 返回一个新的字符串
chars —— 要去除的字符 默认为空格或换行符。
程序示例:
str = "123456789321"
print(str.strip("123"))
str1 = "my name is ymyyyy"
print(str1.strip("my"))
print(str1.strip("my "))
程序运行结果:
456789
name is
name is
35. lstrip()函数
描述:从字符串str中去掉在其左边chars中列出的字符。
注:chars传入的是一个字符数组,编译器去除两端所有相应的字符,直到出现第一个在chars中不匹配的字符。详看示例。
语法:str.lstrip(chars) -> str 返回一个新的字符串
chars —— 要去除的字符 默认为空格或换行符。
程序示例:
str1 = "bacjabck123kluabc"
print(str1.lstrip("abc"))
str2 = "12578asdfgh12"
print(str2.lstrip("12"))
程序运行结果:
jabck123kluabc
578asdfgh12
36. rstrip()函数
描述:从字符串str中去掉在其右边chars中列出的字符。
注:chars传入的是一个字符数组,编译器去除两端所有相应的字符,直到出现第一个在chars中不匹配的字符。详看示例。
语法:str.rstrip(chars) -> str 返回一个新的字符串
chars —— 要去除的字符 默认为空格或换行符。
程序示例:
str1 = "abcjabck123kluabcca"
print(str1.rstrip("abc"))
str2 = "12578asdfgh11112"
print(str2.rstrip("12"))
程序运行结果:
abcjabck123klu
12578asdfgh
解决 制表 翻译 问题:
37. maketrans()函数
描述:制作翻译表,删除表,常与translate()函数连用。即:返回用于str.translate()函数翻译的的转换表。
语法:maketrans(x, y=None, z=None, /) 返回可用于str.translate()函数的转换表
str.maketrans(x,y,z)
bytes.maketrans(x,y)
bytearray.maketrans(x,y)
如果只有一个参数x,它必须是一个字典且为Unicode形式的映射。
如果有两个参数x和y,它们必须是长度相等的字符串,并且在结果映射中,x中的每个字符都将映射到y中相同位置的字符(Unicode形式的映射)。
如果有三个参数x,y和z. x和y用法同上,z为指定要删除的字符串,其结果中的字符将一一映射为:None。
bytes.maketrans(x,y) 和 bytearray.maketrans(x,y) 必须要有x和y两个参数。注:z的长度可以和x和y不同。
str.maketrans(x,y,z)形式:
程序示例:
s = "123456789"
#只有参数x,且x为字典。
map1 = str.maketrans({"1":"a","2":"b","3":"c"})
print(map1,type(map1),ord("1"),ord("2"),ord("3"))
map2 = str.maketrans("123","abc")
print(map2,type(map2),ord("a"),ord("b"),ord("c"))
map3 = str.maketrans("123","abc","56k")
print(map3,type(map3),ord("5"),ord("6"),ord("k"))
程序运行结果:
49: 'a', 50: 'b', 51: 'c'} <class 'dict'> 49 50 51
{49: 97, 50: 98, 51: 99} <class 'dict'> 97 98 99
{49: 97, 50: 98, 51: 99, 53: None, 54: None, 107: None} <class 'dict'> 53 54 107 In [6]:
bytes.maketrans(x,y)形式:
程序示例:
map4 = bytes.maketrans(b"123",b"abc")
print(type(b"123"),type(b"abc"),type(map4),map4)
程序运行结果:
<class 'bytes'> <class 'bytes'> <class 'bytes'>
b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0abc456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
bytearray.maketrans(x,y)形式:
程序示例:
map5 = bytearray.maketrans(b"123",b"abc")
print(type(b"123"),type(b"abc"),type(map5),map5)
程序运行结果:
<class 'bytes'> <class 'bytes'> <class 'bytes'>
b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0abc456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
38.0 translate()函数
描述:过滤(删除),翻译字符串。即根据maketrans()函数给出的字符映射转换表来转换字符串中的字符。
注:translate()函数是先过滤(删除),再根据maketrans()函数返回的转换表来翻译。
语法:str.translate(table) -> str 返回一个字符串
str.translate(table)
bytes.translate(table, deletechars)
bytearray.translate(table, deletechars)
table —— 转换表,转换表是通过maketrans()函数转换而来。
deletechars —— 字符串中要过滤(删除)的字符。
程序示例:
s = "123456789abc"s1 = b"123456789abc"map1 = str.maketrans({"1":"a","2":"b","3":"c"})print(map1,type(map1),ord("1"),ord("2"),ord("3"))
map2 = str.maketrans("123","abc")print(map2,type(map2),ord("a"),ord("b"),ord("c"))#有x,y,z三个参数map3 = str.maketrans("123","abc","56k")print(map3,type(map3),ord("5"),ord("6"),ord("k"))
map4 = bytes.maketrans(b"123",b"abc")print(type(b"123"),type(b"abc"),type(map4),map4)print("\n")
map5 = bytearray.maketrans(b"123",b"abc")print(type(b"123"),type(b"abc"),type(map5),map5)print("\n\n")print(s.translate(map1))print(s.translate(map2))print(s.translate(map3))print(s1.translate(map5))print(s1.translate(map4,b"78b"))print(s1.translate(map5,b"9"))
程序运行结果:
{49: 'a', 50: 'b', 51: 'c'} 49 50 51
{49: 97, 50: 98, 51: 99} 97 98 99
{49: 97, 50: 98, 51: 99, 53: None, 54: None, 107: None} 53 54 107
b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0abc456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0abc456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
abc456789abc
abc456789abc
abc4789abc
b'abc456789abc'
b'abc4569ac'
b'abc45678abc'
解决分割字符串问题:
39. partition()函数:
描述:根据指定的分隔符(sep)将字符串进行分割。从字符串左边开始索引分隔符sep,索引到则停止索引。
语法:str.partition(sep) -> (head, sep, tail) 返回一个三元元组,head:分隔符sep前的字符串,sep:分隔符本身,tail:分隔符sep后的字符串。
sep —— 指定的分隔符。
如果字符串包含指定的分隔符sep,则返回一个三元元组,第一个为分隔符sep左边的子字符串,第二个为分隔符sep本身,第三个为分隔符sep右边的子字符串。
如果字符串不包含指定的分隔符sep,仍然返回一个三元元组,第一个元素为字符串本身,第二第三个元素为空字符串
程序示例:
str = "https://www.baidu.com/"
print(str.partition("://"))
print(str.partition(","))
print(str.partition("."))
print(type(str.partition("://")))
程序运行结果:
('https', '://', 'www.baidu.com/')
('https://www.baidu.com/', '', '')
('https://www', '.', 'baidu.com/')
<class 'tuple'>
40. rpartition()函数
描述:根据指定的分隔符(sep)将字符串进行分割。从字符串右边(末尾)开始索引分隔符sep,索引到则停止索引。
语法:str.rpartition(sep) -> (head, sep, tail) 返回一个三元元组,head:分隔符sep前的字符串,sep:分隔符本身,tail:分隔符sep后的字符串。
sep —— 指定的分隔符。
如果字符串包含指定的分隔符sep,则返回一个三元元组,第一个为分隔符sep左边的子字符串,第二个为分隔符sep本身,第三个为分隔符sep右边的子字符串。
如果字符串不包含指定的分隔符sep,仍然返回一个三元元组,第一个元素为字符串本身,第二第三个元素为空字符串。
注:rpartition()函数与partition()函数用法相似,rpartition()函数从右边(末尾)开始索引,partition()函数从左边开始索引。
程序示例:
str = "https://www.baidu.com/"
print(str.rpartition("://"))
print(str.rpartition(","))
print(str.rpartition("."))
print(type(str.partition("://")))
程序运行结果:
('https', '://', 'www.baidu.com/')
('', '', 'https://www.baidu.com/')
('https://www.baidu', '.', 'com/')
<class 'tuple'>
41. split()函数
描述:拆分字符串。通过指定分隔符sep对字符串进行分割,并返回分割后的字符串列表。
语法:str.split(sep=None, maxsplit=-1) -> list of strings 返回 字符串列表 或str.split(sep=None, maxsplit=-1)[n]
sep —— 分隔符,默认为空格,但不能为空即(")。
maxsplit —— 最大分割参数,默认参数为-1。
[n] —— 返回列表中下标为n的元素。列表索引的用法。
程序示例:str1 = "i love python"
str2 = "https://www.baidu.com"
str3 = "scriptscript"
str4 = "i \n love \n python"
print(str1.split())
print(str2.split("."))
print(str2.split(".",-1))
print(str2.split(".",1))
print(str2.split(".")[1])
print(str3.split(")[1].split(">")[0])
print(str4.split("\n"))
程序运行结果:
['i', 'love', 'python']
['https://www', 'baidu', 'com']
['https://www', 'baidu', 'com']
['https://www', 'baidu.com']
baidu
i love python
['i ', ' love ', ' python']
42. 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的元素。列表索引的用法。
程序示例:
str = "https://www.baidu.com"
print(str.rsplit()) #默认空格分割。
print(str.rsplit("."))
print(str.rsplit(".",1))
print(str.rsplit(".",1)[1])
程序运行结果:
['https://www.baidu.com']
['https://www', 'baidu', 'com']
['https://www.baidu', 'com']
com
43. splitlines()函数
描述:按照('\n', '\r', \r\n'等)分隔,返回一个包含各行作为元素的列表,默认不包含换行符。
符号 | 描述 |
\n | 换行符 |
\r | 回车符 |
\r\n | 回车+换行 |
语法:str.splitlines(keepends) -> list of strings 返回 字符串列表
keepends —— 默认参数为False ,译为 不保留换行符。参数为True , 译为 保留换行符。
程序示例:
s1 = """i
love
python
"""
s2 = "i\nlove\npython\n" #与s1等效。
s3 = "123\n456\r789\r\nabc"
print(s1.splitlines(True))
print(s1.splitlines()) #keepends 默认为False
print(s1.splitlines(False))
print(s2.splitlines())
print(s3.splitlines())
程序运行结果:
['i\n', 'love\n', 'python\n']
['i', 'love', 'python']
['i', 'love', 'python']
['i', 'love', 'python']
['123', '456', '789', 'abc']
44. join()函数
描述:将iterable变量的每一个元素后增加一个str字符串。
语法:str.join(iterable) -> str 返回字符串 即:返回一个以str作为分隔符,将iterable中的各元素合并连接成一个新的字符串。
str——分隔符。可以为空。
iterable—— 要连接的变量 ,可以是 字符串,元组,字典,列表等。
程序示例:
#对列表进行操作
l = ["1","2","3"]
print(" ".join(l)) #以空格为分隔符
print(",".join(l)) #以逗号为分隔符
#对字符串进行操作
str = "python"
print(" ".join(str)) #以空格为分隔符
print(",".join(str)) #以逗号为分隔符
#对字典进行操作
d = {"a":1,"b":2,"c":3}
print(" ".join(d)) #以空格为分隔符
print(",".join(d)) #以逗号为分隔符
#对元组进行操作
s = ("1","2","3")
print(" ".join(s)) #以空格为分隔符
print(",".join(s)) #以逗号为分隔符
程序运行结果:
1 2 3
1,2,3
p y t h o n
p,y,t,h,o,n
b c a
b,c,a
1 2 3
1,2,3
解决替换问题:
45. replace()函数:
描述:返回字符串str的副本,所有old子字符串被替换为new字符串。
语法:str.replace(old, new, count) -> str 返回字符串str的副本
old —— 将被替换的子字符串。
new —— 新子字符串,用于替换old子字符串。
count —— 替换的次数,默认全部替换。
程序示例:
s = "i love python python "
print(s.replace("o","w"))
print(s.replace("o","w",2))
print(s.replace("python","c++"))
print(s.replace("python","c++",1))
程序运行结果:
i lwve pythwn pythwn
i lwve pythwn python
i love c++ c++
i love c++ python