Python学习——Python 容器（列表，元组，字典，集合）

列表：  
列表非常适合利用顺序和位置定位某一元素，尤其是当元素的顺序或内容经常发生改变时。与字符串不同，列表是可变的。  
你可以直接对原始列表进行修改：添加新元素、删除或覆盖已有元素。在列表中，具有相同值的元素允许出现多次。  
使用[] 或者list()创建列表，列表可以由零个或多个元素组成，元素之间用逗号分开，整个列表被方括号所包裹：  
>>> empty_list = []  
>>> name = ['zhangsan','lisi','wangwu']  
>>> other_empty_list = list()  
>>> other_empty_list  []

list()将其他数据类型转换成列表：  
1.将字符串转换成列表  
>>> list('dog')  
['d','o','g']  
2.将元祖转换成列表  
>>> tuple = ('dog','cat','mouse')  
>>> list(tuple)  
['dog','cat','mouse']  
使用 split() 可以依据分隔符将字符串切割成由若干子串组成的列表：  
>>> birthday = '1/6/1952'  
>>> birthday.split('/')  
['1', '6', '1952']  
如果待分割的字符串中包含连续的分隔符，那么在返回的列表中会出现空串元素：  
>>> splitme = 'a/b//c/d///e'  
>>> splitme.split('/')  
['a', 'b', '', 'c', 'd', '', '', 'e']
 列表元素的获取与修改：  
>>> list = ['a','b','c','d','e',f']  
>>> list[0]  
'a'  
>>> list[-1]  
'f'  
>>> list[2:]  
['c','d','e','f']  
>>> list[::2]  
['a','c','e']  
>>> list[:-3]  
['a','b','c']  
>>> list[-3:]  
['d','e','f']  
>>> list[::-2]  
['f','d','b']
 #列表中包含列表  
>>> list1 = ['one','two','three','four']  
>>> list2 = ['cat','dog','mouse']  
>>> list3 = ['jack','tom','robet',5]  
>>> all_list = [list1,list2,'haha',list3]  
>>> all_list  
[['one','two','three','four'],['cat','dog','mouse'],'haha',['jack','tom','robet',5]]  
>>> all_list[0]  
['one','two','three','four']  
>>> all_list[0][1]  
'two' 
#列表值得替换  
>>> list =['a','c','b','d']  
>>> list[1] = 'L'  
>>> list  
['a','L','b','d']

 列表的常用操作：(以下所有操作默认在list列表下进行）  
list = ['one','two','three','four']

1.append()添加元素到尾部  
>>> list.append('five')  
>>> list  
['one','two','three','four','five']

2.extend() 或者 += 合并列表  
>>> other_list = ['tom','jack']  
>>> list.extend(other_list) 
>>> list  
['one','two','three','four','tom','jack']  
或者：  
>>> list += other_list  
>>> list  
['one','two','three','four','tom','jack']

3.insert()在指定位置插入元素  
>>> list.insert(3,'hu')  
>>> list  
['one','two','three','hu','four']  
>>> list.insert(10,'hu')  
>>> list  
['one','two','three','four','hu']

4.del 删除指定位置的元素  
>>> del list[1]  
>>> list  
['one','three','four']  
>>> del list[-1]  
>>> list  
['one','two','three']

5.remove()删除指定值得元素  
>>> list.remove('two')  
>>> list  
['one','three','four']

6.pop()获取并删除指定位置的元素  
使用 pop() 同样可以获取列表中指定位置的元素，但在获取完成后，该元素会被自动删除。  如果你为 pop() 指定了偏移量，它会返回偏移量对应位置的元素；
如果不指定，则默认使 用 -1 。  因此， pop(0) 将返回列表的头元素，而 pop() 或 pop(-1) 则会返回列表的尾元素：  
>>> list.pop()  
'four'  
>>> list  
['one','two','three'] 

7.index() 查询具有特定值的元素的位置  
>>> list.index('three')  
2 

8.in 判断值是否存在  
>>> 'two' in list  
True  

9.count()记录特定值出现的次数  
>>> list.count('one')  
1  
>>> list.count('five')  
0  

10.join()转换为字符串  
>>> ','.join(list)  
'one,two,three,four'  
PS:的调用顺序：join() 是 split() 的逆过程  
>>> c='ab,cd,ef'  
>>> c.split(',')  
['ab','cd','ef']  
>>> ','.join(c)  
'ab,cd,ef'  

11.sort()重新排列元素  
列表方法 sort() 会对原列表进行排序，改变原列表内容；  通用函数 sorted() 则会返回排好序的列表副本，原列表内容不变。  
如果列表中的元素都是数字，它们会默认地被排列成从小到大的升序。如果元素都是字符串，则会按照字母表顺序排列：  
>>> list.sort()  
>>> list  
['foue','one','three','two']
 有些时候甚至多种类型也可——例如整型和浮点型——只要它们之间能够自动地互相转换：  
>>> numbers = [2, 1, 4.0, 3]  
>>> numbers.sort()  
>>> numbers 
[1, 2, 3, 4.0]  
默认的排序是升序的，通过添加参数 reverse=True 可以改变为降序排列：  
>>> numbers = [2, 1, 4.0, 3]  
>>> numbers.sort(reverse=True)  
>>> numbers 
[4.0, 3, 2, 1]
 list_copy是一个副本，它的创建并不会改变原始列表的内容：  
>>> list_copy = sorted(list)  
>>> list_copy  
['foue','one','three','two'] 

12.len() 获取列表长度  
>>> list.len()  
4  

13.copy()函数复制列表  
列表叫作 a，然后利用 copy() 函数创建 b ，利用 list() 函数创建 c，并使用列表分片创建 d ：  
>>> a = [1, 2, 3]  
>>> b = a.copy()  
>>> c = list(a)  
>>> d = a[:]  
b、 c 、 d 都是 a 的复制：它们是自身带有值的新对象，与原始的 a 所指向的列表对象 [1, 2, 3] 没有任何关联。  改变 a 不影响 b 、 c 和 d 的复制：  
>>> a[0] = 'integer lists are boring'  
>>> a  
['integer lists are boring', 2, 3]  
>>> b  
[1, 2, 3]  
>>> c  
[1, 2, 3]  
>>> d  
[1, 2, 3]

 元组:  
与列表类似，元组也是由任意类型元素组成的序列。与列表不同的是，元组是不可变的，这意味着一旦元组被定义，  将无法再进行增加、删除或修改元素等操作。
因此，元组就像是一个常量列表。  使用（）创建元组  
>>> empty_tuple = ()  
>>> empty_tuply  
()  
创建包含一个或多个元素的元组时，每一个元素后面都需要跟着一个逗号，即使只包含一个元素也不能省略：  
>>> one_marx = 'Groucho',  
>>> one_marx  ('Groucho',)  
PS:如果创建的元组所包含的元素数量超过 1，最后一个元素后面的逗号可以省略.     
Python的交互式解释器输出元组时会自动添加一对圆括号。你并不需要这么做——定义元组真正靠的是每个元素的后缀逗号     
但如果你习惯添加一对括号也无可厚非。可以用括号将所有元素包裹起来，这会使得程序更加清晰：
 可以将元组赋值给多个变量：  
>>> tuple = ('one','two','three')  
>>> a,b,c = tuple  
>>>a  
'one'  
>>>b  
'two'  
>>>c  
'three'  
这个过程叫做元组解包

 元组可以对多个变量的值进行交换而不需要利用中间值：  
>>> tuple1 = ('first',)  
>>> tuple2 = ('last',) 
>>> tuple1,tuple2 = tuple2,tuple1  
>>> tuple1  
'last'  
>>> tuple2  
'first'

 tuple() 函数可以用其他类型的数据来创建元组：  
>>> marx_list = ['Groucho', 'Chico', 'Harpo']  
>>> tuple(marx_list)  
('Groucho', 'Chico', 'Harpo')

 字典:  
字典 （dictionary）与列表类似，但其中元素的顺序无关紧要，因为它们不是通过像 0 或 1 的偏移量访问的。  取而代之，每个元素拥有与之对应的互不相同的 键 （key），
需要通过键来访问元素。  键通常是字符串，但它还可以是 Python 中其他任意的不可变类型：布尔型、整型、浮点型、元组、字符串等等。  
字典是可变的，因此你可以增加、删除或修改其中的键值对。  用大括号{}将一系列以逗号隔开的 键值对 （ key:value）包裹起来即可进行字典的创建。
最简单的字典是空字典，它不包含任何键值对.  
>>> empty_dict = {}  
>>> empty_dict  {}
 字典的常用操作:  
dict = {          
'one':'1',          
'two':'2',          
'three':'3',          
} 

1.dict()转换为字典  
可以用 dict() 将包含双值子序列的序列转换成字典。  
（你可能会经常遇到这种子序列，例如“Strontium，90，Carbon，14”或者“Vikings，20，Packers，7”，等等。）  每个子序列的第一个元素作为键，第二个元素作为值。  
>>> lol = [ ['a', 'b'], ['c', 'd'], ['e', 'f'] ]  
>>> dict(lol)  
{'c': 'd', 'a': 'b', 'e': 'f'}  
>>> tos = ( 'ab', 'cd', 'ef' )  
>>> dict(tos)  
{'c': 'd', 'a': 'b', 'e': 'f'} 

2.[key]添加或者修改元素  
>>> dict['one'] = 'A'  
>>> dict  
{'one':'A', 'two':'2','three':'3',}
>>> other = {'four':'4','five':'5'}  
>>> dict.update(other)  
>>> dict  
{'one':'A', 'two':'2','three':'3','four':'4','five':'5'}  
PS:如果待添加的字典与待扩充的字典包含同样的键,新归入字典的值会取代原有的值：  
>>> first = {'a': 1, 'b': 2}  
>>> second = {'b': 'platypus'}  
>>> first.update(second)  
>>> first  
{'b': 'platypus', 'a': 1} 

3.del 删除具有指定键的元素  
>>> del dict['one']  
>>> dict  
{'two':'2','three':'3',} 

4.clear()删除所有元素  
>>> dict.clear()  
>>> dict  {} 

5.in 判断是否存在(只能判断键，不能判断值）  
>>> 'one' in dict  
True  
>>> '1' in dict  
False  

6.使用[key]获取元素  
>>> dict['one']  
'1'  
PS:使用字典函数get()也可以获取元素  
>>> dict.get('one')  
'1'  

7.keys()获取所有键  
>>> dict.keys()  
dict_keys(['one','two','three'])  
PS:在 Python 2 里， keys() 会返回一个列表，而在 Python 3 中则会返回 dict_keys()，它是键的迭代形式。     
只能调用list() 将 dict_keys 转换为列表类型。  
>>> list(dict.keys())  
['one','two','three']  

8.使用values()获取所有值  
>>> list(dict.values())  
['1','2','3']  

9.items()获取所有的键值对  字典 items() 方法以列表返回可遍历的(键, 值) 元组数组  
>>> dict.items()  
dict_items([('one','1'),('two','2'),('three','3')])  
>>> list(dict.items())  
[('one','1'),('two','2'),('three','3')]  
每个键值对以元组的形式返回。

 集合：  
集合 就像舍弃了值，仅剩下键的字典一样。键与键之间也不允许重复。与字典的键一样，集合是无序的。
 集合的常见操作： 

1.使用set()创建集合  
>>> empty_set = set()  
>>> empty_set  set()  

2.使用set()将其他类型转换成集合  
你可以利用已有列表、字符串、元组或字典的内容来创建集合，其中重复的值会被丢弃。  
>>> set('letters')  {'l','e','t','r','s'}  
注意，上面得到的集合中仅含有一个 'e' 和一个 't'，尽管字符串 'letters' 里各自包含两个。  
>>> set( ['Dasher', 'Dancer', 'Prancer', 'Mason-Dixon'] )  
{'Dancer', 'Dasher', 'Prancer', 'Mason-Dixon'}  
>>> set( ('Ummagumma', 'Echoes', 'Atom Heart Mother') )  
{'Ummagumma', 'Atom Heart Mother', 'Echoes'}  
当字典作为参数传入 set() 函数时，只有键会被使用：  
>>> set( {'apple': 'red', 'orange': 'orange', 'cherry': 'red'} )  
{'apple', 'cherry', 'orange'}