前一章介紹了python中的集中基本數據類型，本章 著重 記錄python中str字符串類型數據的應用。str字符串主要由兩種方法，一種是方法，一種是魔術方法。由于內容實在過于多，本章只介紹其中的方法。我會按照pycharm給的內置方法順序（即字母排列順序） 全部 依次介紹各種方法的使用。
print(dir(str))
"""
'__add__', '__class__', '__contains__', '__delattr__',
'__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__getnewargs__',
'__gt__', '__hash__', '__init__', '__init_subclass__',
'__iter__', '__le__', '__len__', '__lt__', '__mod__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', 'capitalize', 'casefold', 'center',
'count', 'encode', 'endswith', 'expandtabs', 'find',
'format', 'format_map', 'index', 'isalnum', 'isalpha',
'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric',
'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust',
'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind',
'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split',
'splitlines', 'startswith', 'strip', 'swapcase', 'title',
'translate', 'upper', 'zfill'
"""
# 前后有兩個下劃線的為魔術方法，剩下的則是我們這一節討論的方法。
首先丟出這節的目錄：
目錄
首先丟出這節的目錄：
1、capitalize()
2、casefold()
3、center()
4、count()
5、encode()
6、endswith()
7、expandtabs()
8、find()
9、format
10、format_map(maping)
11、index
12、isalnum
13、isalpha
14、isdecimal
15、isdigit
16、isidentifier
17、islower
18、isnumeric
19、isprintable
?20、isspace
21、istitle
22、isupper
23、join
24、ljust
25、lower
26、lstrip
27、maketrans
28、partition
29、replace
30、rfind
31、rindex
32、rjust
33、rpartition
34、rsplit
35、rstrip
36、split
37、splitlines
38、startswith
39、strip
40、swapcase
41、title
42、translate
43、upper
44、zfill
1、capitalize()
還是老規矩，看看pycharm對于capitalize方法給出的解釋。大致意思第一個字符就是返回一個大寫的版本，其他的還是小寫
def capitalize(self): # real signature unknown; restored from __doc__
"""
S.capitalize() -> str
Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case.
"""
return ""
capitalize（）具體使用情況如下
a = "life is too short,I use Python"
print(a) # life is too short,I use Python
print(a.capitalize()) # Life is too short,i use python
s = "人生苦短，我用Python"
print(s) # 人生苦短，我用Python
print(s.capitalize()) # 人生苦短，我用python
s1 = "人生苦短，我用python"
print(s1) # 人生苦短，我用python
print(s1.capitalize()) # 人生苦短，我用python
由上面兩個變量可以看出。capitalize()是返回一個字符串副本，并將第一個字符大寫。假如第一個字符不是英文，會將后面第一個英文字符進行小寫化，若是小寫的存在則保持小寫狀態，不進行改變。
2、casefold()
對于casefold（）方法，pycharm給出的解釋是：
def casefold(self): # real signature unknown; restored from __doc__
"""
S.casefold() -> str
Return a version of S suitable for caseless comparisons.
"""
意思是返回經過標準化（normalize）后的字符串，標準化類似于轉換為小寫，但更適合用于對Unicode字符串進行不區分大小寫的比較，和我們眾所周知的lower（）方法不同，casefold可以將對于其他語言（非漢語或英文）中把大寫轉換為小寫。如下面的代碼塊中的 西塔 Theta 屬于希臘字符就發生了改變。
a = "PYTHON"
print(a) # PYTHON
print(a.casefold()) # python
c = "Θ"
print(c) # Θ
print(c.casefold()) #θ
3、center()
順序介紹第三個就是center，中心中央這個單詞，那么來看看pycharm給我們的對于它的解釋是什么呢？
def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.center(width[, fillchar]) -> str
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
"""
return ""
返回一個長度為（len（string），width）的字符串。這個字符串的中間包括當前字符串，但兩端用fillchar指定的字符（默認是空格）填充。注意：“雙引號”可以不存在，那么就是默認空字符串填寫在原str前后兩端，若寫了“雙引號”并沒有添加空格，則會出現報錯提醒，如代碼塊：
# 語法：str.center(width , "fillchar") -> str 返回字符串
a = "hello world"
print(a) # hello world
print(a.center(20,"*")) # ****hello world*****
b = "hello world"
print(b.center(20,"")) #TypeError: The fill character must be exactly one character long
4、count()
第四個是count，這個方法還是比較常見的一種方法在各個編程語言中，統計某個字符在這個字符串中出現的次數，可搜索范圍限定為string[start :end] ， 其中pycharm給的解釋是：
def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are
interpreted as in slice notation.
"""
return 0
那么在實際的環境中，應用的效果：
# S.count(sub[, start[, end]]) -> int
s = "color red yellow green blue black white purple"
print(s.count("o", 0, )) #3
print(s.count("o")) # 3
print(s.count("o", ,10)) # SyntaxError: invalid syntax
將指定字符串找到后，用上count() 方法，括號里面第一個字符用“雙引號”包含在其中，中間的start為指定開始的位置，從你指定位置開始向后尋找，指定查找的字符，end為終止節點，此位置后的字符串將不考慮在查找范圍內，當然我們可以填了start后空出end的位置，那么就自動匹配到字符串結束。假如start & end 都不存在，則是對整個字符串進行搜索。 假如start的位置空出，只填寫sub & end 的話，會報錯的。
5、encode()
對于這個encode() 方法，看單詞就知道這個方法跟編碼有關。pycharm給的解釋：返回使用指定編碼和errors指定的錯誤處理方式對字符串進行編碼的結果。
def encode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__
"""
S.encode(encoding='utf-8', errors='strict') -> bytes
Encode S using the codec registered for encoding. Default encoding
is 'utf-8'. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that can handle UnicodeEncodeErrors.
"""
return b""
encoding參數中有utf-8、utf-16、utf-32、gbk、ASCII 碼，參數errors的值可能取值包含 ‘strict’ 、‘ignore’ 、 ‘replace’等。
# encode()語法：str.encode(encoding='UTF-8',errors='strict')
str = "hello world!"
print(str.encode("gbk","strict")) # b'hello world!'
print(str.encode("utf-8", "strict")) # b'hello world!'
print(str.encode("utf-16","strict"))
# b'\xff\xfeh\x00e\x00l\x00l\x00o\x00 \x00w\x00o\x00r\x00l\x00d\x00!\x00'
print(str.encode("utf-32","strict"))
# b'\xff\xfe\x00\x00h\x00\x00\x00e\x00\x00\x00l\x00\x00\x00l\x00\x00\x00o\x00\x00\x00 \x00\x00\x00w\x00\x00\x00o\x00\x00\x00r\x00\x00\x00l\x00\x00\x00d\x00\x00\x00!\x00\x00\x00'
6、endswith()
endswitch()方法是用于檢查字符串是否以suffix結尾，還可使用索引start和end來指定匹配范圍，如果以指定后綴結尾返回True，否則返回False。pycharm的使用方法 & 解釋為：
def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
"""
return False
endswith()方法語法：
S.endswith(suffix[, start[, end]]) -> bool
具體用法如下：
a = "hello world!"
print(a.endswith("d")) # False
print(a.endswith("!", 0)) # True
print(a.endswith("ll", 2, 4)) # True
print(a[2:4]) # ll
這個方法若用于檢查最后字符串最后一位的話，無須填寫start & end，默認就好了。若檢驗中間的指定字符串用法就類似于list中的切片，用start & end 截取出指定范圍并進行校對。
7、expandtabs()
返回將字符串中的制表符展開為空格后的結果，可指定可選參數tabsize（默認為8），說通俗一點就是把字符串中的 tab 符號('\t')轉為空格，tab 符號('\t')默認的空格數是 8。pycharm的使用方法 & 解釋為：
def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
"""
S.expandtabs(tabsize=8) -> str
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
"""
return ""
expandtabs()方法語法為：
S.expandtabs(tabsize=8) -> str
具體方法如下：
str = "this\tis python ! "
print(str.expandtabs(8)) # this is python !
print(str.expandtabs(12)) # this is python !
print(str.expandtabs(16)) # this is python !
該方法返回字符串中的 tab 符號('\t')轉為空格后生成的新字符串。轉換的長度隨expandtabs中參數變化而變化。
8、find()
返回找到的第一個子串sub的索引，如果沒有找到這樣的子串，就返回-1；還可將搜索范圍限制為string[start : end]
def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.find(sub[, start[, end]]) -> int
Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
"""
return 0
具體的格式：?S.find(sub[, start[, end]]) -> int；str -- 是檢索的字符串；start -- 開始索引，默認為0；end -- 結束索引，默認為字符串的長度 。 那么運行起來是一個這樣的一個情況：
# S.find(sub[, start[, end]]) -> int
a = "life is short , i use python."
print("字母i在{}位置上".format(a.find("i"))) # 字母i在1位置上
print('use在{}位置上'.format(a.find('s',14,15))) # use在-1位置上
print('use在{}位置上'.format(a.find('s',14,20))) # use在19位置上
首先我們先找的字母i，find()函數自動會檢查到第一個符合我們指定的字符并返回位置，第二個print輸出為指定的字符串，并且指定了開始索引和結束索引，但是在這個范圍內，并沒有找到符合的字符串，所以返回值為-1，第三個print輸出則返回的是一個匹配正確的字符串的首字母u的位置。即use中的u字母在19的位置上。
9、format
實現了標準的Python字符串格式設置。將字符串中用大括號分割的字段替換為相應的參數，再返回結果。
具體用法就像上面的使用的代碼塊。pycharm給的用法解釋為：
def format(self, *args, **kwargs): # known special case of str.format
"""
S.format(*args, **kwargs) -> str
Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').
"""
pass
10、format_map(maping)
類似于使用關鍵字參數調用format，只是參數是映射的方式提供的。即mapping是一個字典對象。
def format_map(self, mapping): # real signature unknown; restored from __doc__
"""
S.format_map(mapping) -> str
Return a formatted version of S, using substitutions from mapping.
The substitutions are identified by braces ('{' and '}').
"""
return ""
# S.format_map(mapping) -> str
Student = {"id":"001","name":"Bob","age":"18"}
print("My name is {name}，I'm {age} old ,my id is {id}".format_map(Student))
# My name is Bob，I'm 18 old ,my id is 001
print("My name is {name}，I'm {age} old ".format_map(Student))
# My name is Bob，I'm 18 old
于format不同，format是將后面的參數插入前面輸出的大括號中，參數類型可以是str、list、數字等。但是format_map（）中的參數只能是鍵值對其中的value值，你可以設置了多個鍵值對，不必全部輸出。選擇想輸出的value在大括號中填入其對應的key值即可。
11、index
index(sub[, start[, end]])返回找到的第一個子串sub的索引，如果沒有找到這樣的子串，將引發valueError異常；還可將搜索范圍限制為string[start:end]。
def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.index(sub[, start[, end]]) -> int
Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Raises ValueError when the substring is not found.
"""
return 0
s = "If we just open the door a crack,the light comes pouring in."
print("open中o字母在{}位置上".format(s.index("open")))
print(s.index("open", 0, 1)) # ValueError: substring not found
index()方法和第8個提到的find()方法很相似，都是在一定長度的字符串中查找規定子串的首次出現位置。不同點在于，index直接返回ValueError異常，而find返回值為-1。
12、isalnum
isalnum()檢查字符串中的字符是否 都為字母或數 ，滿足則返回Ture，不滿足返回False。
def isalnum(self): # real signature unknown; restored from __doc__
"""
S.isalnum() -> bool
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
"""
return False
a = 'd1231dsa1'
print(a.isalnum()) # True
b = "$asd%gq12"
print(b.isalnum()) # False
很好理解。
13、isalpha
isalpha（）檢查字符串中的字符是否 都是字母 。用法如上12，isalnum方法。
# S.isalpha() -> bool
a = "hello"
print(a.isalpha()) # True
14、isdecimal
isdecimal（）檢查字符串中的字符是否都是十進制的數，用法如上12，isalnum方法。注：python中二進制為0o開頭，八進制數位0x開頭，16進制數位0b開頭。
# S.isdecimal() -> bool
a = oct(64)
print(a, a.isdecimal()) # 0o100 False
b = hex(64)
print(b, b.isdecimal()) # 0x40 False
c = bin(64)
print(c, c.isdecimal()) # 0b1000000 False
d = '64'
print(d, d.isdecimal()) # 64 True
15、isdigit
isdigit（）檢查字符串中的字符是否都是數字。
# S.isdigit() -> bool
a = "\t2t123"
print(a.isdigit()) # False
a = "123"
print(a.isdigit()) # Ture
16、isidentifier
isidentifier（）檢查字符串是否可用作Python標識符。在python里，標識符有字母、數字、下劃線組成。所有標識符可以包括英文、數字以及下劃線（_），但不能以數字開頭。標識符可以簡單的理解成為一個文件命名的規范。
# S.isidentifier() -> bool
a = "\t"
print(a.isidentifier()) # False
a = "1"
print(a.isidentifier()) # False
?
17、islower
islower（）檢查字符串中 所有字母都是小寫 的。不管字符串中有沒有其他東西，比如數字，漢字，符號等等。
# S.islower() -> bool
a = 'abc'
print(a.islower()) # True
a = 'Abc'
print(a.islower()) # False
a = "123abc"
print(a.islower()) # True
18、isnumeric
isnumeric（）檢查字符串中的所有字符是否 都是數字字符 。
# S.isnumeric() -> bool
a = '\t\n'
print(a.isnumeric()) # False
a = '123'
print(a.isnumeric()) # Ture
a = '123\t'
print(a.isnumeric()) # False
a = "hello world"
print(a.isnumeric()) # False
19、isprintable
isprintable（）檢查字符串中的字符是否都是可打印的。如\t 制表符 ， \n換行符是無法打印的。
#S.isprintable() -> bool
a = '\t\t\t'
print(a.isprintable()) # False
a = '\t\n'
print(a.isprintable()) # False
a = '123\t'
print(a.isprintable()) # False
?20、isspace
isspace（）檢查字符串中的字符都是空白字符。
#S.isspace() -> bool
a = ' '
print(a.isspace()) # True
a = '00'
print(a.isspace()) # False
a = '\t\t\t'
print(a.isspace()) # True
a = '\t\n'
print(a.isspace()) # True
21、istitle
istitle（）檢查字符串中位于非字母后面的字母都是大寫的，且其他所有字母都是小寫的。我的理解就是檢查開頭第一個英文字符是不是大寫。
# S.istitle() -> bool
a = "56賦值A%&*@13 23A"
print(a.istitle()) # True
a = "asad1AVB"
print(a.istitle()) # False
a = "hello world!"
print(a.istitle()) # False
a = "Hello World!"
print(a.istitle()) # True
22、isupper
isupper（）檢查字符串中的字母是否都是大寫。
# S.isupper() -> bool
a = "hello world！"
print(a.isupper()) # False
a = "HELLO WORLD!"
print(a.isupper()) # True
"""
對于上面的一類以is開頭的方法，就是檢驗是否滿足
其后面剩余的字符的方法，如islower拆成is & lower
其中lower方法會在后面介紹，是一種將字符串中大寫字符
轉換成小寫的一個方法。
"""
23、join
join（）方法，將string與sequence中所有的字符串元素合并生成的新字符串，并返回結果。兩字符串相連
def join(self, iterable): # real signature unknown; restored from __doc__
"""
S.join(iterable) -> str
Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.
"""
return ""
a = "——"
b = "abc"
print(a.join(b)) # a——b——c
24、ljust
ljust()返回一個長度為max（len（string),width)的字符串，其開頭是當前字符串的副本，而末尾是使用fillchar指定的字符（默認為空格）填充的。
- width -- 指定字符串長度。
- fillchar -- 填充字符，默認為空格。
def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.ljust(width[, fillchar]) -> str
Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
"""
return ""
a = "hello"
print(a.ljust(10,'c')) # helloccccc
顯示結果為10個字符長度的字符串，在原字符串的基礎上增加到了10（原本是5，增加了5個字符）。
25、lower
lower（）將字符串中所有的字母都轉換成小寫，并返回結果。
def lower(self): # real signature unknown; restored from __doc__
"""
S.lower() -> str
Return a copy of the string S converted to lowercase.
"""
return ""
a = "HELLO WORLD!"
print(a.lower()) # hello world!
a = "hello world!"
print(a.lower()) # hello world!
26、lstrip
lstrip（[chars])將字符串開頭所有的chars（默認為所有的空白字符，如空格、制表符和換行符）都刪除，并返回結果。刪除完后自動縮進定格。
def lstrip(self, chars=None): # real signature unknown; restored from __doc__
"""
S.lstrip([chars]) -> str
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
"""
return ""
a = "aaaaaaaaaaaaahello world!"
print(a.lstrip("a")) # hello world!
a = " hello world!"
print(a.lstrip()) # hello world!
27、maketrans
一個靜態方法，創建一個供translate使用的轉換表。如果只指定了參數x，它必須是從字符或序數到Unicode序數或None（用于刪除）的映射；也可使用兩個表示源字符和目標字符串調用它；還可以提供第三個參數，它指定要刪除的字符。
def maketrans(self, *args, **kwargs): # real signature unknown
"""
Return a translation table usable for str.translate().
If there is only one argument, it must be a dictionary mapping Unicode
ordinals (integers) or characters to Unicode ordinals, strings or None.
Character keys will be then converted to ordinals.
If there are two arguments, they must be strings of equal length, and
in the resulting dictionary, each character in x will be mapped to the
character at the same position in y. If there is a third argument, it
must be a string, whose characters will be mapped to None in the result.
"""
pass
str.maketrans(intab, outtab)
- intab -- 字符串中要替代的字符組成的字符串。
- outtab -- 相應的映射字符的字符串。
intab = "aei"
outtab = "123"
deltab = "to"
trantab1 = str.maketrans(intab , outtab) # 創建字符映射轉換表
trantab2 = str.maketrans(intab,outtab,deltab) #創建字符映射轉換表，并刪除指定字符
test = "this is string example....wow!!!"
print(test.translate(trantab1)) # th3s 3s str3ng 2x1mpl2....wow!!!
print(test.translate(trantab2)) # h3s 3s sr3ng 2x1mpl2....ww!!!
28、partition
在字符串中搜索sep，并返回元祖（sep前面的部分，sep，sep后面的部分）。pycharm給的解釋：
def partition(self, sep): # real signature unknown; restored from __doc__
"""
S.partition(sep) -> (head, sep, tail)
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.
"""
pass
a = "good"
b = a.partition('o')
print(b, type(b)) # ('g', 'o', 'od')
# 記住tuple不能修改
29、replace
將字符串中的子串old替換成new，并返回結果；還可將最大替換次數限制為max。S.replace(old, new[, count]) -> str，old為原字符串的子串，new為即將替換的子串。replace在字符串的使用中頻率是比較高的一類。
def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
"""
S.replace(old, new[, count]) -> str
Return a copy of S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
"""
return ""
print("this is a test".replace('this', 'This')) # This is a test
30、rfind
返回找到的最后一個子串的索引，如果沒有找到這樣的子串，就返回-1；還可將搜索范圍限定為string[start : end]。S.rfind(sub[, start[, end]]) -> int，sub為規定子串，start為開始索引，end為結束索引。
def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.rfind(sub[, start[, end]]) -> int
Return the highest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
"""
return 0
print("This is a test".rfind('s', 0, 1)) # -1
print("This is a test".rfind('s')) # 12
rfind和find的返回相同，錯誤則返回-1，正確的找到則返回滿足要求的索引值。
不同點：find 為第一個子串的索引，rfind為最后一個子串的索引，r即right（右，從后往前讀）
31、rindex
rindex(sub[, start[, end]])返回找到的 最后 一個子串sub的索引，如果沒有找到這樣的子串，將引發valueError異常；還可將搜索范圍限制為string[start:end]。
def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.rindex(sub[, start[, end]]) -> int
Return the highest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Raises ValueError when the substring is not found.
"""
return 0
s = "If we just open the door a crack,the light comes pouring in."
print("t字母在{}位置上".format(s.rindex("t"))) # t字母在41位置上
print(s.index("t", 0, 1)) # ValueError: substring not found
rindex和index的返回相同，錯誤則返回ValueError異常，正確的找到則返回滿足要求的索引值。
不同點：rindex 為第一個子串的索引，index 為最后一個子串的索引，r即right（右，從后往前讀）
32、rjust
返回一個長度為max(len(String),width)的字符串。其末尾是當前字符串的拷貝，而開頭是使用fillchar指定的字符（默認為空格）填充的。
- width -- 指定字符串長度。
- fillchar -- 填充字符，默認為空格。
def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.rjust(width[, fillchar]) -> str
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
"""
return ""
a = "aaaahello world!aaaa"
print(a.lstrip("a")) # hello world!aaaa
a = " hello world! "
print(a.lstrip()) # hello world!
注意：ljust ——L = left? ? ，? ?rjust —— R = right
33、rpartition
與partition相同，但從右往左搜索。將字符串按照要求切成三段類似于切片。
def rpartition(self, sep): # real signature unknown; restored from __doc__
"""
S.rpartition(sep) -> (head, sep, tail)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.
"""
pass
a = "good"
b = a.rpartition('o')
print(b, type(b)) # ('go', 'o', 'd')
# 記住tuple不能修改
34、rsplit
與split相同，但指定了參數maxsplit，從右往左計算劃分次數。
def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
"""
S.rsplit(sep=None, maxsplit=-1) -> list of strings
Return a list of the words in S, using sep as the
delimiter string, starting at the end of the string and
working to the front. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified, any whitespace string
is a separator.
"""
return []
a = 'good\tfood\tnood\taood'
print(a.rsplit()) # ['good', 'food', 'nood', 'aood']
print(a.rsplit("\t",2)) # ['good\tfood', 'nood', 'aood']
35、rstrip
將字符串末尾所有的chars字符（默認為所有的空白字符，如空格、制表符、換行符）都刪除，并返回結果。
def rstrip(self, chars=None): # real signature unknown; restored from __doc__
"""
S.rstrip([chars]) -> str
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
"""
return ""
a = "hello world!!!!"
print(a.rstrip("!")) # hello world
a = "hello world!\t\t\t\n"
print(a.rstrip()) # hello world!
注意：rstrip為從右(right)往左右刪規定字符。strip為從左（默認）往右刪除規定字符。
36、split
split()通過指定分隔符對字符串進行切片，如果參數 num 有指定值，則分隔 num+1 個子字符串。
def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
"""
S.split(sep=None, maxsplit=-1) -> list of strings
Return a list of the words in S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are
removed from the result.
"""
return []
a = 'good\tfood\tnood\naood'
print(a.split()) # ['good', 'food', 'nood', 'aood']
print(a.rsplit()) # ['good', 'food', 'nood', 'aood']
print(a.split("\t",2)) # ['good', 'food', 'nood\naood']
split 和rsplit的用法差不多，唯一的區別就是它們讀取字符串的順序，split默認從左向右分開，rsplit則從右向左分開。和strip、rstrip的區分一樣。
37、splitlines
splitlines按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果參數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。
其中參數keepends -- 在輸出結果里是否保留換行符('\r', '\r\n', \n')，默認為 False，不包含換行符，如果為 True，則保留換行符。
def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
"""
S.splitlines([keepends]) -> list of strings
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
"""
return []
a = "abc\n\n\td ef\nghi \tjk"
print(a)
# abc
#
# d ef
# ghi jk
print(a.splitlines()) # ['abc', '', '\td ef', 'ghi \tjk']
b = "abc\n\n\td ef\nghi \tjk"
print(a.splitlines(True)) # ['abc\n', '\n', '\td ef\n', 'ghi \tjk']
38、startswith
startswith() 方法用于檢查字符串是否是以指定子字符串開頭，如果是則返回 True，否則返回 False。如果參數 beg 和 end 指定值，則在指定范圍內檢查。
startswith 用法 ： S.startswith(prefix[, start[, end]]) -> bool
- str -- 檢測的字符串。
- strbeg -- 可選參數用于設置字符串檢測的起始位置。
- strend -- 可選參數用于設置字符串檢測的結束位置。
def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
"""
return False
a = "Other men live to eat， while I eat to live"
print(a.startswith("Other")) # True
print(a.startswith("O")) # True
print(a.find("men")) # 6
print(a.startswith("men", 6, 9)) # True
39、strip
strip() 方法用于移除字符串頭尾指定的字符（默認為空格或換行符）或字符序列。str.strip（[chars]）中chars -- 移除字符串頭尾指定的字符序列。
def strip(self, chars=None): # real signature unknown; restored from __doc__
"""
S.strip([chars]) -> str
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
"""
return ""
a = "123apple123"
print(a.strip("123")) # apple
a = "123ap123ple123"
print(a.strip("123")) # ap123ple
結果顯示：strip只能刪除頭尾指定的字符串，對字符串中的字符刪除不了。
40、swapcase
sqapcase（）用于對字符串的大小寫字母進行轉換。
def swapcase(self): # real signature unknown; restored from __doc__
"""
S.swapcase() -> str
Return a copy of S with uppercase characters converted to lowercase
and vice versa.
"""
return ""
a = "Life is short, just ues Python."
print(a.swapcase()) # lIFE IS SHORT, JUST UES pYTHON.
a = "hello WORLD!\n你好世界！"
print(a.swapcase())
# HELLO world!
# 你好世界！
41、title
title() 方法返回"標題化"的字符串,就是說所有單詞都是以大寫開始，其余字母均為小寫(見 istitle())。
def title(self): # real signature unknown; restored from __doc__
"""
S.title() -> str
Return a titlecased version of S, i.e. words start with title case
characters, all remaining cased characters have lower case.
"""
return ""
a = "life is short, just use Python"
print(a.title()) # Life Is Short, Just Use Python
print((a.title()).istitle()) # True
istitle是來判斷每個單詞是不是大寫開頭，那么我拿到后先用title轉換成每個單詞首字母大寫，再用istitle自然滿足istitle的判斷要求并輸出True。
42、translate
translate() 方法根據參數table給出的表(包含 256 個字符)轉換字符串的字符, 要過濾掉的字符放到 del 參數中。
translate()方法語法：str.translate(table[, deletechars]);
- table -- 翻譯表，翻譯表是通過maketrans方法轉換而來。
-
deletechars -- 字符串中要過濾的字符列表。
def translate(self, table): # real signature unknown; restored from __doc__ """ S.translate(table) -> str Return a copy of the string S in which each character has been mapped through the given translation table. The table must implement lookup/indexing via __getitem__, for instance a dictionary or list, mapping Unicode ordinals to Unicode ordinals, strings, or None. If this operation raises LookupError, the character is left untouched. Characters mapped to None are deleted. """ return ""43、upper
upper()方法將字符串中的小寫字母轉為大寫字母。
def upper(self): # real signature unknown; restored from __doc__
"""
S.upper() -> str
Return a copy of S converted to uppercase.
"""
return ""
a = "hello world!"
print(a.upper()) # HELLO WORLD!
44、zfill
zfill()方法是最后一個方法，陸陸續續的寫終于寫到了最后一個方法。 zfill() 方法返回指定長度的字符串，原字符串右對齊，前面填充0。
def zfill(self, width): # real signature unknown; restored from __doc__
"""
S.zfill(width) -> str
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
"""
return ""
a = "Life is short , just use Python"
print(a.zfill(40))
# 000000000Life is short , just use Python
字符串的方法基本上全部介紹完畢， 下面一章介紹list列表的方法。
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
