Python數據結構之字符串類型（str）

字符串類型（str）

• 字符串說明

• 索引和切片

• 轉義字符

• 字符串運算符

• 字符串格式化

• 字符串內置的函數

一.字符串說明

　　字符串是 Python 中最常用的數據類型。我們可以使用引號('或")來創建字符串。

　　字符串是不可變的數據類型，不論執行任何操作，源字符串是不會改變的，每次操作都會返回新字符串；

　　創建字符串，只需要為變量賦值即可，如：Str = "hello world"

　　字符串在轉換成int時，如果字符串中的數字有空格，則在轉換時自動去除空格；

　　訪問字符串中的值：

　　Python 不支持單字符類型，單字符在 Python 中也是作為一個字符串使用。

>>> print("hello world")
hello world

　　字符串更新：

　　可以截取字符串的一部分並與其他字段拼接，如下實例：

>>> print("hello world" + " 你好，中國")
hello world 你好，中國

二、索引和切片

1.索引

　　說明：通過索引取出字符串對應的值

　　格式：str[下標]

　　參數：下標 ------ > 是一個int型數據，

　　索引從0開始，使用[下標]可以獲取到每一個字符，還可以倒着數，最后一個字符用-1表示，一次往前數是-1、-2...

　　返回值：返回字符串對應索引所對應的值；如果索引超出邊界則報錯

　　實例：

>>> s = "abcdefg"
>>> print(s[0])
a
>>> print(s[1])
b
>>> print(s[2])
c
>>> print(s[3])
d
>>> print(s[4])
e
>>> print(s[5])
f
>>> print(s[6])
g

----------------索引超出邊界，報錯---------------------------------

　>>> print(s[7])
　　Traceback (most recent call last):
　　File "<stdin>", line 1, in <module>
　　IndexError: string index out of range

 

2.切片

　　說明：通過切片取出字符串的一段字符；

　　格式：str[起始位置:結束位置:步長]

　　參數：起始位置 --------> 表示從哪個下標開始

　　　　　結束位置 --------> 表示到哪個下標結束

　　　　　 步長 --------------> 默認從左到右，步長為1，也可以取反，表示倒敘，步長取負數

　　特點：顧頭不顧尾，從start開始截取. 截取到end位置. 但不包括end

　　返回值：返回一個由切片選擇好的子串；

　　實例：

>>> s = "abcdefg"
>>> print(s[:])
abcdefg
>>> print(s[0:4])
abcd
>>> print(s[2:6])
cdef
>>> print(s[:6:2])
ace
>>> print(s[1::2])
bdf
>>> print(s[::-1])
gfedcba
>>> print(s[-1:-3])

>>> print(s[-1:-3:-1])
gf
>>> print(s[-1::-2])
geca

 

 

 

 

 

 

 

三.轉義字符

　　在需要在字符中使用特殊字符時，python用反斜杠(\)轉義字符。如下表：

四.字符串運算符

下表實例變量a值為字符串 "Hello"，b變量值為 "Python"：

五.字符串格式化

　　Python 支持格式化字符串的輸出 。盡管這樣可能會用到非常復雜的表達式，但最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中。

　　在 Python 中，字符串格式化使用與 C 中 sprintf 函數一樣的語法。

>>> print("中國的首都是%s" % ("北京"))
中國的首都是北京

　　python字符串格式化符號:

　　格式化操作符輔助指令:

六.字符串內置的函數

　　

 

　　1.capitalize(self)

　　說明：將字符串的第一個字符轉換為大寫，其他字母變成小寫；注意的是並不會改變原字符串內容；

　　語法：str.capitalize()

　　返回值：該方法返回一個首字母大寫的字符串；

　　實例：

>>> S = "hello WoRld"
>>> print(S.capitalize())
Hello world

 

　　2.casefold(self)

　　說明：將字符串中的所有大寫字符轉換為小寫字符；並支持識別東歐的一些字母；lower不支持東歐的字母；

　　語法：str.casefold()

　　返回值：返回將字符串中所有大寫字符轉換為小寫后生成的字符串；

　　實例：

>>> S = "hello WoRld"
>>> print(S.casefold())
hello world

 

　　3.center(self, width, fillchar=None)

　　說明：返回一個指定的寬度width且居中的字符串，字符串長度為width，fillchar為填充的字符，默認為空格；

　　語法：str.center(width,fillchar)

　　返回值：返回一個指定的寬度 width 居中的字符串，如果 width 小於字符串寬度直接返回字符串，否則使用 fillchar 去填充。

　　實例：

>>> print("今日頭條".center(40,"*"))
******************今日頭條******************

 

　　4.count(self, sub, start=None, end=None)

　　說明：用於統計字符串里某個字符出現的次數。可選參數為在字符串搜索的開始與結束位置。

　　語法：str.count(sub,start=None, end=None)

　　參數：sub  -----> 要搜索的子字符串；

　　　　　start -----> 字符串開始搜索的位置。默認為第一個字符,第一個字符索引值為0;

　　　　　end ------> 字符串中結束搜索的位置。字符中第一個字符的索引為 0。默認為字符串的最后一個位置;

 　  返回值：返回子字符串在字符串中出現的次數；

　　實例：

>>> print(ss.count("a"))
2
>>> print(ss.count("a",0,8))
1

 

　　5.encode(self, 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 對象

　　實例：

>>> abc = "燈火闌珊"
>>> abc_utf8 = abc.encode("UTF-8")
>>> abc_gbk = abc.encode("GBK")
>>> print(abc)
燈火闌珊
>>> print(abc_utf8)
b'\xe7\x81\xaf\xe7\x81\xab\xe9\x98\x91\xe7\x8f\x8a'
>>> print(abc_gbk)
b'\xb5\xc6\xbb\xf0\xc0\xbb\xc9\xba'

 

　　6.decode(self, decoding='utf-8', errors='strict')

　　說明：以指定的編碼格式來解碼字符串。errors參數可以指定不同的錯誤處理方案。

　　語法：bytes.decode(encoding="utf-8", errors="strict")

　　參數：encoding -----> 要使用的編碼，如：UTF-8

　　　　　errors -----> 設置不同錯誤的處理方案。默認為 'strict',意為編碼錯誤引起一個UnicodeError。 其他可能得值有 'ignore', 'replace', 　　　                                        'xmlcharrefreplace', 'backslashreplace' 以及通過 codecs.register_error() 注冊的任何值。

　　返回值：返回解碼后的字符串；

　　實例：

>>> print(abc_gbk.decode("GBK"))
燈火闌珊
>>> print(abc_utf8.decode("UTF-8"))
燈火闌珊

 

　　7.endswith(self, suffix, start=None, end=None)

　　說明：用於判斷字符串是否以指定后綴結尾，如果以指定后綴結尾返回True，否則返回False；

　　語法：str.endswith(suffix,start=None, end=None)

　　參數：suffix -----> 該參數可以是一個字符串或者是一個元素；

　　　　    start ------> 字符串中的開始位置;

　　　　    end  ------> 字符中結束位置

　　返回值：如果字符串含有指定的后綴返回True，否則返回False；

　　實例：

>>> end = "hello world"
>>> print(end.endswith("ld"))
True
>>> print(end.endswith("ld",0,10))
False

 

　　8.expandtabs(self, tabsize=8)

　　說明：把字符串中的 tab 符號('\t')轉為空格，tab 符號('\t')默認的空格數是 8；

　　注意：規則是這樣的，如果設置空格數是8，則會從開頭查詢，每8個字符為一組，到有\t那組時，缺幾個就補幾個空格；

　　語法：str.expandtabs(tabsize=8)

　　參數：tabszie -----> 指定轉換字符串中的 tab 符號('\t')轉為空格的字符數；

　　返回值：返回字符串中的 tab 符號('\t')轉為空格后生成的新字符串；

　　實例：

>>> ss = "this is \tstring example"
>>> print(ss)
this is     string example
#this is 剛好8個，所以到\t這里自動在補8個空格；

>>> print(ss.expandtabs(0)) 

this is string example 
#0自動沒有

>>> print(ss.expandtabs(20)) 
this is             string example
#this is \t是8個，設置的是20空格，所以還需在補12個空格

 

　　9.find(self, sub, start=None, end=None)

　　說明：檢測字符串中是否包含子字符串 sub ，如果指定 start（開始） 和 end（結束） 范圍，則檢查是否包含在指定范圍內，如果指定范圍內如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。

　　語法：str.find(sub, start=None, end=None)

　　參數：sub ------> 指定檢索的字符串；

　　　　　start -----> 指定開始索引位置，默認為0

　　　　　end  -----> 指定結束索引位置，默認為字符串長度，len(str)

　　返回值：如果包含子字符串返回開始的索引值，否則返回-1；

　　實例：

>>> str1 = "Life is too short for python"
>>> print(str1.find("short"))
12
>>> print(str1.find("short",5,19))
12
>>> print(str1.find("short",17,19))
-1

 

　　10.format(self, *args, **kwargs)

　　說明：format函數用於字符串的格式化，通過{}和:來代替%；傳入的參數兩種形式，一種是位置參數，一種是關鍵字參數；位置參數不受順序約束，且可以為{},只要format里有相對應的參數值即可,參數索引從0開，傳入位置參數列表可用*列表，關鍵字參數值要對得上，可用字典當關鍵字參數傳入值，字典前加**即可，注意的是當位置參數和關鍵字參數混合使用時，位置參數一定要在關鍵字參數左邊。

　　語法：str.format( *args, **kwargs)

　　參數：*args ------> 當傳入的參數為列表時，可用*列表；

　　　　　**kwargs -------> 可用字典當關鍵字參數傳入值，字典前加**即可；

　　返回值：返回一個已經填充好的字符串。

　　例子：

------------------不設置指定位置，按默認順序--------------------------

>>> str2 = "中國的城市有,{},{},{},{}"
>>> print(str2.format("北京","上海","深圳","武安"))
中國的城市有,北京,上海,深圳,武安


----------------設置指定位置-------------------------------------------

>>> str2 = "中國的城市有,{3},{0},{2},{1}"
>>> print(str2.format("北京","上海","深圳","武安"))
中國的城市有,武安,北京,深圳,上海


------------------使用位置-列表形式---------------------------
>>> li = ["北京","上海","深圳","武安"]
>>> print(str2.format(*li))
中國的城市有,北京,上海,深圳,武安

-------------------使用關鍵字位置形式-------------------------
>>> print(str2.format(k2="北京",k3="上海",k1="深圳",k4="武安"}))
中國的城市有,深圳,北京,上海,武安

-------------------使用關鍵字位置字典形式-------------------------
>>> print(str2.format(**{"k2":"北京","k3":"上海","k1":"深圳","k4":"武安"}))
中國的城市有,深圳,北京,上海,武安


-------------------使用混合模式--------------------------------
>>> str2 = "中國的城市有,{3},{0},{2},{1},{h}"
>>> print(str2.format("北京","上海","深圳","武安",**{"h":"石家庄"}))
中國的城市有,武安,北京,深圳,上海,石家庄

　　也可以向.format()傳入對象：

class test():
    def __init__(self,asd):
        self.num = asd
ming = test(6)
print("ming的數字是：{0.num}".format(ming))
#{0.num}中的0是可選的表示指定位置

-------------------輸出結果為------------------------------

ming的數字是：6

　　.format()的數字格式化：

>>> print("{:.2f}".format(3.1415926))
3.14

　　下表展示了 str.format() 格式化數字的多種方法：

>>> print("{}對應的位置是{{0}}".format("zjk"))
zjk對應的位置是{0}

 

　　11.format_map(self, mapping)

　　說明：類似於format，不同的是format_map只能使用關鍵字位置形式傳入字典來進行；

　　語法：str.format_map(mapping)

　　參數：mapping -----> 必須是一個字典；

　　返回值：一個已經填充好的字符串；

　　實例：

>>> print("{name}對應的位置是{{0}}".format_map({"name":"zjk"}))
zjk對應的位置是{0}

 

　　12.index(self, sub, start=None, end=None)

　　說明：檢測字符串中是否包含子字符串 sub ，如果指定 start（開始） 和 end（結束） 范圍，則檢查是否包含在指定范圍內，該方法與 python find()方法一樣，只不過如果sub不在 str中則會報一個異常，而find則是返回-1；

　　語法：str.index(sub,start=None, end=None)

　　參數：sub ------> 指定檢索的子字符串；

　　　　　start -----> 指定開始索引位置，默認為0；

　　　　　end ------> 指定結束索引位置，默認為字符串的長度；

　　返回值：如果包含子字符串返回開始的索引值，否則拋出異常；

　　實例：

>>> str1 = "Life is too short for python"
>>> print(str1.index("short"))
12
>>> print(str1.index("short",14))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

 

　　13.isalnum(self)

　　說明：檢測字符串是否由字母和數字組成；

　　語法：str.isalnum()

　　返回值：如果 string 至少有一個字符並且所有字符都是字母或數字則返回 True,否則返回 False

　　實例：

>>> str1 = "helloworld"
>>> print(str1.isalnum())
True
>>> str2 = "hello world"
>>> print(str2.isalnum())
False

 

　　14.isalpha(self)

　　說明：檢測字符串是否只由字母組成；

　　語法：str.isalpha()

　　返回值：如果字符串至少有一個字符並且所有字符都是字母則返回 True,否則返回 False；

　　實例：

>>> str1 = "python"
>>> print(str1.isalpha())
True
>>> str2 = "python3"
>>> print(str2.isalpha())
False

 

　　15.isdecimal(self)

　　說明：檢查字符串是否只包含十進制字符。這種方法只存在於unicode對象；注意:定義一個十進制字符串，只需要在字符串前添加 'u' 前綴即可。

　　語法：str.isdecimal()

　　返回值：如果字符串只包含十進制字符返回True，否則返回False

　　實例：

>>> str1 = u"zjk2018"
>>> print(str1.isdecimal())
False
>>> str2 = u"201807"
>>> print(str2.isdecimal())
True

 

　　16.isdigit(self)

　　說明：檢測字符串是否只由數字組成；

　　語法：str.isdigit()

　　返回值：如果字符串只包含數字則返回 True 否則返回 False；

　　實例：

>>> str1 = "zjk2018"
>>> print(str1.isdigit())
False
>>> str2 = "201807"
>>> print(str2.isdigit())
True

 

　　17.isidentifier(self)

　　說明：判斷是否為python中的標識符，也就是說是否符合python變量名語法；

　　語法：str.isidentifier()

　　返回值：如果字符串的內容符合python變量命名語法，則返回True，否則返回False；

　　實例：

>>> str1 = "zjk1"
True
>>> str2 = "666zjk"
>>> str2.isidentifier()
False
>>> str3 = "變量名"
>>> str3.isidentifier()
True
>>> str4 = "def"
>>> str4.isidentifier()
True
#python的關鍵字一樣是合法的
>>> str5 = "88888"
>>> str5.isidentifier()
False

 

　　18.islower(self)

　　說明：檢測字符串是否由小寫字母組成；

　　語法：str.islower()

　　返回值：如果字符串中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是小寫，則返回 True，否則返回 False；

　　實例：

>>> str1 = "Life is too short for python -zjk23"
>>> print(str1.islower())
False
>>> str2 = "life is too short for python -zjk23"
>>> print(str2.islower())
True

 

　　19.isnumeric(self)

　　說明：檢測字符串是否只由數字組成。這種方法是只針對unicode對象；注：定義一個字符串為Unicode，只需要在字符串前添加 'u' 前綴即可；

　　語法：str.isnumeric()

　　返回值：如果字符串中只包含數字字符，則返回 True，否則返回 False

　　實例：

>>> str1 = "zjk1995"
>>> print(str1.isnumeric())
False
>>> str2 = "1995"
>>> print(str2.isnumeric())
True

 

　　20.isprintable(self)

　　說明：判斷是否由可打印字符組成，回車符等一些特殊字符是不會打印顯示在屏幕上的；

　　語法：str.isprintable()

　　返回值：如果字符串中所有內容都可打印則返回True，否則返回False；

　　實例：

>>> print("123\t4\t56".isprintable())
False
>>> print("123\\t456".isprintable())
True

 

　　21.isspace(self)

　　說明：檢測字符串是否只由空白字符組成；

　　語法：str.isspace()

　　返回值：如果字符串中只包含空格，則返回 True，否則返回 False；

　　實例：

>>> str1 = "    "
>>> print(str1.isspace())
True
>>> str2 = " sdf sdf"
>>> print(str2.isspace())
False

 

　　22.istitle(self)

　　說明：檢測字符串中所有的單詞拼寫首字母是否為大寫，且其他字母為小寫；

　　語法：str.istitle()

　　返回值：如果字符串中所有的單詞拼寫首字母是否為大寫，且其他字母為小寫則返回 True，否則返回 False；

　　實例：

>>> str1 = "Life Is Too Short For Python"
>>> print(str1.istitle())
True
>>> str2 = "Life is Too short For PyThon"
>>> print(str2.istitle())
False

 

　　23.isupper(self)

　　說明：檢測字符串中所有的字母是否都為大寫；

　　語法：str.isupper()

　　返回值：如果字符串中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是大寫，則返回 True，否則返回 False；

　　實例：

>>> str1 = "LIFE IS TOO SHORT FOR PYTHON"
>>> print(str1.isupper())
True
>>> str2 = "LIFE Is TOO ShOrT FOR PYTHON"
>>> print(str2.isupper())
False

 

　　24.join(self, iterable)

　　說明：用於將序列中的元素以指定的字符連接生成一個新的字符串；

　　語法：n.join(iterable)

　　參數：iterable ------> 要連接的元素序列；

　　　　　n --------------> 指定用來連接的字符；

　　返回值：返回通過指定字符連接序列中元素后生成的新字符串；

　　實例：

>>> str1 = "zjk"
>>> print("-".join(str1))
z-j-k

 

　　25.ljust(self, width, fillchar=None)

　　說明：返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。如果指定的長度小於原字符串的長度則返回原字符串；

　　語法：str.ljust(width, fillchar=None)

　　參數：width ------> 指定字符串長度；

　　　　　fillchar -----> 填充字符，默認為空格；

　　返回值：返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。如果指定的長度小於原字符串的長度則返回原字符串；

　　實例：

>>> str1 = "I Love You"
>>> print(str1.ljust(20,"*"))
I Love You**********

------------當指定的填充長度小於原字符串長度時返回原字符串-------

>>> str2 = "I Love You"
>>> print(str1.ljust(10,"*"))
I Love You

 

　　26.lower(self)

　　說明：轉換字符串中所有大寫字符為小寫；

　　語法：str.lower()

　　返回值：返回將字符串中所有大寫字符轉換為小寫后生成的字符串；

　　實例：

>>> str1 = "I Love You"
>>> print(str1.lower())
i love you

 

　　27.lstrip(self, chars=None)

　　說明：用於截掉字符串左邊的空格或指定字符，貪婪模式；

　　語法：str.lstrip( chars=None)

　　參數：chars ------> 指定截取的字符；

　　返回值：返回截掉字符串左邊的空格或指定字符后生成的新字符串；

　　實例：

>>> str1 = "666666I66Love You"
>>> print(str1.lstrip("6"))
I66Love You

 

　　28.maketrans(self, *args, **kwargs)

　　說明：用於創建字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示需要轉換的字符，第二個參數也是字符串表示轉換的目標。兩個字符串的長度必須相同，為一一對應的關系；

　　語法：str.maketrans(intab,outtab)

　　參數：intab -------> 需要轉換的字符串；

　　　　　outtab -----> 被轉換的字符串；

　　返回值：返回的是一個字典，字典內容是字符串的ASCII碼的序號，一一對應

　　實例：

>>> dat = str.maketrans("123","abc")
>>> print(dat)
{49: 97, 50: 98, 51: 99}

-----------------解釋--------------------------
1 的ASCII碼為 49
a 的ASCII碼為 97

 

　　29.partition(self, sep)

　　說明：返回一個由三個元素組成的元祖，第一個元素為分隔符左側的子串，第二個元素為分隔符，第三個元素為分隔符右側的子串；

　　語法：str.partition(sep)

　　參數：sep ------> 指定分隔符

　　返回值：返回一個由三個元素組成的元祖，第一個元素為分隔符左側的子串，第二個元素為分隔符，第三個元素為分隔符右側的子串；

　　實例：

>>> str1 = "http://www.dhlanshan.cn"
>>> print(str1.partition("//"))
('http:', '//', 'www.dhlanshan.cn')

-----------如果指定的分隔符在字符串中有兩個，則以最左側為分隔符----------

>>> print(str1.partition("."))
('http://www', '.', 'dhlanshan.cn')

 

　　30.replace(self, old, new, count=None)

　　說明：將字符串中的某子串進行替換，默認替換指定的所有子串；

　　語法：str.replace(old, new, count=None)

　　參數：old ------> 舊的子串；

　　　　　new -----> 新的子串；

　　　　　count ----> 替換的次數；

　　返回值：返回一個子串替換好之后的新的字符串；

　　實例：

------------------替換所有子串----------------------------

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.replace("a","A"))
http://video.dhlAnshAn.cn

-----------------從左到右只替換1次子串------------------

>>> print(str1.replace("a","A",1))
http://video.dhlAnshan.cn

 

　　31.rfind(self, sub, start=None, end=None)

　　說明：返回指定的子串在字符串中最后一次出現的位置，如果沒有匹配項則返回-1；也可以說是從右邊開始找這個指定的子串；

　　語法：str.rfind(sub, start=None, end=None)

　　參數：sub ------> 指定的子串；

　　　　　start ------> 開始查找的位置，默認為0;

　　　　　end  ------> 結束查找位置，默認為字符串的長度;

　　返回值：返回字符串最后一次出現的位置，如果沒有匹配項則返回-1

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.rfind("an"))
20
>>> print(str1.rfind("an",21))
-1

 

　　32.rindex(self, sub, start=None, end=None)

　　說明：返回子字符串 str 在字符串中最后出現的位置，如果沒有匹配的字符串會報異常，和rfind類似，只不過rfind找不到會返回-1；也可以說是從右邊開始找這個指定的子串；

　　語法：str.rindex(sub, start=None, end=None)

　　參數：sub ------> 指定的子串；

　　　　　start ------> 開始查找的位置，默認為0;

　　　　　end  ------> 結束查找位置，默認為字符串的長度;

　　返回值：返回子字符串 str 在字符串中最后出現的位置，如果沒有匹配的字符串會報異常；

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.rindex("an"))
20

---------------找不到則報錯--------------------------
>>> print(str1.rindex("an",21))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

　　

　　33.rjust(self, width, fillchar=None)

　　說明：返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串。如果指定的長度小於字符串的長度則返回原字符串。

　　語法：str.rjust(width, fillchar=None)

　　參數：width ------> 指定填充指定字符后中字符串的總長度；

　　　　　fillchar -----> 填充的字符，默認為空格；

　　返回值：返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串。如果指定的長度小於字符串的長度則返回原字符串；

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.rjust(30,"-"))
-----http://video.dhlanshan.cn

 

　　34.rpartition(self, sep)

　　說明：返回一個由三個元素組成的元祖，第一個元素為分隔符左側的子串，第二個元素為分隔符，第三個元素為分隔符右側的子串，分隔符從字符串的右邊開始查找。

　　語法：str.rpartition(sep)

　　參數：sep ----->指定分隔符；

　　返回值：返回一個由三個元素組成的元祖，第一個元素為分隔符左側的子串，第二個元素為分隔符，第三個元素為分隔符右側的子串；

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.rpartition("."))
('http://video.dhlanshan', '.', 'cn')

 

　　35.rsplit(self, sep=None, maxsplit=-1)

　　說明：分隔字符串，從右側開始分隔，返回一個將字符串以指定分隔符分隔的列表，從右邊開始查找分隔符,默認空格為分隔符；注意，最后列表里是不存在指定的那個分隔符的；

　　語法：str.rsplit(sep=None, maxsplit=-1)

　　參數：sep ------> 指定分隔符；

　　　　　maxsplit ------> 最多分隔的次數，-1表示全部分隔；

　　返回值：返回一個將字符串以指定分隔符分隔的列表；

　　實例：

--------------------分隔所有--------------------------------------
>>> str1 = "1 2 3 4 5"
>>> print(str1.rsplit(" ",maxsplit=-1))
['1', '2', '3', '4', '5']

-------------------分隔2次---------------------------------------
>>> print(str1.rsplit(" ",maxsplit=2))
['1 2 3', '4', '5']

--------------------列表中會刪除指定的分隔符-----------------
>>> print(str1.rsplit("3",maxsplit=1))
['1 2 ', ' 4 5']

 

　　36.rstrip(self, chars=None)

　　說明：刪除 string 字符串最右邊的指定字符（默認為空格）；貪婪模式；

　　語法：str.rstrip(chars=None)

　　參數：chars ------> 指定的子符；

　　返回值：返回刪除 string 字符串最右邊的指定字符后生成的新字符串；

　　實例：

>>> str1 = "**********今日說法**************"
>>> print(str1.rstrip("*"))
**********今日說法

 

　　37.split(self, sep=None, maxsplit=-1)

　　說明：分隔字符串，從左側開始分隔，返回一個將字符串以指定分隔符分隔的列表，從左邊開始查找分隔符,默認空格為分隔符；注意，最后列表里是不存在指定的那個分隔符的；

　　語法：str.rsplit(sep=None, maxsplit=-1)

　　參數：sep ------> 指定分隔符；

　　　　　maxsplit ------> 最多分隔的次數，-1表示全部分隔；

　　返回值：返回一個將字符串以指定分隔符分隔的列表；

　　實例：

--------------------分隔所有--------------------------------------
>>> str1 = "1 2 3 4 5"
>>> print(str1.split(" ",maxsplit=-1))
['1', '2', '3', '4', '5']

-------------------當分隔符為整個字符串時則返回一個有兩個空字符串的元素的列表----------------------

>>> str1 = "1 2 3 4 5"
>>> print(str1.split("1 2 3 4 5",maxsplit=-1))
['', '']

-------------------分隔2次---------------------------------------
>>> print(str1.split(" ",maxsplit=2)) ['1','2','3 4 5'] --------------------列表中會刪除指定的分隔符-----------------
>>> print(str1.split("3",maxsplit=1)) ['1 2 ', ' 4 5']

 

　　38.splitlines(self, keepends=None)

　　說明：按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果參數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。

　　語法：str.splitlines(keepends=None)

　　參數：keepends -- 在輸出結果里是否去掉換行符('\r', '\r\n', \n')，默認為 False，不包含換行符，如果為 True，則保留換行符

　　返回值：返回一個包含各行作為元素的列表。

　　實例：

>>> print("abc\n\ndefg\rkl\r\n".splitlines())
['abc', '', 'defg', 'kl']
>>> print("abc\n\ndefg\rkl\r\n".splitlines(True))
['abc\n', '\n', 'defg\r', 'kl\r\n']

 

　　39.startswith(self, prefix, start=None, end=None)

　　說明：用於檢查字符串是否是以指定子字符串開頭，如果是則返回 True，否則返回 False。如果參數 start 和 end 指定值，則在指定范圍內檢查。

　　語法：str.startswith(prefix, start=None, end=None)

　　參數：prefix ------> 指定的子串；

　　　　　start  -------> 索引開始處；

　　　　　end  --------> 索引結尾處；

　　返回值：如果檢測到字符串則返回True，否則返回False；

　　實例：

>>> str1 = "http://video.dhlanshan.cn"
>>> print(str1.startswith("http"))
True
>>> print(str1.startswith("video",7))
True
>>> print(str1.startswith(":",6,9))
False

 

　　40.strip(self, chars=None)

　　說明：用於移除字符串頭尾指定的字符（默認為空格）或字符序列。注意：該方法只能刪除開頭或是結尾的字符，不能刪除中間部分的字符。

　　語法：str.strip(chars)

　　參數：chars -------> 移除字符串頭尾指定的字符序列；

　　返回值：返回移除字符串頭尾指定的字符序列生成的新字符串；

　　實例：

>>> str1 = "**********今*日*說*法**************"
>>> print(str1.strip("*"))
今*日*說*法

　　無敵匹配法：

　　先看效果：

>>> str1 = "12345654321"
>>> print(str1.strip("12"))
3456543
>>> str1 = "12345654312"
>>> print(str1.strip("12"))
3456543
>>> str1 = "12345654321"
>>> print(str1.strip("125"))
3456543
>>> str1 = "1234565431221"
>>> print(str1.strip("12"))
3456543
>>> str1 = "1234565432121"
>>> print(str1.strip("12"))
3456543
 ----------------------------------------說明--------------------------------
#其實“12”是分為了3個匹配符，分別是"1" "2" "12",這三個匹配符會循環去匹配字符串，直到這三個匹配符一個也匹配不上為止。

 

　　41.swapcase(self)

　　說明：用於對字符串的大小寫字母進行轉換，小寫變大寫，大寫變小寫；

　　語法：str.swaocase()

　　返回值：返回大小寫字母轉換后生成的新字符串；

　　實例：

>>> str1 = "I Love You"
>>> print(str1.swapcase())
i lOVE yOU

 

　　42.title(self)

　　說明：返回"標題化"的字符串,就是說所有單詞的首個字母轉化為大寫，其余字母均為小寫；注意，默認是按空格來分單詞，也可以是其他特殊字符或數字。

　　語法：str.title()

　　返回值：返回"標題化"的字符串,就是說所有單詞的首字母都轉化為大寫。

　　實例：

>>> str1 = "Life is too short for python"
>>> print(str1.title())
Life Is Too Short For Python

 　　使用特殊字符或數字來區分：

>>> str1 = "zjk zjk*zjk&zjk^zjk@,zjk.zjk9zjk8zjk/zjk"
>>> print(str1.title())
Zjk Zjk*Zjk&Zjk^Zjk@,Zjk.Zjk9Zjk8Zjk/Zjk

 

　　43.translate(self, table)

　　說明：根據由maketrans函數生成的對照表table完成字符替換；

　　語法：str.tarnslate(table)

　　參數：table ---- 對照表，是由maketrans函數生成；

　　返回值：返回翻譯后的字符串；

　　實例：

>>> table = str.maketrans("zjk","666")
>>> str = "zjkqwert"
>>> print(str.translate(table))
666qwert

 

　　44.upper(self)

　　說明：將字符串中的小寫字母轉為大寫字母；

　　語法：str.upper()

　　返回值：返回小寫字母轉為大寫字母的字符串；

　　實例：

>>> str1 = "Life is too short for python"
>>> print(str1.upper())
LIFE IS TOO SHORT FOR PYTHON

 

　　45.zfill(self, width)

　　說明：返回指定長度的字符串，原字符串右對齊，前面填充0，若指定長度小於原字符串長度，則返回原字符串；

　　語法：str.zfill(width)

　　參數：width -------> 指定字符串的長度。原字符串右對齊，前面填充0;

　　返回值：返回指定長度的字符串；

　　實例：

>>> str = "zjkqwert"
>>> print(str.zfill(10))
00zjkqwert
>>> print(str.zfill(6))
zjkqwert