>>>li=[1,2,3]
>>>dir(li) #查看方法和属性
['__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) 用obj扩展原来的列表。
# L.extend(iterable) -> None -- extend list by appending elements from the iterable 用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
# 序列类型都是可迭代的
>>>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']
（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) #中括号时可选参数
（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) 出栈，可以指定位置。index默认是L[-1]
# L.pop([index]) -> item -- remove and return item at index (default last). Raises IndexError if list is empty or index is out of range.
# 用于移除列表中的一个元素（默认是最后一个元素），并且返回该元素的值
>>>li2.pop() #有返回值，也改变了列表，把列表中的最后一个元素抛出来，默认删除最后一个元素
>>>li2.pop(2) #也可以指定索引删除
#pop方法是惟一一个既能修改又能返回元素值（除了None）的列表方法。要将若干盘子堆成一堆，只能在一个盘子的上面放另一一个一个wangxiana个盘子；
#要拿盘子时，只能从顶部一个一个往下拿，最后放入的盘子是最先被拿的。栈也是这样，最后放入栈的最先被移除，称为LIFO（last in first out），即后进先出
#栈中的放入和移除操作有统一的称谓---入栈（push）和出栈（pop）
#使用pop方法可以实现一种常见的数据结构--栈。
#栈的原理就像是堆放一个盘子，
（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']
#该方法改变了列表但不返回值
（11）L.sort() 对原列表进行排序。列表中的元素要类型相同 (key = len)
# L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* 对原列表进行排序，如果指定参数，就使用参数指定的比较方法进行排序。默认升序排序
>>>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']
（11）L.clear() 清空列表，类似于 del a[:]
# L.clear() -> None -- remove all items from L
（12）L.copy() 复制列表
# L.copy() -> list -- a shallow copy of
>>> li=[1,2,3]
>>> li1=li.copy()
>>> li1 #[1, 2, 3]
>>> id(li) #2561239466632
>>> id(li1) # 2561239617672
#复制完后是两个对象，内容一样但是，地址不一样，这叫浅复制
内置函数：
sorted（） 和 reversed()
# sorted函数可以直接获取列表的副本进行排序
>>>num=[5,8,1,3,6,]
>>>n=sorted(num) #[1,3,,5,6,8]
#sorted函数可以用于任何序列，返回结果都是一个列表
>>>sorted('python') #['h', 'n', 'o', 'p', 't', 'y']
# reversed函数，可以对一个序列进行反向迭代。这个函数并不会返回列表，而是返回一个迭代器对象，可以通过list函数把返回的对象转换为列表。
>>>num=[1,2,3]
>>> reversed(num) #<list_reverseiterator object at 0x0000025455BAC390>
>>>list(reversed(num)) #[3,2,1]
T.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present. 用于从元组中找出某个值第一个匹配项的索引第一次出现的位置
内置函数：len(tuple),max(tuple),min(tuple)
'''
'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'
'''
s.count(x)：返回字符串 x 在 s 中出现的次数，带可选参数
# S.count(sub[, start[, end]]) -> int [, start[, end]]代表可选参数，start为开始索引，end为结束索引
>>>s='asdfasdf'
>>>s.count('a') #2
(2)s.endswith(x)：如果字符串s以x结尾，返回True
# S.endswith(suffix[, start[, end]]) -> bool 检测是否以某个字符串结束，可以指定范围，返回一个bool值
>>>s.endswith('f') #返回一个bool型，字符串是否以''结束 True
(3)s.startswith(x)：如果字符串s以x开头，返回True
# S.startswith(prefix[, start[, end]]) -> bool 检测是否以某个字符串开始，可以指定范围，返回一个bool值
>>>s.startswith('ff') #返回一个false
(4)s.find(x) ：返回字符串中出现x的最左端字符的索引值，如果不在则返回-1
# S.find(sub[, start[, end]]) -> int 用于检测字符串中是否包含子字符串str，查找元素的索引位置，第一次出现的索引，找不到的话就返回-1，跟index()（会报错）不一样
>>> field='do it now'
>>> field.find('do') #0
>>> field.find(' ') #2
>>> field.find('now') #6
>>> field.find('python‘) #-1
>>> field.index('z') #报错
#如果找到就返回首个字符串的索引，没有找到就返回-1
(5)s.index(x)：返回字符串中出现x的最左端的索引值，如果不在则抛出valueError异常
# S.index(sub[, start[, end]]) -> int
>>> field='do it now'
>>> field.index('do') #0
>>> field.find('python‘) #SyntaxError: EOL while scanning string literal
(6)s.isalpha () ：测试是否全是字母，都是字母则返回 True,否则返回 False.
# S.isalpha() -> bool
>>> s.isalpha() #测试是否全是字母
>>> s2='12321654'
>>> s2.isalpha() #False
>>> s2='aaaaaa我'
>>> s2.isalpha() #True
(7)s.isdigit () ：测试是否全是数字，都是数字则返回 True 否则返回 False.
# S.isdigit() -> bool
>>>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'
(11)s.upper () ：将字符串转为大写
# S.upper() -> str 有返回值的 原对象没有变
>>> field='do it now'
>>> field.find('It') #-1
>>> fild.upper().find('It'.upper())
>>> field.upper().find('It'.upper()) #3
如果想要在一个字符串中查找某个子字符串并忽略大小写，即字符串全部转换为大写后能找到对应子串
(12)s.replace (x,y) ：子串替换,在字符串s中出现字符串x的任意位置都用y进行替换
# 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()：返回一系列用空格分割的字符串列表
# S.split(sep=None, maxsplit=-1) -> list of strings -1为全部切 sep,maxsplit为默认参数，sep是将要分割的字符串，maxsplit是说明最多要分割几个,返回一个列表
>>> 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
>>> field=['1','2','3','4']
>>> mark='+'
>>> mark.join(field) #'1+2+3+4'
>>> field.join(mark) #list没有join方法
Traceback (most recent call last):
File "<pyshell#45>", line 1, in <module>
field.join(mark)
AttributeError: 'list' object has no attribute 'join'
>>> num=[1,2,3,4]
>>> mark.join(num)
Traceback (most recent call last):
File "<pyshell#47>", line 1, in <module>
mark.join(num)
TypeError: sequence item 0: expected str instance, int found
#进行join操作调用和被调用的对象必须都是字符串，任意一个不是字符串的都会报错
(14)s.swapcase():用于对字符串的大小写字母进行转换，将字符串中大写转换为小写，小写转换成大写
# S.swapcase() -> str
>>> s1='adsfASD'
>>> s1.swapcase() #'ADSFasd'
(15)s.strip(): 用于移除字符串头尾指定的字符（默认为空格）
# S.strip([chars]) -> str
>>> field='----do --it-- now----'
>>> field.strip('-') #'do --it-- now'
(16)s.translate(): 根据参数table给出的表转换字符串的字符，将要过滤掉的字符放到del参数中
# S.translate(table) -> str
>>> intab='adfas'
>>> outtab='12345'
>>> trantab=str.maketrans(intab,outtab)
>>> st='just do it'
>>> st.translate(trantab) #'ju5t 2o it'
| 1 | capitalize() 将字符串的第一个字符转换为大写 |
|---|---|
| 2 | center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| 3 | count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
| 4 | bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 |
| 5 | encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' |
| 6 | endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
| 7 | expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 |
| 8 | find(str, beg=0 end=len(string)) 检测 str 是否包含在字符串中 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 |
| 9 | index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常. |
| 10 | isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
| 11 | isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
| 12 | isdigit() 如果字符串只包含数字则返回 True 否则返回 False.. |
| 13 | islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| 14 | isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False |
| 15 | isspace() 如果字符串中只包含空格，则返回 True，否则返回 False. |
| 16 | istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| 17 | isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| 18 | join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| 19 | len(string) 返回字符串长度 |
| 20 | ljust(width[, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
| 21 | lower() 转换字符串中所有大写字符为小写. |
| 22 | lstrip() 截掉字符串左边的空格 |
| 23 | maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| 24 | max(str) 返回字符串 str 中最大的字母。 |
| 25 | min(str) 返回字符串 str 中最小的字母。 |
| 26 | replace(old, new[, max]) 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。 |
| 27 | rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找. |
| 28 | rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始. |
| 29 | rjust(width[,, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串 |
| 30 | rstrip() 删除字符串字符串末尾的空格. |
| 31 | split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串 |
| 32 | splitlines([keepends]) 按照行(' ', ' ', ')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
| 33 | startswith(str, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 |
| 34 | strip([chars]) 在字符串上执行 lstrip()和 rstrip() |
| 35 | swapcase() 将字符串中大写转换为小写，小写转换为大写 |
| 36 | title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
| 37 | translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
| 38 | upper() 转换字符串中的小写字母为大写 |
| 39 | zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
| 40 | isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |