??方法是與對象有緊密聯系的函數，對象可能是列表、數字，也可能是字符串或其他類型的對象。
??方法的定義方式是將對象放到方法名之前，兩者之間用一個點號隔開，方法后面的括號中可以根據需要帶上參數。調用語法如下：
　　對象.方法()
??在python中，一切皆對象

一、列表的常用方法

>>> dir(list)   #查看方法(沒有返回值)和魔法方法(或者特殊方法，暫時理解為屬性，有返回值)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__',
　　 '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__','__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__',
　　 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

??雙下劃線的是魔法方法(面向對象才學)，后面的是方法

>>> help(list.方法名)　 #查看具體的方法或屬性 箭頭表示返回類型

1. L.append(obj)

>>> help(list.append)

??L.append(object) -> None -- append object to end
??在列表的末尾添加新的對象,無返回值

>>> li.append(3) 　　#添加3到末尾 
>>> li 　　#[1, 2, 3]

2. L.clear()

??L.clear() -> None -- remove all items from L
??清除所有items(項),返回None

>>> li.clear()　　#[]

3. L.copy()

??L.copy() -> list -- a shallow copy of L　　
??復制一個列表，返回一個列表

>>> li2=li.copy() 　　#拿li2接收 這兩個對象是不一樣的，雖然內容一樣
>>> id(li)　　　　#1779135890632
>>> id(li2)　　　　#1779135891848

4. L.count(obj)

??L.count(value) -> integer -- return number of occurrences of value　　
??記指定元素在列表中出現的次數，返回一個整型

>>> li.count(1)　　#1

5. L.extend(obj)

??L.extend(iterable) -> None -- extend list by appending elements from the iterable
??用于在列表末尾一次性追加另一個序列中的多個值(用新obj擴展原來的列表)
序列類型都是可迭代的

>>> li.extend([1])　　#[1, 2, 3, 1]
>>> dir(li) 　　 #__iter__  有這個就是可迭代的

??extend()和append()的區別就是

>>> li.extend([1])  #[1, 2, 3, 1]
>>> li.append([1,2,3])   #[1, 2, 3, 1, [1, 2, 3]]

??還可以用分片賦值實現相同的結果

>>> a=['hello','world']
>>> b=['python','is','funny']
>>> a[len(a):]=b　　#['hello', 'world', 'python', 'is', 'funny']
>>> a+b     #['hello', 'world', 'python', 'is', 'funny']
>>> a           #['hello','world']

??extend()方法和序列相加的主要區別是：extend()方法修改了被擴展的序列，如前面的；原始原始額的連接操作會返回一個全新的列表，如上面的示例，返回的是一個包含a和b副本的新列表，而不會修改原始的變量。

6. L.index(obj)

??L.index(value, [start, [stop]]) -> integer -- return first index of value.Raises ValueError if the value is not present.
??用于從列表中查找指定值第一次出現的索引。

>>> li2.index(1) #返回這個value第一次出現的位置

??默認是從0開始到末尾，但也可以指定：
??L.index(value, [start, [stop]])，其中括號是可選參數

>>> li2.index(1,2) #從2位置開始找1,默認到末尾
>>> li2.index(1,2,5) #中括號時可選參數
>>> li2.index(10)
ValueError: 4 is not in list

??如果輸入不在列表里的元素就會報錯

7. L.insert(index,obj)

??L.insert(index, object) -- insert object before index
??將一個對象插入列表，可以指定位置。

>>> li2.insert(3,'lucky')　　#在3的位置插入

??也可以和extend()一樣用分片賦值實現

>>> li2[2:2]=['ssss']　　#['a', 'b', 'ssss', 'd', 'c']

8. L.pop(index)

??L.pop([index]) -> item -- remove and return item at index (default last).　　Raises IndexError if list is empty or index is out of range.　　
??用于移除列表中的一個元素(默認是最后一個元素)，并且返回該元素的值，可以指定位置。index默認是L[-1]

>>> li2.pop() #有返回值，也改變了列表，把列表中的最后一個元素拋出來，默認刪除最后一個元素
>>> li2.pop(2) #也可以指定索引刪除

??pop方法是惟一一個既能修改又能返回元素值(除了None)的列表方法。
??使用pop方法可以實現一種常見的數據結構--棧。
??棧的原理就像堆放盤子一樣，一次操作一個盤子，要將若干盤子堆成一堆，只能在一個盤子的上面放另一個盤子；要拿盤子時，只能從頂部一個一個往下拿，最后放入的盤子是最先被拿的。棧也是這樣，最后放入棧的最先被移除，稱為LIFO(last in first out)，即后進先出
??棧中的放入和移除操作有統一的稱謂---入棧(push)和出棧(pop)。Python中沒有入棧方法，但可以使用append方法代替。

9. L.remove(obj)

??L.remove(value) -> None -- remove first occurrence of value. Raises ValueError if the value is not present.　　
??移除列表中第一個為指定值的元素，沒有返回值,只刪除了第一次出現重復的元素,第二次之后出現的值沒有被移除。
??刪除沒有的元素會報錯，告知移除的對象不在列表中。

>>> li2.remove('ssss')　　#['a', 'b', 'd', 'c']
>>> li2.remove('ss')　　#ValueError: list.remove(x): x not in list

??有一點需要了解的是：remove是一個沒有返回值的原位置元素變更方法，它修改了列表卻沒有返回值，與pop方法正好相反。

10. L.reverse()

***??L.reverse() -- reverse *IN PLACE****　　
??用于反向列表中的元素。

>>> li2.reverse()　　#['c', 'd', 'b', 'a']

??該方法改變了列表但不返回值。
??如果需要對一個序列進行反向迭代，那么可以使用reversed函數。這個函數并不返回列表，而是返回一個迭代器對象，可以通過list函數把返回的對象轉換為列表。

>>> num=[1,2,3]
>>> reversed(num)　　　　
#<list_reverseiterator object at 0x0000025455BAC390>
>>> list(reversed(num))　　#[3,2,1]

11. L.sort()

***??L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE**** 　　
??對原列表進行排序，如果指定參數(key = len)，就使用參數指定的比較方法進行排序。默認升序排序，無返回值(返回None)。

>>> li=[2,1,5,6,3]
>>> li.sort()　　 #必須是同種類型的才可以排序
>>> li2=['a','b','d','c'] 　　#默認根據ASCII碼排序
>>> li4=['b','ab','a']　　
>>> li4.sort()　　　　 #['a', 'ab', 'b']
>>> li4.sort(key=len)  　　 #['a', 'b', 'ab']
>>> li4.sort(key=len,reverse=True)   　　#['ab', 'a', 'b']

??當用戶需要一個排好序的列表副本，同時又保留原有列表不變時，是先把這個列表的副本賦值給另一個列表，然后對另一個列表進行排序。
如reverse方法一樣，sort方法也有一個同樣功能的函數—sorted函數。該函數可以直接獲取排序后的列表的副本。

>>> num=[5,8,1,3,6]
>>> n=sorted(num)   #[1,3,5,6,8]

??Sorted函數可以用于任何序列，返回結果是一個列表。

12. L.clear()

??L.clear() -> None -- remove all items from L
??清空列表，類似于 del a[:],清空完變為[]
??也類似于切片賦值a[:]=[]

>>> field=[1,2,3]
>>> field.clear()       #[]

13. L.copy()

??L.copy() -> list -- a shallow copy of 　　
??復制列表，類似于a[:]

>>> li=[1,2,3]
>>> li1=li.copy()   #[1, 2, 3]
>>> id(li)　　#2561239466632
>>> id(li1)　　#　　2561239617672

??復制完后是兩個對象，內容一樣。但是，地址不一樣，這叫淺復制。只是將另一個名稱關聯到列表。

二、元組的常用方法

1. count()

??T.count(value) -> integer -- return number of occurrences of value　　
??記某一元素在元組中出現的次數,返回一個整型

2. index()

??T.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present.　　
??用于從元組中找出某個值第一個匹配項的索引第一次出現的位置

三、字符串的常用方法

　　dir(str)
'''
'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. s.count(x)

??s.count(sub[, start[, end]]) -> int　[, start[, end]]代表可選參數，start為開始索引，end為結束索引
??返回字符串 x 在 s 中出現的次數，帶可選參數

>>> s='asdfasdf'
>>> s.count('a')　　#2

2. s.endswith(x)

??s.endswith(suffix[, start[, end]]) -> bool　　
??檢測是否以某個字符串結束，可以指定范圍，返回一個bool值

>>> s.endswith('f')   #返回一個bool型，字符串是否以''結束  True

3. s.startswith(x)

??s.startswith(prefix[, start[, end]]) -> bool　　
??檢測是否以某個字符串開始，可以指定范圍，返回一個bool值

>>> s.startswith('ff')  #返回一個false

4. s.find(str)

??s.find(sub[, start[, end]]) -> int　　
??用于檢測字符串中是否包含子字符串str，如果包含子字符串，就返回子串的第一個字符第一次出現的索引，否則返回-1，跟列表的index()(會報錯)不一樣。如果指定start和end范圍，就檢查是否包含在指定范圍內，這個范圍包含起點，但不包含終點。

>>> field='do it now'
>>> field.find('do')　　  #0
>>> field.find(' ')　　       #2
>>> field.find('do',2)　 #-1
>>> field.find('python')　　#-1
>>> field.index('z')        #ValueError: substring not found

??我們再垃圾郵件過濾器中檢查主題是否包含$$$。這種檢查也可用find來執行。

5. s.index(x)：

??s.index(sub[, start[, end]]) -> int　　
??返回字符串中出現x的最左端的索引值，如果不在則拋出valueError異常

>>> field='do it now'
>>> field.index('do')　　#0
>>> field.find('python')　　#SyntaxError: EOL while scanning string literal

6. s.isalpha ()

??s.isalpha() -> bool
??測試是否全是字母，都是字母則返回 True,否則返回 False.

>>> s.isalpha() 　　#測試是否全是字母
>>> s2='12321654'
>>> s2.isalpha() 　　 #False
>>> s2='aaaaaa我'
>>> s2.isalpha() 　　 #True

7. s.isdigit ()

??s.isdigit() -> bool
??測試是否全是正整數字，都是數字則返回 True 否則返回 False.負數和小數都返回False

>>> s.isdigit()　　 #測試是否為全數字
>>> s3='-123'　　#負數被默認為字符串
>>> s.isdigit()　　 #False
>>> s3='123' 
>>> s.isdigit() 　　 #True

8. s.islower ()

??s.islower() -> bool
??測試是否全是小寫

9. s.isupper ()

??s.isupper() -> bool
??測試是否全是大寫

10. s.lower ()

??s.lower() -> str　　
??將字符串轉為小寫,原對象沒有變。返回結果為轉換為小寫后生成的字符串。

>>> s='ASDASDaa'
>>> s.lower()　　#'asdasdaa'

??如果想要在一個字符串中查找某個子字符串并忽略大小寫，即字符串全部轉換為小寫后能找到對應子串。

>>> field=' DO IT NOW '
>>> field.find('It')　　#-1
>>> a=field.lower()     # ' do it now '
>>> field.lower().find('It'.lower())　　#3

11. s.upper ()

??s.upper() -> str　　
??將字符串轉為大寫,原對象沒有變。返回結果為轉換為大寫后生成的字符串。

>>> field='do it now'
>>> field.find('It')　　#-1
>>> a=field.upper()     # 'DO IT NOW'
>>> field.upper().find('It'.upper())　　#3

??如果想要在一個字符串中查找某個子字符串并忽略大小寫，即字符串全部轉換為大寫后能找到對應子串

12. s.replace (old,new)

??s.replace(old, new[, count]) -> str　　
??把字符串中的old(舊字符串)全部替換成new(新字符串)，如果指定第3個參數count，替換次數就不超過max次，替換從左到右。返回替換后的結果。

>>> field　　'do it now'
>>> field='do it now,do it now'
>>> field.replace('do','Just do')　　#'Just do it now,Just do it now'
>>> field.replace('do','Just do',1)　　#'Just do it now,do it now'

13. s.split(str)

??s.split(sep=None, maxsplit=-1) -> list of strings　　
??通過指定分隔符對字符串進行切片。sep和maxsplit為默認參數，sep是將要分割的字符串；maxsplit是說明最多要分割幾個, 默認-1為全部切。返回為分割后的字符串列表。如果沒有指定分隔符，將默認在單個或多個連續的空白字符(空格、制表符、換行符等)處進行拆分。

>>> field　　#'do it now,do it now'
>>> field.split()　　#['do', 'it', 'now,do', 'it', 'now']
>>> s='aaaa'
>>> s.split() 　　 #['aaaa'] 返回一個列表
>>> field.split('o',1)　　#['d', ' it now,do it now']
>>> field.split('o',2)　　#['d', ' it n', 'w,do it now']

14. s.join()

??s.join(iterable) -> str
??將序列中的元素以指定字符連接成一個新字符串。Iterable表示要連接的元素序列。返回結果為指定字符連接序列中元素后生成的新字符串。作用與split相反。

>>> field=['1','2','3','4']
>>> mark='+'
>>> mark.join(field)　　#'1+2+3+4'
>>> field.join(mark)　　#list沒有join方法
#AttributeError: 'list' object has no attribute 'join'
>>> num=[1,2,3,4]
>>> mark.join(num)  
#TypeError: sequence item 0: expected str instance, int found

??進行join操作調用和被調用的對象必須都是字符串，任意一個不是字符串的都會報錯

15. s.swapcase()

??s.swapcase() -> str
??用于對字符串的大小寫字母進行轉換，將字符串中大寫轉換為小寫，小寫轉換成大寫。返回結果為大小寫字母轉換后生成的新字符串。

>>> s1='adsfASD'
>>> s1.swapcase()　　#'ADSFasd'

16. s.strip()

??s.strip([chars]) -> str
??用于移除字符串頭尾指定的字符(默認為空格)，中間的不會被刪除。返回結果為移除字符串頭尾指定的字符生成的新字符串。

>>> field='----do --it-- now----'
>>> field.strip('-')　　#'do --it-- now'

17. s.translate()

??s.translate(table) -> str
??根據參數table給出的表轉換字符串的字符，將要過濾掉的字符放到del參數中。Table代表翻譯表，通過maketrans方法轉換而來。
??方法translate與replace一樣替換字符串的特定部分，但不同的是它只能進行單字符替換。這個方法的優勢在于能夠同時替換多個字符，因此效率比replace高。
??這個方法的用途很多(如替換換行符或其他平臺而異的特殊字符)，但這里只介紹一個簡單的示例。假設你要將一段英語文本轉換為帶有德國口音的版本，為此必須將字符c和s分別替換為k和z。
??然而，使用translate錢前必須創建一個轉換表。這個轉換表指出了不同Unicode碼點之間的轉換關系。要創建轉換表，可對字符串類型str調用方法maketrans，這個方法接受兩個參數：兩個長度相同的字符串，它們指定要將第一個字符串中的每個字符都替換為第二個字符串中的相應字符。

>>> intab='adfas'
>>> outtab='12345'
>>> trantab=str.maketrans(intab,outtab)
# {97: 52, 100: 50, 102: 51, 115: 53}

??如果愿意，可查看轉換表的內容，但你看到的只是Unicode碼點之間的映射。

>>> st='just do it'
>>> st.translate(trantab)　　#'ju5t 2o it'

??調用方法maketrans時，還可提供可選的第三個參數，指定要將哪些字母刪除。

>>>table=str.maketrans('cs','kz','')
>>>'an incredible test'.translate(table)    #'aninkredibletezt'

18. s.center()

??s.center(width[, fillchar]) -> str
??通過在兩邊添加填充字符(默認為空格)讓字符串居中。

>>> 'The Middle by Jimmy Eat World'.center(39)
>>> '     The Middle by Jimmy Eat World     '
>>> 'The Middle by Jimmy Eat World'.center(39,'*')
>>> '*****The Middle by Jimmy Eat World*****'s

四、Python3字符串方法