lst = [1,2,3,4,5]   # 列表使用[]声明，元素之间使用逗号分割  
# list.append(x) 向列表尾部添加一个元素，等价于a[len(a):] = x  
lst.append(6)   # lst:[1, 2, 3, 4, 5, 6]  
# list.extend(iterable) 将可迭代元素的每个元素依次添加到列表尾部  
lst.extend([7,8])   # lst:[1, 2, 3, 4, 5, 6, 7, 8]  
# list.insert(i,x) 向列表的第i个位置上插入元素x  
lst.insert(0,0)   # lst:[0, 1, 2, 3, 4, 5, 6, 7, 8]  
# list.remove(x) 删除列表中第一个等于x的元素，如果没有这种元素会引发ValueError  
lst.remove(0)  # lst:[1, 2, 3, 4, 5, 6, 7, 8]  
# list.pop([i]) 移除列表中第i个元素并返回这个元素，[]表示可选参数，若没有给出i，则删除并返回列表中最后一个元素  
lst.pop(6)  # 返回7，lst：[1, 2, 3, 4, 5, 6, 8]  
lst.pop()   # 返回8，lst:[1, 2, 3, 4, 5, 6]  
# list.reverse()  将列表的元素反转  
lst.reverse()   # lst：[6, 5, 4, 3, 2, 1]  
# list.index(x[,start[,end]]) 返回下标从0开始的第一个值等于x元素的下标，如果没有这个元素，则引发ValueError  
# start,end可选参数使用了切片的语法，用来限制索引范围  
lst.index(5)   # 返回1  
# list.count(x) 返回列表中x出现的次数  
lst.count(2)  # 返回1  
# list.sort(key=None,reverse=False) 将列表元素从小到大排序，排序的自定义参数可以参考sorted()的参数  
lst.sort()  #lst：[1, 2, 3, 4, 5, 6]  
# list.copy()  返回列表的一个浅复制，等价于a[:]  
# 浅复制不会复制子对象，所以，复制出来的对象和原对象并非完全不想关。  
# 深复制会递归的克隆子对象，所以，复制出来的对象和原对象完全不相关，但是深复制比浅复制会慢一些。  
lst.copy()   # 返回[1, 2, 3, 4, 5, 6]  
# list.clear() 清空列表，等价于del a[:]  
lst.clear()  # lst:[]  

stack = [1,2,3]   # 声明栈  
stack.append(4)   # 入栈 stack:[1, 2, 3, 4]  
stack.pop()  # 出栈，返回4  stack:[1, 2, 3]  
len(stack)   # 返回3 获取栈中数据元素的个数  

queue = [1,2,3]   # 声明队列  
queue.append(4)  # 入队列 queue:[1, 2, 3, 4]  
queue.pop(0)  # 出队列，返回1 queue:[2, 3, 4]  
len(queue)   # 返回3 获取队列中数据元素的个数  

from collections import deque  # 引入deque库  
queue = deque([1,2,3])  # 声明队列  
queue.append(4)  # 入队列，queue:deque([1, 2, 3, 4])  
queue.popleft()  # 出队列，返回1  queue:deque([2, 3, 4])  
len(queue)   # 返回3 获取队列中数据元素的个数  

from collections import deque  # 引入deque库  
data = {...}   # 这里假设遍历一个多层嵌套的字典  
queue = deque([])   # 声明队列  
queue.append(start)   # 根结点入队列  
while len(queue) > 0:  # 当队列非空时进行操作  
    top = queue.popleft()   # 队首元素出队列  
    # ... 进行BFS的一些相关操作  
    for child in top['child']:   # 将当前节点所有子节点入队列  
        queue.append(child)  

a = [1,2,3,4,5,6]  
del a[0]   # 删除元素a[0] ,a:[2, 3, 4, 5, 6]  
del a[1:3]  # 删除a[1:3],a:[2, 5, 6]  
del a[:]  # 清空列表,a:[]  

# 元组包含一些使用逗号分割的值  
t = 1,2,3,4,5   # 声明一个元组，t:(1, 2, 3, 4, 5)  
a,b,c,d,e = t  # sequence unpacking,将元组的元素依次赋给每个变量  
print(t[0])   # 元组支持索引，输出1  
u = t , (6,7)  # 元组支持嵌套 u:((1, 2, 3, 4, 5), (6, 7))  
# 不过元组的元素是不可变的  
t[0] = 8  # 元组元素不可以进行赋值，否则会引发TypeError  
# TypeError: 'tuple' object does not support item assignment  
# 不过元组可以包含可变对象  
v = ([1,2,3],[3,2,1])  
v[0][1] = 3   # 元组中的可变对象的元素可以进行赋值  

empty = ()  # 声明一个空元组使用'()'  
len(empty)   # 空元组长度，返回0  
single = "hello",  # 声明一个只有一个元组的元组，需要在结尾加逗号  
len(single)   # 返回1  

nset = {1,2,1,2,3,1,3}  # 声明集合  
print(nset)   #输出{1, 2, 3} ，集合中不含重复元素  
# 使用in可以检查一个元素是否在集合中  
1 in nset   # 返回True  
5 in nset   # 返回False  

# 演示一下集合的数学运算  
a = set([1,2,3])  # 使用set()也可以生成集合，a:{1, 2, 3}  
b = set([2,3,4])  # b:{2, 3, 4}  
a - b  # 返回{1}, 差集：在a且不在b中的元素  
a | b  # 返回{1, 2, 3, 4}，并集：在a或在b中的元素  
a & b  # 返回{2, 3}，交集：在a且在b中的元素  
a ^ b  # 返回{1, 4}，在a或在b但不同时在a和b中的元素  

tel = {'jack':123,'rose':567}  # 声明一个字典  
tel['mike'] = 666   # 使用[]为字典添加一个键值对  
print(tel) # 输出 {'jack': 123, 'rose': 567, 'mike': 666}  
tel['jack']  # 输出123 ，使用[key]获取字典中对应的值  
del tel['rose']  # 使用del删除一个键值对  
print(tel)  # 输出 {'jack': 123, 'mike': 666}  
# list(dic)返回字典的键组成的列表，顺序为插入键值对的顺序  
list(tel)  # 返回 ['jack', 'mike']  
sorted(tel)  # 返回 ['jack', 'mike']，返回排序后键列表  
# 使用关键字'in'可以检查字典中是否有相应的key  
'jack' in tel  # 返回 True  
'rose' in tel  # 返回False  
# 使用dict()构造函数可以直接以键值对形式构造字典  
dict([('a',1),('b',2)])   # 返回 {'a': 1, 'b': 2}  
# dic.get(key,default) 可以获取字典中键为key对应的值，若key不存在会返回default，而不会报错  
tel.get('jack',0)   # 返回 123  
tel.get('rose',0)   # 返回 0  

tel = {'jack': 123, 'mike': 666}  # 声明字典  
for key,val in tel.items():  # 遍历字典，key表示键，val表示值  
     print(key,val)  
# 输出内容如下：  
# jack 123  
# mike 666  

lst = ['a','b','c']  # 声明列表  
for l in lst:   # 遍历列表，l为列表中 的元素  
    print(l)  
# 输出内容如下：  
# a  
# b  
# c  

lst = ['a','b','c']  # 声明列表  
for index,val in enumerate(lst): # 遍历列表,index为索引,val为值  
    print(index,val)  
# 输出内容如下：  
# 0 a  
# 1 b  
# 2 c  

questions = ['name','age','favorite color']  
answers = ['jack',20,'green']  
for q,a in zip(questions,answers):  # 同时遍历两个列表  
    print('What is your {0}? It is {1}.'.format(q,a))  
# 输出内容如下：  
# What is your name? It is jack.  
# What is your age? It is 20.  
# What is your favorite color? It is green.  

for i in reversed(range(1,5,2)):  
    print(i)  
# 输出内容如下：  
# 3  
# 1  

lst = [3 ,5 ,2 ,1]  
for l in sorted(lst):  
    print(l)  
# 输出内容如下  
# 1  
# 2  
# 3  
# 5  
lst   # 返回 [3, 5, 2, 1]