python3_列表、元组、集合、字典

列表list##

#列表的基本操作
>>> a=[]                            #创建空列表
>>> a = [0,1,2,3,4,5]         #创建列表并初始化，列表是[]包含由逗号分隔的多个元素组成。
>>> a[0]                            #访问引索０位置的元素。
>>> a.append(6)              #添加元素到列表末尾 。
>>> a.extend([10,20])            #在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
>>> a.insert(0, 1) 　　　  #在列表索引 0 位置添加元素 1。
>>> a.remove(1)              #移除列表中指定元素。
>>> del a[-1]                    #删除列表引索-1位置元素。
>>> a.count(1)                 #返回列表中元素1的个数。
>>> a.reverse()                #反转整个列表。
>>> a.index(1)                #从列表中找出某个值第一个匹配项的索引位置
>>> a.sort()                      #列表排序。
>>> len(a)                        #列表长度
>>> [1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6]     #组合
>>> ['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!']             # 重复
>>> 3 in [1, 2, 3] True                               #元素是否存在于列表中
>>>  cmp(list1, list2)          #比较两个列表的元素
>>>  max(list)                    #返回列表元素最大值
>>> 	min(list)                    #返回列表元素最小值
>>>	list(seq)                    #将元组转换为列表

#将列表用作栈和队列
>>> a.pop()                      #弹出列表最后的元素，可作为栈使用
>>> a.pop(0)                    #弹出列表第一个元素，可作为队列使用

#列表推导式
>>> a=[1,2,3]
>>> z = [x + 1 for x in [x ** 2 for x in a]]
>>> z
[2, 5, 10]

#遍历列表（或任何序列类型）的同时获得元素索引值。
>>> for i, j in enumerate(['a', 'b', 'c']):
...     print(i, j)
...
0 a
1 b
2 c

#列表切片(slice notation)
>>> a = [0,1,2,3,4,5,6,7,8,9]
>>> b = a[1:3]                                  #b的内容是 [1,2]。
#a[i:j:s] 表示复制a[i]到a[j-1]，以生成新的list对象。
#当i缺省时，默认为0，即 a[:3]相当于 a[0:3]。
#当j缺省时，默认为len(alist), 即a[1:]相当于a[1:10]。
#当i,j都缺省时，a[:]就相当于完整复制一份a了。
#s表示步进，缺省为1。
#当s<0时，i缺省时，默认为-1. j缺省时，默认为-len(a)-1。
>>> a[::-1]                                       #相当于 a[-1:-len(a)-1:-1]。

元组tuple##

>>> a = (1, 2, 3, 4)                        #元组是由()包含的逗号分隔的多个元素组成。
>>> a = (123, )                              #要创建只含有一个元素的元组，在值后面跟一个逗号。
>>> del a                                       #删除元组
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');                        #修改元组
tup3 = tup1 + tup2;                        #元组加法

元组是不可变类型，不能在元组内删除或添加或编辑任何元素。但元组中列表的内容可以修改。

集合set##

集合是一个无序不重复元素的集。

>>> a = set()                                #想要创建空集合，你必须使用 set() 而不是 {}。后者用于创建空字典，我们在下一节中介绍的一种数据结构。
>>> a = {0,1,1,2,3,4,5}                 #重复的元素被去除
>>> １ in a                                   #判断集合中是否存在元素
True

# 演示对两个单词中的字母进行集合操作
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                          # a 去重后的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                                    # a 有而 b 没有的字母
{'r', 'd', 'b'}
>>> a | b                                    # 存在于 a 或 b 的字母
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                                   # a 和 b 都有的字母
{'a', 'c'}
>>> a ^ b                                   # 存在于 a 或 b 但不同时存在的字母
{'r', 'd', 'b', 'm', 'z', 'l'}

#从集合中添加或弹出元素：
>>> a = {0,1,2,3,4,5}
>>> a
{0, 1, 2, 3, 4, 5}
>>> a.pop()
0
>>> a.add(10)
>>> a
{1, 2, 3, 4, 5, 10}

字典dict##

字典是是无序的键值对（key:value）集合，同一个字典内的键必须是互不相同的。

>>> data = {}                                                        #一对大括号 {} 创建一个空字典。
>>> data = {'me':'apple','you':'banana'}               #初始化字典时，在大括号内放置一组逗号分隔的键：值对，这也是字典输出的方式。
>>> data['me']                                                     #使用键来检索存储在字典中的数据。
'apple'
>>> data['he'] = 'tomato'                                      #建新的键值。
>>> del data['he']                                                #删除任意指定的键值对。
>>> data.clear()                                                  #清空字典
>>> del data                                                       #删除整个字典
>>> 'me' in data                                                  #查询指定的键是否存在于字典中。
>>> dict.keys()                                                    # 以列表返回一个字典所有的键
>>> dict.copy()                                                    #返回一个字典的浅复制
>>> dict.fromkeys(seq[, val]))                             # 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
>>> dict.get(key, default=None)                          #返回指定键的值，如果值不在字典中返回default值
>>> dict.has_key(key)                                        # 如果键在字典dict里返回true，否则返回false
>>> dict.items()                                                   #以列表返回可遍历的(键, 值) 元组数组
>>> dict.keys()                                                    #以列表返回一个字典所有的键
>>> dict.setdefault(key, default=None)               #和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
>>> dict.update(dict2)                                        #把字典dict2的键/值对更新到dict里
>>> dict.values()                                                #以列表返回字典中的所有值
>>> pop(key[,default])                                       #删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
>>> popitem()                                                    #随机返回并删除字典中的一对键和值。

False

#由于字典中的键必须是不可变类型，所以不能使用列表作为键。
#从包含键值对的元组中创建字典。
>>> dict((('he','tomato'),('she','patoto')))
{'she': 'patoto', 'he': 'tomato'}

# 由字典转化为元组类表中只保存键
>>>print (tuple(data))
('me', 'you')
# 由字典转化为列表只保存键
>>> print (list(data))
['me', 'you']

＃遍历一个字典
>>> for x, y in data.items():
...  print("{} uses {}".format(x, y))
...
me uses apple
you uses banana

#判断这个元素是否存在，不存在则创建一个默认值。
>>> data
{'me': 'apple', 'you': 'banana'}
>>> data.setdefault('me', 'orange')
'apple'
>>> data.setdefault('he', 'tomato')
'tomato'
>>> data
{'me': 'apple', 'you': 'banana', 'he': 'tomato'}

#索引一个不存在的键将会抛出一个 keyError 错误。我们可以使用 dict.get(key, default) 来索引键，如果键不存在，那么返回指定的 default 值。
>>> data['it']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'it'
>>> data.get('it', orange)
orange

#同时遍历两个序列类型，你可以使用 zip() 函数。
>>> a = [0,1,2,3,4]
>>> b = [9,8,7,6,5]
>>> for x,y in zip(a,b):
...     print("x:{} & y: {}".format(x,y))
...
x:0 & y: 9
x:1 & y: 8
x:2 & y: 7
x:3 & y: 6
x:4 & y: 5