一、元组中常用的方法
元组-->tuple(),经常用到的方法有两个
1.count()方法
>>> help(tuple.count) Help on method_descriptor: count(...) T.count(value) -> integer -- return number of occurrences of value
这个方法只向count()的括号里面传入一个参数，会返回一个整数，这个整数就是传入的参数值在元组里出现的次数，如下：
>>> tu_1=("alex","weishaopeng","a","b","c","w") >>> tu_1.count("w") 1 >>> tu_1.count("e") 0 >>> tu_1.count("alex") 1 >>> tu_1.count("a") 1
上面的代码可以看到，当我们传入w,e,a时，它们的出现次数都是返回1，这就可以看出，元组在计算一个字母在它的所有元素中出现的次数，最小颗粒度是以元素为单位，而不是以元素里面的字母等其他值为颗粒单位，这个必须注意
2.index()方法
>>> help(tuple.index) Help on method_descriptor: index(...) T.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present.
这段源码可以看到我们用index()方法时可以向index()里面传入三个参数，第一个是你要查找的这个值，第二、第三个分别是开始和结束的位置。第二、第三个参数可以不传，当它会返回一个整数，就是传入的那个值在元组里首先出现的位置
>>> tu_1=("alex","weishaopeng","a","b","c","w") >>> tu_1.index("w") 5 ValueError: tuple.index(x): x not in tuple >>> tu_1.index("a",0,5) 2 >>> tu_1.index("w",0,5) Traceback (most recent call last): File "<pyshell#14>", line 1, in <module> tu_1.index("w",0,5) ValueError: tuple.index(x): x not in tuple >>> tu_1.index("w",0,6) 5 >>> tu_1.index("alex",0) 0
从上面的代码可以看出，这个方法执行的最小颗粒度也是元素，当只传第一、二个元素 ，不传第三个时，表示查找这个传入的元素在元组中出现的位置，从第二个参数指定的位置开始直到结尾
二、列表中常用的方法
首先定义一个列表list_1=["a","b","c",1,2,3]
1.append()方法
Help on method_descriptor:
append(...)
L.append(object) -> None -- append object to end
通过源码可以看到，这个方法主要是往列表里添加对象，当执行这个方法时，要往括号里传入要添加的对象，方法执行后不返回值，要添加的对象将添加在列表最后的位置
>>> list_1=["a","b","c",1,2,3] >>> list_1.append(4) >>> list_1 ['a', 'b', 'c', 1, 2, 3, 4] >>> list_1.append("a") >>> list_1 ['a', 'b', 'c', 1, 2, 3, 4, 'a'] >>> list_1.append(1) >>> list_1 ['a', 'b', 'c', 1, 2, 3, 4, 'a', 1]
可以看到，列表里面的元素类型没有限制，可以往列表里添加相同的元素，添加的元素在列表的最后的位置
2.clear（）方法
>>> help(list.clear) Help on method_descriptor: clear(...) L.clear() -> None -- remove all items from L
这个方法主要用来清空列表里的所有元素，但是列表本身并不会被删除
>>> list_1.clear() >>> list_1 [] >>> del list_1 >>> list_1 Traceback (most recent call last): File "<pyshell#30>", line 1, in <module> list_1 NameError: name 'list_1' is not defined
可以看到当执行完这个方法后，列表list_1里面的所有元素都被清空了，然后输出list_1，变成一个空列表，但是列表还存在，当用del list_1的时候，才把整个列表删除，此时再输出list_1，就会报错，指出名为list_1 的列表没有被定义过
3.copy（）方法
>>> help(list.copy)
Help on method_descriptor:
copy(...)
L.copy() -> list -- a shallow copy of L
这个就是 列表的浅拷贝方法，如下是应用方法应用
>>> list_2=list_1.copy() >>> list_2 ['wsp', 'b', 'c', 1, 2, 3] >>> list_1[0]="bill" >>> list_1 ['bill', 'b', 'c', 1, 2, 3] >>> list_2 ['wsp', 'b', 'c', 1, 2, 3]
3.count（）方法 #共同方法
这个方法应用跟元组的一样，这里不再赘述
4.extend（）方法
>>> help(list.extend) Help on method_descriptor: extend(...) L.extend(iterable) -> None -- extend list by appending elements from the iterable >>> list1=['wsp', 'b', 'c', 1, 2, 3] >>> list2=['bill', 'b', 'c', 1, 2, 3] >>> list1.extend(list1) >>> list1 ['wsp', 'b', 'c', 1, 2, 3, 'wsp', 'b', 'c', 1, 2, 3] >>> tuple1=("a","b") >>> list1.extend(tuple1) >>> list1 ['wsp', 'b', 'c', 1, 2, 3, 'wsp', 'b', 'c', 1, 2, 3, 'a', 'b'] >>> s1="alex" >>> list1.extend(s1) >>> list1 ['wsp', 'b', 'c', 1, 2, 3, 'wsp', 'b', 'c', 1, 2, 3, 'a', 'b', 'a', 'l', 'e', 'x'] >>> bian=1 >>> list1.extend(bian) Traceback (most recent call last): File "<pyshell#66>", line 1, in <module> list1.extend(bian) TypeError: 'int' object is not iterable
这个方法是用来拓展列表的，当调用这个方法的时候，往extend()方法的括号里面传入的必须是可迭代的，当传入的是列表、元组、字符串时都可以，传入的是一个整型变量时就不可以了
5.index（）#这个方法也跟元组的运用一样，共同方法
6.insert（）方法
>>> help(list.insert)
Help on method_descriptor:
insert(...)
L.insert(index, object) -- insert object before index
这个方法是用来在指定的索引位置，插入一个对象，所有传入的参数有两个，而且必须传，index就是索引位置，object就是要插入的对象，操作演示如下：
>>> list1=["a","b"] >>> list1.insert(1,"c") >>> list1 ['a', 'c', 'b'] >>> list1.insert(4,"d") >>> list1 ['a', 'c', 'b', 'd'] >>> list1.insert(8,"e") >>> list1 ['a', 'c', 'b', 'd', 'e']
可以看到，第二行代码语句，在索引位置1就是列表的第2个位置插入对象"c"，当索引序号超过本列表的长度时，默认往最后面插入这个对象
7.pop()方法
>>> help(list.pop) Help on method_descriptor: pop(...) L.pop([index]) -> item -- remove and return item at index (default last). Raises IndexError if list is empty or index is out of range. >>> list1 ['a', 'c', 'b', 'd', 'e'] >>> list1.pop() 'e' >>> list1 ['a', 'c', 'b', 'd'] >>> list1.pop(0) 'a' >>> list1 ['c', 'b', 'd'] >>> list1.pop(1) 'b' >>> list1 ['c', 'd']
从源码和演示中我们可以看到，调用这个pop()方法时，就是用来移除列表里面的不想要的元素，如果不传入任何参数，那么默认就移除最后那个元素，并返回这个元素。如果要指定移除某个元素，就传入这个元素的索引下标位置
8.remove()方法
>>> help(list.remove) Help on method_descriptor: remove(...) L.remove(value) -> None -- remove first occurrence of value. Raises ValueError if the value is not present. >>> list1 ['c', 'd'] >>> list1=['a', 'c', 'b', 'd'] >>> list1.remove() Traceback (most recent call last): File "<pyshell#87>", line 1, in <module> list1.remove() TypeError: remove() takes exactly one argument (0 given) >>> list1.remove(0) Traceback (most recent call last): File "<pyshell#88>", line 1, in <module> list1.remove(0) ValueError: list.remove(x): x not in list >>> list1.remove("a") >>> list1 ['c', 'b', 'd'] >>> list1=["a","b","c","d","a"] >>> list1.remove("a") >>> list1 ['b', 'c', 'd', 'a']
从源码解释中可以看到，要调用这个remove()方法时（也是跟pop方法不同的地方）
1、必须传入参数
2.传入的参数必须是你要移除的那个元素，并不是那个元素的索引序号
9.reverse()方法
这个方法就是用来把列表倒序
>>> list1 ['b', 'c', 'd', 'a'] >>> help(list.reverse) Help on method_descriptor: reverse(...) L.reverse() -- reverse *IN PLACE* >>> list1.reverse() >>> list1 ['a', 'd', 'c', 'b']
10.sort()方法
#代码块1 >>> list1=[5,1,3,4,"a","k","f","c"] >>> list1.sort() Traceback (most recent call last): File "<pyshell#99>", line 1, in <module> list1.sort() TypeError: unorderable types: str() < int() >>> list1.sort(key=int) Traceback (most recent call last): File "<pyshell#100>", line 1, in <module> list1.sort(key=int) ValueError: invalid literal for int() with base 10: 'a' #代码块2 >>> list1=["a","k","f","c"] >>> list1.sort() >>> list1 ['a', 'c', 'f', 'k'] >>> list1=["a","k","f","c"] >>> list2=list1.sort() >>> list2 >>> list2=sorted(list1) >>> list2 ['a', 'c', 'f', 'k']
从代码块1可以看到，当列表中的元素的类型不只是一种类型，比如既包含整型，又包含字符串时，那么调用sort()方法实际执行不成功，这个方法里可以设置为key=len,reverse=True,表示就是会按字符串的长度来排序，而不是顺序，同时会倒叙排序。
从代码块2可以看到，当我们想把一个排序过的列表直接赋值给一个变量时，打印输出显示为空，比如list2，那么如何实现呢，此时要用到sorted()方法，在括号里传入要排序的列表
三、字典的常用方法
1.clear() #这个也是跟元组、列表中的clear方法一样，表示清空字典里的元素
>>> dic1={1:"a",2:"b",3:"c",4:"d"}
>>> dic1.clear()
>>> dic1
{}
2.copy（） #跟列表中的此类方法一样，用来复制某个列表
>>> dic1={1:"a",2:"b",3:"c",4:"d"}
>>> dic2=dic1.copy()
>>> dic2
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
>>> dic2[1]="k"
>>> dic2
{1: 'k', 2: 'b', 3: 'c', 4: 'd'}
>>> dic1
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
3.get()方法
>>> help(dict.get) Help on method_descriptor: get(...) D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. >>> dic1 = {'name': 'wsp', 'age': 27} >>> print ("Value : %s" % dic1.get('Age')) Value : 27 >>> print ("Value : %s" % dic1.get('Sex', "man")) Value : man
从源码可以看出，调用get()方法时，可以往括号里面传入两个参数，k是指字典的键， d是指如果你传入的键不存在，那么你可以指定一个默认值，就比如上面的倒数第二行代码语句一样，要传入键"Sex"，这个键在dic1 中是不存在的，但是它指定了默认值"man“,所以打印的时候就输出了此默认值
4.keys()#这个是返回字典的键
>>> help(dict.keys) Help on method_descriptor: keys(...) D.keys() -> a set-like object providing a view on D's keys >>> dic1.keys() dict_keys(['Age', 'Name'])
5.values() #用来返回字典的值
>>>dic1 = {'Name': 'wsp', 'Age': 27}
>>> dic1.values()
dict_values([27, 'wsp'])
6.items（）#用来返回字典的键值对
>>> dic1 = {'Name': 'wsp', 'Age': 27}
>>> dic1.items()
dict_items([('Age', 27), ('Name', 'wsp')])
7.pop() 方法
>>> help(dict.pop) Help on method_descriptor: pop(...) D.pop(k[,d]) -> v, remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised >>> dic1.pop("Name") 'wsp' >>> dic1 {'Age': 27} >>> dic1["Name"]="wsp" >>> dic1 {'Age': 27, 'Name': 'wsp'} >>> dic1.pop("sex","man") 'man' >>> dic1 {'Age': 27, 'Name': 'wsp'} >>> dic1.pop("school") Traceback (most recent call last): File "<pyshell#146>", line 1, in <module> dic1.pop("school") KeyError: 'school'
源码的意思是这个方法也是跟元组、列表中的pop方法一样，用来移除元素的，不同的是，括号里要传入的是字典的键，如果键不存在，如果指定了默认值，那么就执行成功，并返回指定的默认值，如果键不存在，也没有指定默认值，那么就会抛出KeyError的错误
8.fromkeys（）
首先定义一个迭代器，这里是一个元组
>>> tup1=('a', 'b', 'c')
>>> dic1=dict.fromkeys(tup1) >>> dic1 {'b': None, 'a': None, 'c': None} >>> dic1=dict.fromkeys(tup1,10) >>> dic1 {'b': 10, 'a': 10, 'c': 10}
>>> help(dict.fromkeys) Help on built-in function fromkeys: fromkeys(iterable, value=None, /) method of builtins.type instance Returns a new dict with keys from iterable and values equal to value.
当我们要往新字典添加键值对时，可以直接以元组里的元素为键，同时在fromkeys()方法的第二个参数指定一个值，那么新字典里的所有的键的值都是第二个参数指定的值
9.popitem()
>>> dic1={'Age': 27, 'Name': 'wsp'}
>>> dic1.popitem()
('Age', 27)
>>> dic1.popitem()
('Name', 'wsp')
>>> dic1
{}
>>> dic1.popitem()
Traceback (most recent call last):
File "<pyshell#154>", line 1, in <module>
dic1.popitem()
KeyError: 'popitem(): dictionary is empty'
这个方法是移除字典的键值对，移除的顺序从字典的第一个元素开始，如果字典为空，那么再执行此方法就会报字典为空的错误
10.setdefault()方法
>>> help(dict.setdefault) Help on method_descriptor: setdefault(...) D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D >>> a = { } #新建一个空字典 >>> a['name'] = 'wsp' #为字典添入参数 >>> a #输出字典a {'name': 'wsp'} >>> a.setdefault('name','alex') #因为键名name存在，则返回键对应的值‘wsp’ 'wsp' >>> a.setdefault('name1','alex') #因键名name1不存在，程序把('name1','alex')当做项添加到字典a中，并返回其值。 'alex' >>> a {'name': 'wsp', 'name1': 'alex'}
11.update()方法
>>> dic1={'Age': 27, 'Name': 'wsp'}
>>> dic2={'name': 'wsp', 'name1': 'alex'}
>>> dic1.update(dic2)
>>> dic1
{'name': 'wsp', 'Age': 27, 'Name': 'wsp', 'name1': 'alex'}
这个方法用来更新字典，从上面代码块可以看出，类似列表的extend()方法，就是把多个字典拓展添加到要更新的字典中去