1 ##定义列表
 2 list = [1,2,3,"a","b","c",True,False]
 3 ##访问列表
 4 print (list[4]) #b
 5 print (list[3:6])#[a,b,c]
 6 print (list[3:])#[a,b,c,True,False]
 7 print (list[:6])#[1,2,3,a,b,c]
 8 print (list[-2])#True
 9 ##更新列表
10 list[4] = "x"
11 print list # [1, 2, 3, ‘a‘, ‘x‘, ‘c‘, True, False]
12 
13 ## 删除元素
14 del list[3:6]
15 print list #[1, 2, 3, True, False]
16 ##列表函数
17 print len(list) #5
18 print [1,2,3] + ["a","b","c"] #[1, 2, 3, ‘a‘, ‘b‘, ‘c‘]
19 print [1,2,3] *3  #[1, 2, 3, 1, 2, 3, 1, 2, 3]
20 print "x" in [1,2,3] #False
21 print "x" not in [1,2,3] #True
“”“

定义列表：
list1 = [‘physics‘, ‘chemistry‘, 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
获取列表数据：
list1[1]
list2[1:5]
更新列表：
list[2] = 2001;
删除元素：
del list1[2];
列表函数：
len([1, 2, 3]) 3 长度
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合
[‘Hi!‘] * 4 [‘Hi!‘, ‘Hi!‘, ‘Hi!‘, ‘Hi!‘] 重复
3 in [1, 2, 3] True 元素是否存在于列表中
for x in [1, 2, 3]: print x, 1 2 3 迭代
列表截取：
L[2] ‘SPAM!‘ 读取列表中第三个元素
L[-2] ‘Spam‘ 读取列表中倒数第二个元素
L[1:] [‘Spam‘, ‘SPAM!‘] 从第二个元素开始截取列表

“”“

 1 其他方法：
 2 cmp(list1, list2)
 3     比较两个列表的元素
 4 len(list)
 5     列表元素个数
 6 max(list)
 7     返回列表元素最大值
 8 min(list)
 9     返回列表元素最小值
10 list(seq)
11     将元组转换为列表
12 list.append(obj)
13     在列表末尾添加新的对象
14 list.count(obj)
15     统计某个元素在列表中出现的次数
16 list.extend(seq)
17     在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
18 list.index(obj)
19     从列表中找出某个值第一个匹配项的索引位置
20 list.insert(index, obj)
21     将对象插入列表
22 list.pop(obj=list[-1])
23     移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
24 list.remove(obj)
25     移除列表中某个值的第一个匹配项
26 list.reverse()
27     反向列表中元素
28 list.sort([func])
29     对原列表进行排序

 1 #元组 tuple
 2 
 3 ##定义元组
 4 
 5 t1 = (1,2,3,"aa","vv",True)
 6 t2 = (2,2,3,"bb","zz",False)
 7 
 8 ##访问元组
 9 print t1[1] # 2
10 print t2[2:4] #(3, ‘bb‘)
11 print t1[2:] # (3, ‘aa‘, ‘vv‘, True)
12 print t1[:4] # (1, 2, 3, ‘aa‘)
13 print t1[-2] # vv
14 
15 ##修改元祖 -元祖元素不可改变  但是可以将多个元组 拼接为一个新元组
16 t = (1,2,3) + ("a","b","c")
17 print t  # (1, 2, 3, ‘a‘, ‘b‘, ‘c‘)
18 
19 ## 删除元祖 - 元组元素不可删除  但是可以删除整个元祖
20 del t

 1 定义元组：
 2 tup1 = (‘physics‘, ‘chemistry‘, 1997, 2000);
 3 tup2 = (1, 2, 3, 4, 5 );
 4 tup3 = "a", "b", "c", "d";    
 5 tup1 = ();
 6 tup1 = (50,);#元组中只包含一个元素时，需要在元素后面添加逗号
 7 
 8 访问元组：
 9 tup1[0]
10 tup2[1:5]
11 
12 修改元组：
13 元组是不允许修改的 但是可以进行连接组合
14     tup1 = (12, 34.56);
15     tup2 = (‘abc‘, ‘xyz‘);
16     tup3 = tup1 + tup2;
17     print tup3;
18 
19 删除元祖：
20 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
21 tup = (‘physics‘, ‘chemistry‘, 1997, 2000);
22 del tup;
23 
24 其他运算：
25 len((1, 2, 3))    3    计算元素个数
26 (1, 2, 3) + (4, 5, 6)    (1, 2, 3, 4, 5, 6)    连接
27 (‘Hi!‘,) * 4    (‘Hi!‘, ‘Hi!‘, ‘Hi!‘, ‘Hi!‘)    复制
28 3 in (1, 2, 3)    True    元素是否存在
29 for x in (1, 2, 3): print x,    1 2 3    迭代
30 L[2]    ‘SPAM!‘    读取第三个元素
31 L[-2]    ‘Spam‘    反向读取；读取倒数第二个元素
32 L[1:]    (‘Spam‘, ‘SPAM!‘)    截取元素
33 cmp(tuple1, tuple2)
34     比较两个元组元素。
35 len(tuple)
36     计算元组元素个数。
37 max(tuple)
38     返回元组中元素最大值。
39 min(tuple)
40     返回元组中元素最小值。
41 tuple(seq)
42     将列表转换为元组。

1 #Set
2 ## 定义Set
3 s = {"aa",1,2,3,True,"aa",1,2,3}
4 print s  # set([‘aa‘, 1, 2, 3])
5 ##访问Set
6 for i in s:
7     print i
8     

 1 #字典dict
 2 ##定义字典
 3 d = {"name":"zs","age":18,"addr":"bj","salary": 999.999}
 4 print d # {‘salary‘: 999.999, ‘age‘: 18, ‘name‘: ‘zs‘, ‘addr‘: ‘bj‘}
 5 
 6 ##访问字典
 7 print d["name"] #zs
 8 
 9 ##修改字典
10 d["salary"]  = 1000.0  
11 print d # {‘salary‘: 1000.0, ‘age‘: 18, ‘name‘: ‘zs‘, ‘addr‘: ‘bj‘}
12 
13 #删除字典
14 del d["age"] #删除某一项
15 print d  # {‘salary‘: 1000.0, ‘name‘: ‘zs‘, ‘addr‘: ‘bj‘}
16 d.clear() #清空字典，字典本身是存在
17 print d  # {}
18 del d #删除字典本身

 1 创建字典：
 2 d = {key1 : value1, key2 : value2,... }
 3 键必须是唯一的，但值则不必。
 4 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
 5 字典中的内容无序
 6 
 7 访问字典：
 8 dict[‘Name‘]
 9 
10 修改字典:
11 dict[‘Age‘] = 8; # update existing entry
12 dict[‘School‘] = "DPS School"; # Add new entry
13 
14 删除字典：
15 del dict[‘Name‘]; # 删除键是‘Name‘的条目
16 dict.clear();     # 清空词典所有条目
17 del dict ;        # 删除词典
18 
19 
20 其他方法：
21 cmp(dict1, dict2)
22     比较两个字典元素。
23 len(dict)
24     计算字典元素个数，即键的总数。
25 str(dict)
26     输出字典可打印的字符串表示。
27 type(variable)
28     返回输入的变量类型，如果变量是字典就返回字典类型。
29 dict.clear()
30     删除字典内所有元素
31 dict.copy()
32     返回一个字典的浅复制
33 dict.fromkeys(seq[, val]))
34     创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
35 dict.get(key, default=None)
36     返回指定键的值，如果值不在字典中返回default值
37 dict.has_key(key)
38     如果键在字典dict里返回true，否则返回false
39 dict.items()
40     以列表返回可遍历的(键, 值) 元组数组
41 dict.keys()
42     以列表返回一个字典所有的键
43 dict.setdefault(key, default=None)
44     和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
45 dict.update(dict2)
46     把字典dict2的键/值对更新到dict里
47 dict.values()
48     以列表返回字典中的所有值