Python学习笔记二：02序列类型的各自方法

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

方法名	描述
capitalize()	将字符串的第一个字符转换为大写
center(width, fillchar)	返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
count(str, beg= 0,end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
bytes.decode(encoding=“utf-8”, errors=“strict”)	Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
encode(encoding=‘UTF-8’,errors=‘strict’)	以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
endswith(suffix, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
expandtabs(tabsize=8)	把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
find(str, beg=0 end=len(string))	检测 str 是否包含在字符串中 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在字符串中会报一个异常.
isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
isalpha()	如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
isdigit()	如果字符串只包含数字则返回 True 否则返回 False…
islower()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False
isspace()	如果字符串中只包含空格，则返回 True，否则返回 False.
istitle()	如果字符串是标题化的(见 title())则返回 True，否则返回 False
isupper()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
join(seq)	以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
len(string)	返回字符串长度
ljust(width[, fillchar])	返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
lower()	转换字符串中所有大写字符为小写.
lstrip()	截掉字符串左边的空格
maketrans()	创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
replace(old, new[, max])	将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
rfind(str, beg=0,end=len(string))	类似于 find()函数，不过是从右边开始查找.
rindex( str, beg=0, end=len(string))	类似于 index()，不过是从右边开始.
rjust(width[, fillchar])	返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串
rstrip()	删除字符串字符串末尾的空格.
split(str="", num=string.count(str)) num=string.count(str))	以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串
splitlines([keepends])	按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
startswith(str, beg=0,end=len(string))	检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
strip([chars])	在字符串上执行 lstrip()和 rstrip()
swapcase()	将字符串中大写转换为小写，小写转换为大写
title()	返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
translate(table, deletechars="")	根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
upper()	转换字符串中的小写字母为大写
zfill (width)	返回长度为 width 的字符串，原字符串右对齐，前面填充0
isdecimal()	检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。