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
圖示：
