java填充字符串到指定长度_Python字符串函数用法大全

最新推荐文章于 2024-08-11 03:16:30 发布

西部空天

最新推荐文章于 2024-08-11 03:16:30 发布

阅读量1.8k

点赞数

文章标签： java填充字符串到指定长度

本文链接：https://blog.csdn.net/weixin_31099497/article/details/112076910

版权

序言：

字符串属于序列类型，根据字符串内容的多少可以将字符串分为单行字符串和多行字符串。其中单行字符串可以由一对双引号(" ")或一对单引号(' ')表示，单引号和双引号等效。多行字符串可由一对三单引号(''' ''')或一对三双引号(""" """)表示，三单引号和三双引号也等效。

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

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

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

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

解决查找指定字符(子字符串)位置问题：

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

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

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

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

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

True

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

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

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

False

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

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

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

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'>

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

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']

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']

['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

西部空天

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫