Python基本数据类型（二）——String(字符串)

文章目录

String(字符串)一、 Unicode 字符串二、 创建字符串三、 字符串表示四、 字符串操作五、 转义字符六、 字符串运算符七、 字符串格式化1、 字符串格式化符号2、 格式化操作符辅助指令3、 字面量格式化字符串八、 字符串内建函数capitalize()center(width, fillchar)ljust(width[, fillchar])rjust(width,[, fillchar])zfill (width)count(str, beg= 0,end=len(string))bytes.decode(encoding="utf-8", errors="strict")encode(encoding='UTF-8',errors='strict')endswith(suffix, beg=0, end=len(string))startswith(substr, beg=0,end=len(string))expandtabs(tabsize=8)find(str, beg=0, end=len(string))rfind(str, beg=0,end=len(string))index(str, beg=0, end=len(string))rindex( str, beg=0, end=len(string))isalnum()isalpha()isdigit()isnumeric()islower()isupper()isspace()title()istitle()join(seq)len(s)lower()upper()swapcase()lstrip()rstrip()strip([chars])maketrans()translate(table, deletechars="")max(str)min(str)replace(old, new [, max])split(str="", num=string.count(str))splitlines([keepends])isdecimal()

String(字符串)

string、list 和 tuple 都属于 sequence（序列）

一、 Unicode 字符串

Python3中，所有的字符串都是Unicode字符串（Python2中，普通字符串是以8位ASCII码进行存储）

Unicode字符串存储16位unicode字符串，使用时在字符串前面加上前缀 u即可

二、 创建字符串

使用单引号 ’或双引号 "来创建字符串，为变量分配一个值

tips :单字符在 Python 中作为字符串使用

s1 = '字符串1'#单引号创建s2 = "字符串2"#双引号创建s2 = "s"#单字符在py中作为字符串使用

三、 字符串表示

没有单独的字符类型，一个字符就是长度为 1 的字符串（不区分单字符与多字符）

单引号 ’或双引号 "括起来表示字符串（单引号和双引号使用完全相同）

使用三引号(’’’ 或 “”")可以指定一个多行字符串，反斜杠\也可以作为续行符

字符串不能改变，比如向一个索引位置赋值，word[0] = ‘m’ 会导致错误

word = '字符串'sentence = "这是一个句子。"paragraph = """这是一个段落，可以由多行组成"""

四、 字符串操作

字符串截取：

变量[头下标:尾下标]

变量[头下标:尾下标:步长]

两种索引方式：

从左往右，以0开始

从右往左，以-1开始

字符串连接：+

字符串复制：* n（n代表复制的次数）

级联字符串：如"this " "is " "string"会被自动转换为this is string

代码示例：

str = '123456789'print(str) # 输出字符串print(str[:]) # 输出所有字符print(str[0:-1]) # 输出第一个到倒数第二个的所有字符print(str[0]) # 输出字符串第一个字符print(str[-6:-2]) #输出字符串倒数第六个到倒数第三个的所有字符[-6,-2)print(str[2:5]) # 输出从第三个开始到第五个的字符[2,5)print(str[2:]) # 输出从第三个开始后的所有字符print(str[1:5:2]) # 输出从第二个开始到第五个且每隔一个的字符（步长为2）print(str * 2) # 输出字符串两次print(str + '你好') # 连接字符串'''输出结果：1234567891234567891234567814567345345678924123456789123456789123456789你好'''

五、 转义字符

反斜杠 \ 转义特殊字符

代码示例：

print("换行符\:","line1 \line2 \line3")print("空\\000:","\000")print("纵向制表符\\v:","Hello \v World!")print("横向制表符\\t:","Hello \t World!")print("后面内容替换前面内容\\r:",'google runoob taobao\r123456')print("换页","Hello \f World!")print("八进制数:","\110\145\154\154\157\40\127\157\162\154\144\41")print("十六进制数:","\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")'''输出结果：换行符\: line1 line2 line3空\000: 纵向制表符\v: Hello World!横向制表符\t: Hello World!123456换页 Hello World!八进制数: Hello World!十六进制数: Hello World!'''

使用r或者R可以让反斜杠不发生转义

代码示例：

print('hello\nrunoob')# 使用反斜杠(\)+n转义特殊字符print(r'hello\nrunoob')# 在字符串前面添加一个 r，表示原始字符串，不会发生转义print('\n') # 输出空行print(r'\n')# 输出 \n'''输出结果：hellorunoobhello\nrunoob\n'''

六、 字符串运算符

代码示例：

a = "Hello"b = " World!"print("a + b ：", a + b)print("a * 2 ：", a * 2)print("a[1] ：", a[1])print("a[1:4] ：", a[1:4])if ("H" in a):print("\"H\" in a : True(H 在变量 a 中)")else:print("\"H\" in a : False(H 不在变量 a 中)")if ("M" not in a):print("\"M\" not in a : True(M 不在变量 a 中)")else:print("\"M\" not in a : False(M 在变量 a 中)")print("r'\\n'不发生转义: ",r'\n')print("R'\\n'不发生转义: ",R'\n')'''输出结果：a + b ： Hello World!a * 2 ： HelloHelloa[1] ： ea[1:4] ： ell"H" in a : True(H 在变量 a 中)"M" not in a : True(M 不在变量 a 中)r'\n'不发生转义: \nR'\n'不发生转义: \n'''

七、 字符串格式化

格式字符串：%

字符串输出格式化：将一个值插入到一个有字符串格式符 %s 的字符串中

1、 字符串格式化符号

代码示例：

print ("这里是 %s ,码龄 %d 年了!" % ('入错行的北北', 1))'''输出结果：这里是 入错行的北北 ,码龄 1 年了!'''

2、 格式化操作符辅助指令

3、 字面量格式化字符串

python3.6 之后版本添加，新的格式化字符串的语法

在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果

以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去

代码示例：

name = 'World'print('Hello %s' % name)print(f'Hello {name}')# 替换变量print(f'{1+2}') # 使用表达式w = {'昵称': '入错行的北北', '码龄': '1年'}print(f'{w["昵称"]}: {w["码龄"]}')x = 1print(f'{x+1}') # python 3.6print(f'{x+1=}') # Python 3.8'''输出结果：Hello WorldHello World3入错行的北北: 1年2x+1=2'''

八、 字符串内建函数

capitalize()

将字符串的第一个字符转换为大写，其它字母小写

str.capitalize()

参数

无返回值

返回一个首字母大写的字符串

代码示例：

str = "hello WORLD！"print ("str.capitalize() : ", str.capitalize())'''输出结果：str.capitalize() : Hello world！'''

center(width, fillchar)

返回一个指定宽度并居中的字符串，fillchar 为填充的字符，默认为空格

str.center(width[, fillchar])

参数

width ：字符串的宽度

fillchar ：填充字符（默认为空格）返回值

返回一个指定宽度并居中的字符串

width小于字符串宽度直接返回字符串，否则fillchar填充

代码示例：

str = "[hello]"print ("str.center(4) : ", str.center(4))print ("str.center(40) : ", str.center(40))print ("str.center(40, '*') : ", str.center(40, '*'))'''输出结果：str.center(4) : [hello]str.center(40) : [hello] str.center(40, '*') : ****************[hello]*****************'''

ljust(width[, fillchar])

返回一个原字符串左对齐，fillchar 为填充的字符，默认为空格

str.ljust(width[, fillchar])

参数

width ：指定字符串长度

fillchar ：填充字符，默认为空格返回值

返回一个指定宽度并左对齐的字符串

width小于字符串宽度直接返回字符串，否则fillchar填充

代码示例：

str = "[hello]"print ("str.center(4) : ", str.ljust(4))print ("str.center(40) : ", str.ljust(40))print ("str.center(40, '*') : ", str.ljust(40, '*'))'''输出结果：str.center(4) : [hello]str.center(40) : [hello] str.center(40, '*') : [hello]*********************************'''

rjust(width,[, fillchar])

返回一个原字符串右对齐，fillchar 为填充的字符，默认为空格

str.rjust(width[, fillchar])

参数

width ：指定字符串长度

fillchar ：填充字符，默认为空格返回值

返回一个指定宽度并右对齐的字符串

width小于字符串宽度直接返回字符串，否则fillchar填充

代码示例：

str = "[hello]"print ("str.center(4) : ", str.rjust(4))print ("str.center(40) : ", str.rjust(40))print ("str.center(40, '*') : ", str.rjust(40, '*'))'''输出结果：str.center(4) : [hello]str.center(40) :[hello]str.center(40, '*') : *********************************[hello]'''

zfill (width)

返回长度为 width 的字符串，原字符串右对齐

width小于字符串宽度直接返回字符串，否则前面填充0

str.zfill(width)

参数

width ： 指定字符串的长度。原字符串右对齐，前面填充0返回值

返回一个指定宽度并右对齐的字符串

width小于字符串宽度直接返回字符串，否则前面填充0

代码示例：

str = "hello world!"print ("str.zfill : ",str.zfill(2))print ("str.zfill : ",str.zfill(20))'''输出结果：str.zfill : hello world!str.zfill : 00000000hello world!'''

count(str, beg= 0,end=len(string))

用于统计字符串里某个字符出现的次数，可选参数为在字符串搜索的开始与结束位置

str.count(sub, start= 0,end=len(string))

参数

sub ： 搜索的子字符串

start ： 搜索的起始位置，默认索引值为0

end： 搜索的结束位置，默认为字符串的最后一个位置返回值

返回子字符串在字符串中出现的次数

代码示例：

str="Hello world！"sub='o'print ("str.count('o') : ", str.count(sub))print ("str.count('o', 3, 5) : ", str.count(sub,3,5))sub='run'print ("str.count('run') : ", str.count(sub))'''输出结果：str.count('o') : 2str.count('o', 3, 5) : 1str.count('run') : 0'''

bytes.decode(encoding=“utf-8”, errors=“strict”)

以指定的编码格式解码 bytes 对象，默认编码为 ‘utf-8’

bytes.decode(encoding=“utf-8”, errors=“strict”)

参数

encoding ： 使用的编码，如"UTF-8"

errors ：设置不同错误的处理方案（默认为 ‘strict’，意为编码错误引起一个UnicodeError，其他可能得值有 ‘ignore’， ‘replace’，‘xmlcharrefreplace’，‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值）返回值

返回解码后的字符串

代码示例：

str = "入错行的北北";str_utf8 = str.encode("UTF-8")str_gbk = str.encode("GBK")print(str)print("UTF-8 编码：", str_utf8)print("GBK 编码：", str_gbk)print("UTF-8 解码：", str_utf8.decode('UTF-8', 'strict'))print("GBK 解码：", str_gbk.decode('GBK', 'strict'))'''输出结果：入错行的北北UTF-8 编码： b'\xe5\x85\xa5\xe9\x94\x99\xe8\xa1\x8c\xe7\x9a\x84\xe5\x8c\x97\xe5\x8c\x97'GBK 编码： b'\xc8\xeb\xb4\xed\xd0\xd0\xb5\xc4\xb1\xb1\xb1\xb1'UTF-8 解码： 入错行的北北GBK 解码： 入错行的北北'''

encode(encoding=‘UTF-8’,errors=‘strict’)

以指定的编码格式编码字符串，errors参数可以指定不同的错误处理方案

str.encode(encoding=‘UTF-8’,errors=‘strict’)

参数

encoding ：要使用的编码，如: UTF-8

errors ： 设置不同错误的处理方案（默认为 ‘strict’，意为编码错误引起一个UnicodeError，其他可能得值有 ‘ignore’， ‘replace’，‘xmlcharrefreplace’，‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值）返回值

返回编码后的字符串，是一个 bytes 对象

代码示例：

str = "入错行的北北";str_utf8 = str.encode("UTF-8")str_gbk = str.encode("GBK")print(str)print("UTF-8 编码：", str_utf8)print("GBK 编码：", str_gbk)print("UTF-8 解码：", str_utf8.decode('UTF-8', 'strict'))print("GBK 解码：", str_gbk.decode('GBK', 'strict'))'''输出结果：入错行的北北UTF-8 编码： b'\xe5\x85\xa5\xe9\x94\x99\xe8\xa1\x8c\xe7\x9a\x84\xe5\x8c\x97\xe5\x8c\x97'GBK 编码： b'\xc8\xeb\xb4\xed\xd0\xd0\xb5\xc4\xb1\xb1\xb1\xb1'UTF-8 解码： 入错行的北北GBK 解码： 入错行的北北'''

endswith(suffix, beg=0, end=len(string))

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

str.endswith(suffix[, start[, end]])

参数

suffix ： 一个字符串或者是一个元素

start ：字符串str中的开始位置

end ：字符串str中结束位置返回值

如果字符串含有指定的后缀返回 True，否则返回 False

代码示例：

Str='Hello!! world!!'suffix='!!'print (Str.endswith(suffix))print (Str.endswith(suffix,5,7))suffix='beibei'print (Str.endswith(suffix))print (Str.endswith(suffix, 0, 19))'''输出结果：TrueTrueFalseFalse'''

startswith(substr, beg=0,end=len(string))

检查字符串是否是以指定子字符串开头

str.startswith(substr, beg=0,end=len(string));

参数

str ： 检测的字符串

substr： 一个字符串或者是一个元素

beg：字符串str中的开始位置

end ：字符串str中结束位置返回值

如果检测到字符串则返回True，否则返回False

代码示例：

Str='!!Hello!! world!!'suffix='!!'print (Str.startswith(suffix))print (Str.startswith(suffix,7))suffix='beibei'print (Str.startswith(suffix))print (Str.startswith(suffix, 0, 19))'''输出结果：TrueTrueFalseFalse'''

expandtabs(tabsize=8)

把字符串中的 tab 符号 \t (默认8个空格)转为空格

在第 0、8、16…等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替

str.expandtabs(tabsize=8)

参数

tabsize ： 指定转换字符串中的 tab 符号 \t转为空格的字符数返回值

返回字符串中的 tab 符号 \t 转为空格后生成的新字符串

代码示例：

str = "Hello\tworld\t！！"print('原始字符串:', str)# 默认 8 个空格print('替换 \\t 符号:', str.expandtabs())# 2 个空格print('使用 2 个空格替换 \\t 符号:', str.expandtabs(2))# 3 个空格print('使用 3 个空格:', str.expandtabs(3))# 4 个空格print('使用 4 个空格:', str.expandtabs(4))# 5 个空格print('使用 5 个空格:', str.expandtabs(5))# 6 个空格print('使用 6 个空格:', str.expandtabs(6))'''输出结果：原始字符串: Helloworld！！替换 \t 符号: Hello world ！！使用 2 个空格替换 \t 符号: Hello world ！！使用 3 个空格: Hello world ！！使用 4 个空格: Hello world ！！使用 5 个空格: Helloworld！！使用 6 个空格: Hello world ！！'''

find(str, beg=0, end=len(string))

检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内

str.find(str, beg=0, end=len(string))

参数

str ： 指定检索的字符串

beg ： 开始索引，默认为0

end ： 结束索引，默认为字符串的长度返回值

如果包含子字符串返回开始出现的位置，否则返回-1

代码示例：

str1 = "Hello world!!!"str2 = "world";print(str1.find(str2))print(str1.find(str2, 5))print(str1.find(str2, 10))'''输出结果：66-1'''

rfind(str, beg=0,end=len(string))

类似于find()函数，不过从右边开始查找

str.rfind(str, beg=0 end=len(string))

参数

str ： 指定检索的字符串

beg ： 开始索引，默认为0

end ：结束索引，默认为字符串的长度返回值

返回字符串最后一次出现的位置，如果没有匹配项则返回-1

代码示例：

str1 = "~~ hello hello world!"str2 = "hello"print (str1.find(str2))#从左开始找第一个print (str1.rfind(str2)) #从右开始找第一个print (str1.find(str2, 0, 10))print (str1.rfind(str2, 0, 10))print (str1.find(str2, 10, 0))print (str1.rfind(str2, 10, 0))'''输出结果：3933-1-1'''

index(str, beg=0, end=len(string))

与find()方法大致一样，但是如果str不在字符串中会报异常

str.index(str, beg=0, end=len(string))

参数

str ： 指定检索的字符串

beg ： 开始索引，默认为0

end ：结束索引，默认为字符串的长度返回值

如果包含子字符串返回开始出现的位置，否则抛出异常

代码示例：

str1 = "Hello world!!!"str2 = "world";print(str1.index(str2))print(str1.index(str2, 5))print(str1.index(str2, 10))'''输出结果：Traceback (most recent call last):File "D:\PythonProject\HelloWorld\HelloWorld.py", line 6, in <module>print(str1.index(str2, 10))ValueError: substring not found66'''

rindex( str, beg=0, end=len(string))

类似于 index()，不过从右边开始

str.rindex(str, beg=0, end=len(string))

参数

str ： 指定检索的字符串

beg ： 开始索引，默认为0

end ：结束索引，默认为字符串的长度返回值

返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常

代码示例：

str1 = "hello hello world!!!"str2 = "hello";print(str1.rindex(str2))print(str1.rindex(str2, 5))'''输出结果：66'''

isalnum()

检测字符串是否由字母和数字组成

str.isalnum()

参数

无返回值

如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

代码示例：

str = "HelloWorld" # 字符串没有空格print(str.isalnum())str = "Hello World"print(str.isalnum())'''输出结果：TrueFalse'''

isalpha()

检测字符串是否只由字母或文字组成

str.isalpha()

参数

无返回值

如果字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False

代码示例：

str = "HelloWorld"print (str.isalpha())str = "入错行的北北"print (str.isalpha())str = "HelloWorld!"print (str.isalpha())str = "入错行的北北666"print (str.isalpha())'''输出结果：TrueTrueFalseFalse'''

isdigit()

检测字符串是否只由**数字（单纯的数字）**组成

str.isdigit()

参数

无返回值

如果字符串只包含数字则返回 True 否则返回 False

代码示例：

str = "123456";print (str.isdigit())str = "HelloWorld"print (str.isdigit())'''输出结果：TrueFalse'''

isnumeric()

检测字符串是否只由数字组成

数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字

str.isnumeric()

参数

无返回值

如果字符串中只包含数字字符，则返回 True，否则返回 False

代码示例：

str = "Hello World"print (str.isnumeric())str = "20 21"print (str.isnumeric())str = ""print (str.isnumeric())'''输出结果：FalseFalseTrue'''

islower()

检测字符串中的字母是否都是小写字母

str.islower()

参数

无返回值

如果字符串中的字母部分全是小写字母，则返回 True，否则返回 False

代码示例：

str = "Hello World！"print (str.islower())str = "hello world!"print (str.islower())str = "hello world!嘿嘿！"print (str.islower())'''输出结果：FalseTrueTrue'''

isupper()

检测字符串中的字母是否都是大写字母

str.isupper()

参数

无返回值

如果字符串中的字母部分全是大写字母，则返回 True，否则返回 False

代码示例：

str = "HELLO WORLD！"print (str.isupper())str = "HELLO WORLD！嘿嘿！"print (str.isupper())str = "hello world!"print (str.isupper())'''输出结果：TrueTrueFalse'''

isspace()

检测字符串是否只由空白字符组成

str.isspace()

参数

无返回值

如果字符串中只包含空格，则返回 True，否则返回 False

代码示例：

str = " "print(str.isspace())str = "Hello World!"print(str.isspace())'''输出结果：TrueFalse'''

title()

返回"标题化"的字符串，所有单词都是首字母大写、其余字母为小写

非字母后的第一个字母将转换为大写字母

str.title();

参数

无返回值

返回"标题化"的字符串，所有单词都是首字母大写、其余字母为小写

非字母后的第一个字母将转换为大写字母

代码示例：

str = "hello world!!"print (str.title())str = "bye 4g hello 5g"print (str.title())'''输出结果：Hello World!!Bye 4G Hello 5G'''

istitle()

检测字符串中所有的单词拼写是否为首字母大写、其余字母为小写

str.istitle()

参数

无返回值

如果字符串中所有的单词拼写首字母为大写、字母为小写则返回 True，否则返回 False

代码示例：

str = "Hello World!"print(str.istitle())str = "Hello world!"print(str.istitle())'''输出结果：TrueFalse'''

join(seq)

用于将序列中的元素以指定的字符连接生成一个新的字符串

str.join(sequence)

参数

sequence ： 要连接的元素序列返回值

返回通过指定字符连接序列中元素后生成的新字符串

代码示例：

s1 = "-"s2 = ""seq = ("h", "e", "l", "l", "o") # 字符串序列print (s1.join( seq ))print (s2.join( seq ))'''输出结果：h-e-l-l-ohello'''

len(s)

返回对象（字符、列表、元组等）长度或项目个数

len( s )

参数

s ：对象返回值

返回对象长度

代码示例：

l = [1,2,3,4,5]print(len(l))s = "Hello World！"print(len(s))'''输出结果：512'''

lower()

字符串中所有大写字符转换为小写

str.lower()

参数

无返回值

返回将字符串中所有大写字符转换为小写后生成的字符串

代码示例：

str = "HELLO WORLD!"print( str.lower() )'''输出结果：hello world!'''

upper()

字符串中的小写字母转换为大写

str.upper()

参数

无返回值

返回小写字母转为大写字母的字符串

代码示例：

str = "hello world!!!";print ("str.upper() : ", str.upper())'''输出结果：str.upper() : HELLO WORLD!!!'''

swapcase()

将字符串中大写转换为小写，小写转换为大写

str.swapcase();

参数

无返回值

返回大小写字母转换后生成的新字符串

代码示例：

str = "Hello World!!"print (str.swapcase())'''输出结果：hELLO wORLD!!'''

lstrip()

删除字符串左边的空格或指定字符

str.lstrip([chars])

参数

chars : 指定字符返回值

返回删除字符串左边的空格或指定字符后生成的新字符串

代码示例：

str = "Hello World!!!";print(str.lstrip());str = "88888888Hello World!!!8888888";print( str.lstrip('8') );'''输出结果：Hello World!!!Hello World!!!8888888'''

rstrip()

删除字符串末尾的空格或指定字符

str.rstrip([chars])

参数

chars ： 指定删除的字符（默认为空格）返回值

返回删除 string 字符串末尾的指定字符后生成的新字符串

代码示例：

str = "Hello World!!!";print(str.rstrip());str = "88888888Hello World!!!8888888";print( str.rstrip('8') );'''输出结果：Hello World!!!88888888Hello World!!!'''

strip([chars])

在字符串上执行 lstrip()和 rstrip()

该方法只能删除开头或是结尾的字符，不能删除中间部分的字符

str.strip([chars]);

参数

chars ： 移除字符串头尾指定的字符序列返回值

返回移除字符串头尾指定的字符序列生成的新字符串

代码示例：

str = "Hello World!!!";print(str.strip());str = "88888888Hello World!!!8888888";print( str.strip('8') );str = "12345678Hello World!!!87654321";print( str.strip('1234567') );'''输出结果：Hello World!!!Hello World!!!8Hello World!!!8'''

maketrans()

创建字符映射的转换表

对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标

两个字符串的长度必须相同，为一一对应的关系

tips：注：Python3.4 已经没有 string.maketrans() ，取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans() 。

str.maketrans(intab, outtab)

参数

intab ： 字符串中要替代的字符组成的字符串

outtab ：相应的映射字符的字符串返回值

返回字符串转换后生成的新字符串

代码示例：

intab = "elord"outtab = "12345"trantab = str.maketrans(intab, outtab)str = "Hello World!!!"print (str.translate(trantab))'''输出结果：H1223 W3425!!!'''

translate(table, deletechars="")

根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中

str.translate(table)

bytes.translate(table[, delete])

bytearray.translate(table[, delete])

参数

table ： 翻译表，通过 maketrans() 方法转换而来

deletechars ： 字符串中要过滤的字符列表返回值

返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射

代码示例：

intab = "helow"outtab = "12345"trantab = str.maketrans(intab, outtab) # 制作翻译表str = "hello world!!!"print(str.translate(trantab))'''输出结果：12334 54r3d!!!'''

max(str)

返回字符串 str 中最大的字母

max(str)

参数

str : 字符串返回值

返回字符串中最大的字母

代码示例：

str = "Hello World!!!"print ("最大字符: " + max(str))'''输出结果：最大字符: r'''

min(str)

返回字符串 str 中最小的字母

min(str)

参数

str : 字符串返回值

返回字符串 str 中最小的字母

代码示例：

str = "abcdefg"print ("最小字符: " + min(str))'''输出结果：最小字符: a'''

replace(old, new [, max])

把 将字符串中的 old 替换成 new

如果 max 指定，则替换不超过 max 次

str.replace(old, new[, max])

参数

old ： 将被替换的子字符串

new ： 新字符串，用于替换old子字符串

max ： 替换不超过 max 次返回值

返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次

代码示例：

str = "1年了"print("错误码龄：", str)print("正确码龄：", str.replace("1年", "2年"))str = "hello hello world!"print(str.replace("hello", "bye", 2))str = "hello hello world!"print(str.replace("hello", "bye", 1))str = "hello hello world!"print(str.replace("hello", "bye", 0))'''输出结果：错误码龄： 1年了正确码龄： 2年了bye bye world!bye hello world!hello hello world!'''

split(str="", num=string.count(str))

以 str 为分隔符分割字符串，如果 num 有指定值，则仅分割 num+1 个子字符串

str.split(str="", num=string.count(str))

参数

str ： 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等

num ： 分割次数（默认为 -1, 即分隔所有）返回值

返回分割后的字符串列表

代码示例：

str = "hello hello world!"print (str.split( )) # 以空格为分隔符print (str.split(' ',1)) # 以 " " 为分隔符print (str.split(' ',0)) # 以 " " 为分隔符print (str.split('w'))# 以 w 为分隔符'''输出结果：['hello', 'hello', 'world!']['hello', 'hello world!']['hello hello world!']['hello hello ', 'orld!']'''

splitlines([keepends])

按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表

如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符

str.splitlines([keepends])

参数

keepends ： 在输出结果里是否去掉换行符(’\r’, ‘\r\n’, \n’)，默认为 False，不包含换行符，如果为 True，则保留换行符返回值

返回一个包含各行作为元素的列表

代码示例：

str = 'ab c\n\nde fg\rkl\r\n'print (str.splitlines()) # 输出结果里去掉换行符('\r', '\r\n', \n')print (str.splitlines(True)) # 输出结果里包含换行符('\r', '\r\n', \n')'''输出结果：['ab c', '', 'de fg', 'kl']['ab c\n', '\n', 'de fg\r', 'kl\r\n']'''

isdecimal()

检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false

注意:定义一个十进制字符串，只需要在字符串前添加 ‘u’ 前缀即可

str.isdecimal()

参数

无返回值

如果字符串是否只包含十进制字符返回True，否则返回False

代码示例：

str = "hello "print (str.isdecimal())str = " "print (str.isdecimal())str = ""print (str.isdecimal())'''输出结果：FalseFalseTrue'''