方法是与对象有紧密联系的函数，对象可能是列表、数字，也可能是字符串或其他类型的对象。
  方法的定义方式是将对象放到方法名之前，两者之间用一个点号隔开，方法后面的括号中可以根据需要带上参数。调用语法如下：
　　对象.方法()
  在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字符串方法