Python3字符串方法

Python字符串方法图示：

1、index()　　重点

定义：查找并返回指定str的索引位置，如果没找到则会抛异常（查找的顺序是从左至右）可以指定范围：开始位置和结束位置进行查找。

格式：“字符串内容”.index('指定的字符串',指定范围)

例1：不指定范围默认是从左至右的顺序查询指定字符串“i”的索引位置

s = 'dark knight'
s1 = s.index('i')
print(s1)

输出结果：

7

图示：

例2：查找一串字符串时，返回这个被查找字符串的首个字符的索引位置

s = 'dark knight'
s1 = s.index('knight')
# 查找一串字符串时，返回这个被查找字符串的首个字符的索引位置
print(s1)

输出结果：

5

图示：

例3：查找并返回指定范围字符“k”的索引位置，查找方向以从左至右的顺序查找，且指定的范围顾首不顾尾

s = 'dark knight'
s1 = s.index('k',4,10)
# 表示从索引4到9的位置进行查找，顾首不顾尾
# 如果有多个“k”字符串时则返回第一个“k”的索引位置
print(s1)

输出结果：

5

图示：

例4：若未找到字符串则会抛出异常

s = 'dark knight'
s1 = s.index('x')  # 若未找到字符串则会抛出异常
print(s1)

输出结果：

ValueError: substring not found

图示：

2、rindex()

定义：查找并返回指定str的索引位置，如果没找到则会抛异常（查找的顺序是从右至左）可以指定范围：开始位置和结束位置进行查找

格式："字符串内容".rindex('指定的字符串'，指定范围)

例1：不指定范围默认是从右至左的顺序查询指定字符串的索引位置

s = 'dark knight'
s1 = s.rindex('k')
# 不指定范围默认是从右至左的顺序查询指定字符串的索引位置
print(s1)　

输出结果：

5

图示：

例2：若未找到字符串则会抛出异常

s = 'dark knight'
s1 = s.rindex('x') # 若未找到字符串则会抛出异常
print(s1)

输出结果：

ValueError: substring not found

图示：

例3：查找并返回指定范围字符“k”的索引位置，查找方向在从右至左的顺序查找，且指定的范围顾首不顾尾

s = 'dark knight'
s1 = s.rindex('k',2,11)
# 表示从索引位置2到10的位置进行查找，顾首不顾尾
# 如果有多个“k”字符串时则返回第一个“k”的索引位置
print(s1)

输出结果：

5

图示：

3、find()　　重点

定义：查找并返回指定str的索引位置，如果没找到则返回：-1（查找的顺序是从左至右）可以指定范围：开始位置和结束位置进行查找

格式："字符串内容".find('指定的字符串'，指定范围)

例1：不指定范围默认是从左至右的顺序查询指定字符串“i”的索引位置

s = 'dark knight'
s1 = s.find('i')
print(s1)

输出结果：

7

图示：

例2：查找一串字符串时，返回这个被查找字符串的首个字符的索引位置

s = 'dark knight'
s1 = s.find('dark')
# 查找一串字符串时，返回这个被查找字符串的首个字符的索引位置
print(s1)

输出结果：

0

图示：

例3：查找并返回指定范围字符“k”的索引位置，查找方向以从左至右的顺序查找，且指定的范围顾首不顾尾

s = 'dark knight'
s1 = s.find('k',3,13)
# 查找并返回指定范围3到12之间的字符“k”的索引位置，从左至右的顺序查找，且指定的范围顾首不顾尾
# 如果有多个“k”字符串时则返回第一个“k”的索引位置
print(s1)

输出结果：

3

图示：

例4：若未找到字符串则返回-1

s = 'dark knight'
s1 = s.find('x') # 没有找到字符串"x"时返回：-1
print(s1)

输出结果：

-1

图示：

4、rfind()

定义：查找并返回指定str的索引位置，如果没找到则返回：-1（查找的顺序是从右至左）可以指定范围：开始位置和结束位置进行查找

格式："字符串内容".rfind('指定的字符串'，指定范围)

例1：不指定范围默认是从右至左的顺序查询指定字符串的索引位置

s = 'dark knight'
s1 = s.rfind('k') # 从右至左的顺序查找并返回字符串'k'的索引位置
print(s1)　　

输出结果：

5

图示：

例2：查找并返回指定范围字符“k”的索引位置，查找方向在从右至左的顺序查找，且指定的范围顾首不顾尾

s = 'dark knight'
s1 = s.rfind('k',3,13)
# 查找并返回指定范围3到12之间的字符“k”的索引位置，从右至左的顺序查找，且指定的范围顾首不顾尾
# 如果有多个“k”字符串时则返回第一个“k”的索引位置
print(s1)

输出结果：

5

图示：

例3：若未找到字符串则返回-1

s = 'dark knight'
s1 = s.rfind('x')
print(s1)

输出结果：

-1

图示：

5、count()　　重点

定义：统计指定的str在字符串中出现的次数并返回这个数若没找到返回：0，可以指定范围：开始位置和结束位置进行统计

格式："字符串内容".count('指定的字符串'，指定范围)

例1：统计指定字符串“k”在字符串中出现的次数并返回这个数

s = 'dark knight'
s1 = s.count('k') # 得到字符串“k”的个数
print(s1)

输出结果：

2

图示：

例2：统计指定范围内的字符串“k”的个数，且顾首不顾尾

s = 'dark knight'
s1 = s.count('k',5,13) # 统计5到12之间的字符串“k”的个数，顾首不顾尾
print(s1)

输出结果：

1

图示：

6、strip()　　重点

定义：移除字符串左右两侧指定的字符，并返回移除指定字符串后的字符串，括号内不指定字符串默认移除空格。

格式："字符串内容".strip(‘指定字符串’)

例1：移除字符串左右两侧的空格

s = '      dark knight    '
s1 = s.strip() # 移除字符串左右两侧的空格
print(s1)

输出结果：

dark knight

图示：

例2：移除字符串左右两侧的指定字符串

s = '****dark knight**************'
s1 = s.strip('*') # 移除字符串左右两侧的字符串“*”
print(s1)

输出结果：

dark knight

图示：

7、lstrtip()

定义：移除字符串左侧指定的字符，并返回移除指定字符串后的字符串，括号内不指定字符串默认移除空格。

格式：“字符串内容”.lstrip（“指定字符串”）

例1：移除字符串左侧的空格

s = '      dark knight          '
s1 = s.lstrip() # 去除字符串左侧的空格
print(s1,'<—右侧空格并未去除')

输出结果：

dark knight           查看右侧的空格是去除

图示：

例2：移除字符串左侧的指定字符串

s = '*****dark knight************'
s1 = s.lstrip('*') # 去除字符串左侧的字符串“*”
print(s1)

输出结果：

dark knight************

图示：

8、rstrip()

定义：移除字符串右侧指定的字符，并返回移除指定字符串后的字符串，括号内不指定字符串默认移除空格。

格式：“字符串内容”.rstrip（“指定字符串”）

例1：移除字符串右侧的空格

s = '       dark knight             '
s1 = s.rstrip() # 去除字符串右侧的空格
print(s1)

输出结果：

左侧的空格未去除—>        dark knight

图示：

例2：移除字符串右侧的指定字符串

s = '*****dark knight************'
s1 = s.rstrip('*') # 去除字符串右侧的字符串“*”
print(s1)

输出结果：

*****dark knight

图示：

9、split()　　重点

定义：通过指定分隔符按从左到右的顺序对字符串进行切片，并以一个列表的形式返回。括号内不指定字符串表示默认以空格为分隔符。可以指定分隔符的个数

格式：“字符串内容”.split（“指定分隔符”）

例1：以空格为分隔符进行切片操作

s = 'dark knight'
s1 = s.split() # 以空格作为分隔符进行切片
print(s1)

输出结果：

['dark', 'knight']

图示：

例2：以指定字符作为分隔符进行切片操作

s = 'dark knight'
s1 = s.split('k') # 以字符“k”作为分隔符进行切片
print(s1)

输出结果：

['dar', ' ', 'night']

图示：

例3： 以指定字符作为分隔符进行切片操作且限定分隔符的个数

s = 'dark knight'
s1 = s.split('k',1)
# 以字符“k”作为分隔符进行切片，
# 且只限定1个"k"作为分隔符，字符串中如果有多个“k”则按从左至右的顺序来选定这个分隔符
print(s1)

输出结果：

['dar', ' knight']

图示：

10、rsplit()

定义：通过指定分隔符按从右到左的顺序对字符串进行切片，并以一个列表的形式返回。括号内不指定字符串表示默认以空格为分隔符。可以指定分隔符的个数

格式：“字符串内容”.rsplit（“指定分隔符”）

例1：以空格作为分隔符进行切片

s = 'dark knight'
s1 = s.rsplit() # 以空格作为分隔符进行切片
print(s1)

输出结果：

['dark', 'knight']

图示：

例2：以指定字符作为分隔符进行切片操作

s = 'dark knight'
s1 = s.rsplit('k') # 以字符“k”作为分隔符进行切片
print(s1)

输出结果：

['dar', ' ', 'night']

图示：

例3： 以指定字符作为分隔符进行切片操作且限定分隔符的个数（这里就体现与split的区别了）

s = 'dark knight'
s1 = s.rsplit('k',1)
# 以字符“k”作为分隔符进行切片，
# 且只限定1个"k"作为分隔符，字符串中如果有多个“k”则按从右至左的顺序来选定这个分隔符
print(s1)

输出结果：

['dark ', 'night']

图示：

11、splitlines()

定义：括号中不加参数默认为False，此时分隔符默认指定为“\n” 、“\n\r” 、“\r”对字符串进行分隔，以一个列表的形式返回；当括号中参数改为True时仍然会以“\n” 、“\n\r” 、“\r”进行分隔，但是在生成的元素中会保留分隔符。并以一个列表的形式返回。

格式：“字符串内容”.splitlines（True/False）

例1：括号中不加参数时默认为False，分隔符“\n”、“\r\n”、“\r”在生成元素时不会被保留

s = '\ndar\rk kni\r\nght\r'
s1 = s.splitlines() # 括号中不加参数默认为False，且以“\n”、"\n\r"、"\r"为分隔符
print(s1)

输出结果：

['', 'dar', 'k kni', '', 'ght']

图示：

例2：括号中为True时的操作，分隔符“\n”、“\r\n”、“\r”在生成元素时会被保留

s = '\ndar\rk kni\r\nght\r'
s1 = s.splitlines(True) # 括号中为True时，分隔符“\n”、“\r\n”、“\r”在生成元素时会被保留
print(s1)

输出结果：

['\n', 'dar\r', 'k kni\r\n', 'ght\r']

图示：

12、replace()　　重点

定义：将指定的字符串替换成新的字符串，并返回替换后的字符串。可以指定替换的次数，若不指定次数则默认替换全部。

格式：“字符串内容”.replace（“要替换的内容”，“新的内容”,指定的替换的次数）

例1：替换全部的指定的内容。

s = 'dark knight dark sky'
s1 = s.replace('dark','暗黑')
print(s1)

输出结果：

暗黑 knight 暗黑 sky

图示：

例2：指定替换的次数，按从左到右的顺序进行替换

s = 'dark knight dark sky'
s1 = s.replace('dark','暗黑',1)
print(s1)

输出结果：

暗黑 knight dark sky

图示：

例3：当要替换的内容不存在时也不会报错，直接返回字符串的原内容

s = 'dark knight dark sky'
s1 = s.replace('x','暗黑') # 要替换的内容不存在时，直接返回字符串的原内容
print(s1)

输出结果：

dark knight dark sky

图示：

13、join()　　重点

定义：将序列中的元素以指定的字符拼接生成一个新的字符串，并返回这个字符串

格式：“指定字符串内容”.join（一个序列）

例1：将序列中的元素以空字符串拼接一个成一个新的字符串

s = ''
t = ('k','n','i','g','h','t')
s1 = s.join(t) # 将序列中的元素以空字符串拼接一个成一个新的字符串
print(s1)

输出结果：

knight

图示：

例2：将序列中的元素以“-”字符串拼接一个成一个新的字符串

s = '-'
t = ('k','n','i','g','h','t')
s1 = s.join(t) # 将序列中的元素以“-”字符串拼接一个成一个新的字符串
print(s1)

输出结果：

k-n-i-g-h-t

图示：

14、format()　　重点

定义：字符串格式化。有三种方法：1、按默认从左到右的默认顺序传值，2、按指定位置传值，3、按设置参数传值，返回格式化后的字符串

格式1：“字符串-｛｝-字符串-｛｝”.format(“内容1”，“内容2”)

　　　#  输出的结果为：字符串-内容1-字符串-内容2

　　　#  格式化后的内容分别按从左到右的默认顺序分别对应到字符串中每个大括号里

格式2：“字符串-｛2｝-字符串-｛1｝”.format(“内容1”，“内容2”)

　　　#  输出的结果为：字符串-内容2-字符串-内容1

　　　#  格式化后的内容分别按指定位置传值到字符串中对应的大括号里

格式3：“字符串-｛变量名1｝-字符串-｛变量名2｝”.format(变量名1 = “内容 ”，变量名2 = “内容2”)

　　    #  输出的结果为：字符串-内容1-字符串-内容12

　　　#  格式化后的内容分别按指定位置传值到字符串中对应的大括号里

例1：按默认顺序对字符串进行格式化

s = "I am dark {},I'm {} years old!"
s1 = s.format('knight','28')
print(s1)

输出结果：

I am dark knight,I'm 28 years old!

图示：

例2：按位置对字符串进行格式化

s = "I am dark {1},I'm {0} years old!"
s1 = s.format('28','knight')
print(s1)

输出结果：

I am dark knight,I'm 28 years old!

图示：

例3：按位置对字符串进行格式化

s = "I am dark {name},I'm {age} years old!"
s1 = s.format(age = '28',name = 'knight')
print(s1)

输出结果：

I am dark knight,I'm 28 years old!

图示：

15、format_map()

定义：字符串格式化，与format不同的是括号中的mapping是一个字典对象，返回格式化后的字符串。

格式：“字符串-｛key1｝-字符串-｛key2｝”.format_map（｛key1 ： “value1 ”，key2 ： “value2”｝）

　　   #  输出的结果为：字符串-value1-字符串-value2

例：字符串的格式，传入一个字典对象

people = {'name':'dark_knight','age':28}
s = 'My name is {name},I am {age} years old'
s1 = s.format_map(people)
print(s1)

输出结果：

My name is dark_knight,I am 28 years old

图示：

16、encode()　　重点

定义：以指定的编码格式对字符串进行编码，并返回编码后的二进制

格式：“字符串内容”.encode（“指定的字符编码”）

例：以utf-8的方式进行编码并解码。

s = '暗黑骑士'
s1 = s.encode('utf-8')
print(s1)  # 得到以"utf-8"编码后的二进制数
s2 = s1.decode('utf-8')
print(s2)  # 用decode解码，以什么编码就要以什么解码，否则乱码

输出结果：

b'\xe6\x9a\x97\xe9\xbb\x91\xe9\xaa\x91\xe5\xa3\xab'
暗黑骑士

图示：

17、startswith()　　重点

定义：判断字符串是否是以指定字符串开头并返回布尔值，并可以指定范围。

格式：“字符串内容”.startswith（“指定字符串”，指定范围）

例1：判断字符串是否以指定字符串开头

s = 'dark knight'
s1 = s.startswith('dark')
print(s1)

输出结果：

True

图示：

例2：判断字符串是否以指定字符串开头，并指定范围

s = 'dark knight'
s1 = s.startswith('k',5)
print(s1)

输出结果：

True

图示：

例3：判断字符串是否以指定字符串开头

s = 'dark knight'
s1 = s.startswith('haha') # 在原字符串中没找到以指定内容开头的内容则返回False
print(s1)

输出结果：

False

图示：

18、endswith()　　重点

定义：判断字符串是否是以指定字符串结尾并返回布尔值，并可以指定范围。

格式：“字符串内容”.endswith（“指定字符串”，指定范围）

例1：判断字符串是否以指定字符串结尾

s = 'dark knight'
s1 = s.endswith('knight')
print(s1)

输出结果：

True

图示：

例2：判断字符串是否以指定字符串开头

s = 'dark knight'
s1 = s.endswith('x')
print(s1)

输出结果：

False

图示：

19、upper()　　重点

定义：将字符串中的小写字母转换成大写字母，并返回转换成大写字母后的字符串

格式："小写字母的字符串".upper（）

例：将小写字母的字符串转换成大写字母。

s = 'dark knight'
s1 = s.upper()
print(s1)

输出结果：

DARK KNIGHT

图示：

20、lower()　　重点

定义：将字符串中的大写字母转换成小写字母，并返回转换成小写字母后的字符串。

格式："大写字母的字符串".lower（）

例：将字符串中的大写字母转换成小写字母

s = 'Dark Knight'
s1 = s.lower()
print(s1)　

输出结果：

dark knight

图示：

21、title()　　重点

定义：将字符串中的所有单词的首字母的替换成大写字母，并返回转换后的字符串

格式：“字符串”.title()

例：将字符串中的所有单词的首字母替换成大写字母

s = 'my name is dark knight'
s1 = s.title()
print(s1)

输出结果：

My Name Is Dark Knight

图示：

22、swapcase()　　重点

定义：将字符串的大小写字母进行转换，并返回转换后的字符串

格式：“字符串”.swapcase()

例：将字符串的大小写字母进行转换

s = 'Dark Knight'
s1 = s.swapcase()
print(s1)

输出结果：

dARK kNIGHT

图示：

23、ljust()

定义：返回一个左对齐的字符串，并使用指定长度的填充符号，不指定填充符号默认使用空格作为填充符号。若指定的填充符号的长度小于字符串本身的长度，填充符号则不会显示。

格式：“字符串”.ljust（填充的长度，“指定填充符号”）

例1：返回一个以空格为填充的左对齐的字符串。

s = 'dark knight'
s1 = s.ljust(30)
print(s1,'<-结束')

输出结果：

dark knight                    <-结束

图示：

例2：返回一个以指定字符串作为填充的左对齐的字符串。

s = 'dark knight'
s1 = s.ljust(30,'*')
print(s1)

输出结果：

dark knight*******************

图示：

例3：指定的填充符号的长度小于字符串本身的长度，填充符号则不会显示

s = 'dark knight'
s1 = s.ljust(10,'*') # 指定填充符号的长度小于字符串的长度，则不会显示填充符号
print(s1,'<-结束')

输出结果：

dark knight <-结束

图示：

24、rjust()

定义：返回一个右对齐的字符串，并使用指定长度的填充符号，不指定填充符号默认使用空格作为填充符号。若指定的填充符号的长度小于字符串本身的长度，填充符号则不会显示。

格式：“字符串”.rjust（填充的长度，“指定填充符号”）

例1：返回一个以空格为填充的右对齐的字符串

s = 'dark knight'
s1 = s.rjust(30)
print('开始->',s1)

输出结果：

开始->                    dark knight

图示：

例2：返回一个以指定字符串作为填充的右对齐的字符串。

s = 'dark knight'
s1 = s.rjust(30,'*')
print(s1)

输出结果：

*******************dark knight

图示：

例3：指定的填充符号的长度小于字符串本身的长度，填充符号则不会显示

s = 'dark knight'
s1 = s.rjust(10,'*') # 指定填充符号的长度小于字符串的长度，则不会显示填充符号
print('开始->',s1)

输出结果：

开始-> dark knight

图示：

25、center()　　重点

定义：返回一个居中对齐的字符串，并使用指定长度的填充符号，不指定填充符号默认使用空格作为填充符号。若指定的填充符号的长度小于字符串本身的长度，填充符号则不会显示。

格式：“字符串”.center（填充的长度，“指定填充符号”）

例1：返回一个以空格为填充的居中对齐的字符串

s = 'dark knight'
s1 = s.center(30)
print('开始->',s1,'<-结束')

输出结果：

开始->          dark knight           <-结束

图示：

例2：返回一个以指定字符串作为填充的居中对齐的字符串。

s = 'dark knight'
s1 = s.center(30,'*')
print('开始->',s1,'<-结束')

输出结果：

开始-> *********dark knight********** <-结束

图示：

例3：指定的填充符号的长度小于字符串本身的长度，填充符号则不会显示

s = 'dark knight'
s1 = s.center(10,'*') # 指定填充符号的长度小于字符串的长度，则不会显示填充符号
print('开始->',s1,'<-结束')

输出结果：

开始-> dark knight <-结束

图示：

26、capitalize()　　重点

定义：返回一个将字符串首字母大写、字符串中的其它字母变为小写的字符串

格式：“字符串”.capitalize()

例：返回一个将字符串首字母大写、字符串中的其它字母变为小写的字符串

s = 'dARk kNigHt'
s1 = s.capitalize()
print(s1)

输出结果：

Dark knight

图示：

27、partition()

定义：按从左到右的顺序，对字符串进行分割，返回一个包含3个元素的元组，这个元组中这3个元素分别为：指定分割符，以及以这个分隔符为中心的左右两侧的字符串。

格式：“字符串”.partition（"指定分隔符"）

例1：对字符串进行分割，返回一个包含3个元素的元组，按从左到右的顺序分割

s = 'dark knight'
s1 = s.partition('k')
print(s1)

输出结果：

('dar', 'k', ' knight')

图示：

例2：若在字符串中未找到指定的分隔符则返回一个包含3个元素的元组，这个元组元素包含字符串本身，以及两个空字符串

s = 'dark knight'
s1 = s.partition('x') # 指定一个不存在的字符串
print(s1)

输出结果：

('dark knight', '', '')

图示：

28、rpartition()

定义：按从右到左的顺序，对字符串进行分割，返回一个包含3个元素的元组，这个元组中这3个元素分别为：指定分割符，以及以这个分隔符为中心的左右两侧的字符串。

格式：“字符串”.rpartition（"指定分隔符"）

例1：对字符串进行分割，返回一个包含3个元素的元组，按从右到左的顺序分割

s = 'dark knight'
s1 = s.rpartition('k')
print(s1)

输出结果：

('dark ', 'k', 'night')

图示：

例2：若在字符串中未找到指定的分隔符则返回一个包含3个元素的元组，这个元组元素包含两个空字符串，以及字符串本身

s = 'dark knight'
s1 = s.rpartition('x') # 指定一个不存在的字符串
print(s1)

输出结果：

('', '', 'dark knight')

图示：

29、translate()

定义：根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。返回这替换后的字符串

格式：“原字符串”.translate（｛映射表｝）

例1：通过映射表替换s2字符串中的指定字符

s1 = 'abcde'  # 原字符串中要替换的字符
num = '12345' # 相应的映射字符的字符串。
s2 = "aaxxbbxxccxxddxxee" # 原字符串

form = s2.maketrans(s1,num) # 创建映射表，让s1字符串中的字母分别对应num中的字母并指向s2字符串。
print(s2.translate(form)) # 使用上面映射表进行翻译，并把并把deletechars中有的字符删掉。

输出结果：

11xx22xx33xx44xx55

图示：

30、zfill()　　重点

定义：按指定长度在字符串的左侧填充"0"补齐，并返回这个补齐“0”后的字符串

格式：“字符串”.zfill（指定长度）

例1：按指定长度在字符串的左侧填充"0"补齐

s = 'dark knight'
s1 = s.zfill(20)
print(s1)

输出结果：

000000000dark knight

图示：

例2：按指定长度在字符串的左侧填充"0"补齐，当填充“0”的个数小于字符串长度时，则不会显示。

s = 'dark knight'
s1 = s.zfill(10) # 填充的“0”的个数小于字符串的长度
print(s1)

输出结果：

dark knight

图示：

31、maketrans()

定义：用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。返回一个一一对应的字典

格式：“原字符串”.maketrans（"原字符串中要替换的字符"，“相应的映射字符的字符串”）

例：创建字符映射的转换表，并进行翻译

s1 = 'abcde'  # 原字符串中要替换的字符
num = '12345' # 相应的映射字符的字符串。
s2 = "aaxxbbxxccxxddxxee" # 原字符串

form = s2.maketrans(s1,num) # 创建映射表，让s1字符串中的字母分别对应num中的字母并指向s2字符串。
print(form)   # 查看这个映射表
print(s2.translate(form)) # 使用上面映射表进行翻译，并把并把deletechars中有的字符删掉。

输出结果：

{97: 49, 98: 50, 99: 51, 100: 52, 101: 53}
11xx22xx33xx44xx55

图示：

32、expandtabs()

定义：expandtabs() 方法把字符串中的“\t”转为空格，并返回替换空格后的字符串。（\t默认的空格数是 8）。

格式：“字符串中的 \t ”.expandtabs(空格数)

例1：将字符串中的“\t”替换成20个空格数

s = 'dark\tknight'
s1 = s.expandtabs(20)
print(s1)

输出结果：

dark                knight

图示：

例2：括号中不加参数默认是8个空格

s = 'dark\tknight'
s1 = s.expandtabs()
print(s1)

输出结果：

dark    knight

图示：

33、isdigit()　　重点

定义：判断字符串是否只由数字组成，并返回一个布尔值。

格式：“字符串”.isdigit（）

例1：判断字符串是否只由数字组成

s = 'dark knight'
s1 = s.isdigit()
print(s1)

输出结果：

False

图示：

例2：判断字符串是否只由数字组成

s = '88888'
s1 = s.isdigit()
print(s1)

输出结果：

True

图示：

34、isalpha()　　重点

定义：判断字符串是否只由字母组成，并返回一个布尔值。

格式：“字符串”.isalpha（）

例1：判断字符串是否只由字母组成

s = 'dark knight'
s1 = s.isalpha()
print(s1) # 因为原字符串中有空格，所以返回False

输出结果：

False

图示：

例2：判断字符串是否只由字母组成

s = 'darkknight'
s1 = s.isalpha()
print(s1)

输出结果：

True

图示：

35、isalnum()　　重点

定义：判断字符串是否只由字母或数字组成，并返回一个布尔值。

格式：“字符串”.isalnum()

例1：判断字符串是否只由字母或数字组成。

s = 'darkknight888'
s1 = s.isalnum()
print(s1)

输出结果：

True

图示：

例2：判断字符串是否只由字母或数字组成。

s = 'dark knight!@#'
s1 = s.isalnum()
print(s1)

输出结果：

False

图示：

36、isupper()　　重点

定义：判断字符串中所有的字母是否为大写。并返回一个布尔值。

格式：“字符串”.isupper（）

例1：判断字符串中所有的字母是否为大写

s = 'DARK KNIGHT!@#'
s1 = s.isupper()
print(s1)

输出结果：

True

图示：

例2：判断字符串中所有的字母是否为大写

s = 'dark KNIGHT!@#'
s1 = s.isupper()
print(s1)

输出结果：

False

图示：

37、islower()　　重点

定义：判断字符串中所有的字母是否为小写。并返回一个布尔值。

格式：“字符串”.islower（）

例1：判断字符串中所有的字母是否为小写

s = 'dark knight!@#'
s1 = s.islower()
print(s1)

输出结果：

True

图示：

例2：判断字符串中所有的字母是否为小写

s = 'DARK knight!@#'
s1 = s.islower()
print(s1)

输出结果：

False

图示：

38、isspace()　　重点

定义：判断字符串是否只由空白字符组成，并返回一个布尔值

格式：“字符串”.isspace（）

例1：判断字符串是否只由空白字符组成

s = 'dark knight'
s1 = s.isspace()
print(s1)

输出结果：

False

图示：

例2：判断字符串是否只由空白字符组成

s = '        '
s1 = s.isspace()
print(s1)

输出结果：

True

图示：

39、istitle()　　重点

定义：判断字符串中所有的单词的首字母是否为大写且其他字母为小写。并返回一个布尔值。

格式：“字符串”.istitle（）

例1：判断字符串中所有的单词的首字母是否为大写且其他字母为小写

s = 'Dark Knight!@#$ 888'
s1 = s.istitle()
print(s1)

输出结果：

True

图示：

例2：判断字符串中所有的单词的首字母是否为大写且其他字母为小写

s = 'Dark KNIGHT!@#$ 888'
s1 = s.istitle()
print(s1)

输出结果：

False

图示：

40、isdecimal()

定义：判断字符串是否只包含十进制字符。这种方法只存在于unicode对象。并返回一个布尔值。（注意：定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可）

格式：“字符串”.isdecimal（）

例1：判断字符串是否只包含十进制字符

s = '8888888888'
s1 = s.isdecimal()
print(s1)

输出结果：

True

图示：

例2：判断字符串是否只包含十进制字符

s = 'dark knight'
s1 = s.isdecimal()
print(s1)

输出结果：

False

图示：

41、isnumeric()

定义：判断字符串是否只由数字组成。只针对unicode对象。并返回一个布尔值。

格式：“字符串”.isnumeric（）

例1：判断字符串是否只由数字组成。

s = '8888888888'
s1 = s.isnumeric()
print(s1)

输出结果：

True

图示：

42、isprintable()

定义：判断字符串中的所有字符都是否为可打印的（或字符串为空）的则返回True，否则返回False

　　    （可打印字符：ASCII码中，第0～32号及第127号是控制字符；第33～126号是可打印字符，其中第48～57号为0～9十个阿拉伯数字；65～90号为26个大写英文字母，97～122号为26个小写英文字母，其余的是一些标点符号、运算符号等）

格式：“字符串”.isprintable（）

例1：判断字符串中的所有字符都是否为可打印的

s = '\t\n'
s1 = s.isprintable()
print(s1)

输出结果：

False

图示：

例2：判断字符串中的所有字符都是否为可打印的

s = 'dark knight'
s1 = s.isprintable()
print(s1)

输出结果：

True

图示：

例3：判断字符串中的所有字符都是否为可打印的

s = '暗黑骑士'
s1 = s.isprintable()
print(s1)

输出结果：

False

图示：

43、isidentifier()

定义：判断是否是合法标识符，实际上是判断变量名是否合法，并返回一个布尔值

格式：“字符串”.isidentifier（）

例1：判断是否是合法标识符

s = '暗黑骑士'
s1 = s.isidentifier()
print(s1)

输出结果：

True

图示：

例2：判断是否是合法标识符

s = '\t\n'
s1 = s.isidentifier()
print(s1)

输出结果：

False

图示：

例3：判断是否是合法标识符

s = ' '
s1 = s.isidentifier()
print(s1)

输出结果：

False

图示：