Disclaimer: This article is a blogger original article, follow the CC 4.0 BY-SA copyright agreement, reproduced, please attach the original source link and this statement.
1. Data Structure and Basic Operation
1.1 List List
（1）初始化
♦空的：list1 = [] 或 list1 = list()
♦有数据：list1 = [1,'a'] list1 = list([1,'a'])#可以在list中存放不同的数据类型
（2）取值
按下标取值list1[0]
（3）添加或修改
在末尾添加元素：list1.append(3)
直接修改：list1[0] = 2
插入：list1.insert(0,'b')
（4）删除
del list1[0]
移除列表中某个值的第一个匹配项 list1.remove('a')
list1.pop(index) 删除并返回该元素，默认index=-1（最后一个元素）
（5）其他函数和方法
列表元素个数 len(list1)
列表元素最大值 max(list1)
列表元素最小值 min(list1)
统计某个元素在列表中出现的次数 list1.count('a')
在列表末尾一次性追加多个值 list1.extend([1,2,3])
某个元素在列表中的第一个索引 list1.index('a')
列表反向 list1.reverse()
清空 list1.clear()
复制 list1.copy()
1.2 yuan group Tuple
与List类似，但其中的元素不可变，不可修改，不可删除
(1)初始化
只有一个元素tuple1 = (1,) #要加逗号
多个元素tuple1 = (1,'a')
(2)访问元组
按索引访问tuple1[0]
(3)不能增加元素，但可以对元组进行连接组合
tuple2 = (2,)
tuple3 = tuple1 + tuple2
(4)如果元组中包含可变对象，对象的属性是可变的
a = (1,[2,3])
a[1][0] = '1'
print a : (1,[1,3])
1.3 collection Set
set是无序不重复元素的序列
(1)初始化
空集合：set1 = set() #不能使用{}，因为{}是创建空字典的
有元素：set1 = {1,'a'} 或 set1 = set((1,'a'))
(2)添加元素
字符串，数字等：set1.add(1), set1.add('b'),set1.add('qweqw')
列表，元组，字典等：set1.update([2,3])...
(3)删除元素
set1.remove('a') 存在则删除，不存在则报错
set1.discard('a') 存在则删除，不存在不报错
set1.pop() 随机删除一个元素
（4）集合之间的运算符
差集 set1 - set2
并集 set1 | set2
交集 set1 & set2
两个集合中不重复的 set1 ^ set2 即 交集-并集
（5）其他方法
清空 set1.clear()
差集 set1.difference(set2) : 返回set1-set2
set1.difference_update(set2):set1 = set1-set2
交集 set1.intersection(set2)
set1.intersection_update()
判断两个集合是否包含相同的元素 set1.isdisjoint(set2)
是否是子集 set1.issubset(set2)
是否是父集 set1.issuperset(set2)
并集 set1.union(set2)
两个集合中不重复的 set1.symmetric_difference(set2)
set1.symmetric_difference_update(set2)
1.4 Dictionary Dict
(1)初始化
空的 ： dict1 = {} 或 dict1 = dict()
有初始值 ：dict1 = {1:'a','b':2} #key必须为不可变的，如字符串，数字或元组
从序列中初始化
dict1 = dict.fromkeys([1,2],'a') <==> dict1={1:'a',2:'a'}
(2)访问
按key访问：dict1[1],dict1['b'] #如果不存在指定的key则报错
或者 dict1.get(1,default=None)
(3)添加或更新
dict1[1] = 'c'
dict1[2] = 'd'
dict1.setdefault(1,'a') 如果已存在这个key，则保持原来不变，不存在，则添加
dict1.update（dict2）把dict2的键值对更新到dict1中
(4)删除元素
del dict1[1]
dict1.pop(1) 删除键值对，并返回删除的值
dict1.popitem() 随机删除一对键值对，并返回
(5)其他函数或方法
清空 dict1.clear()
复制 dict1.copy()
获取所有的值组成的序列 dict1.values()
获取所有的键组成的序列 dict1.keys()
获取所有的键值对组成的序列 dict1.items()
键是否存在dict中 'a' in dict1 或 dict1.has_key('a') #优先使用 in dict，其次dict.has_key,不要使用 in dict.keys
2. Other operations
2.1 List slices and Tuple
l = ['a','b','c','d','e','f','g','h','i']
第一个元素索引是0，倒数第一个元素索引是-1.
取前5个元素l[:5]
取第3个到第五个元素l[2,5]
前5个，每2个取一个l[:5:2]
取后5个[-5:]
后5个，每2个取1个l[-5::2]
2.2 derivations
(1)列表推导式
newList = [exp(i) for i in oldList if filter_exp(i)]
exp(i) 关于i的表达式
filter_exp(i) 过滤某些值
例子：
multiples = [i for i in range(30) if i % 3 == 0]
# Output: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
(2)字典推导式
例子：键值对换
dict1 = {'a': 10, 'b': 34}
dict2 = {v: k for k, v in dict1.items()}
print dict2
# Output: {10: 'a', 34: 'b'}
(3)集合推导式
squared = {x**2 for x in [1, 1, 2]}
print(squared)
# Output: set([1, 4])
2.3 traversal
(1)遍历List/Tuple
1.for val in list:值为val，得不到索引
2.for i in range(len(list)):值为list[i],索引为i
3.for i,val in enumerate(list):值为val，索引为i
只需要值就用第一种，需要索引就用第三种
(2)遍历Set
1.for val in set
2.for i,val in enumerate(set) #相当于把set转为了list
(3)遍历Dict
1.for key in dict: 键key，值dict[key]
2.dict.keys()和dict.values()返回list类型，可以当作list来遍历
3.for kv in dict.items() kv是tuple类型,dict.items()是list类型
4.for key,value in dict.items():键key，值value
2.4 Sorting
(1)使用sort()方法
list.sort(func=None, key=None, reverse=False(or True))
reverse默认False，从小到大；True从大到小
使用sort后，list内容会改变
(2)使用sorted()方法
sorted()可以用于任何一个可迭代对象，返回一个新的list，原来的list不会改变
1.Key Function
例子A：
区分大小写的字符串比较排序
sorted("This is a test string from Andrew".split(), key=str.lower)
#output ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
例子B：tuple的下标
>>> student_tuples = [
... ('john', 'A', 15),
... ('jane', 'B', 12),
... ('dave', 'B', 10),
... ]
>>> sorted(student_tuples, key=lambda student: student[2])
# sort by age
# output [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
例子C：对象的属性
>>> student_objects = [
... Student('john', 'A', 15),
... Student('jane', 'B', 12),
... Student('dave', 'B', 10),
... ]
>>> sorted(student_objects, key=lambda student: student.age)
# sort by age
# output [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
2.Operator Module Functions
例子A：sorted(student_tuples, key=itemgetter(2)) 通过下标
例子B：sorted(student_objects, key=attrgetter('age')) 通过对象属性
例子C：
messages = ['critical!!!', 'hurry!', 'standby', 'immediate!!']
sorted(messages, key=methodcaller('count', '!')) 通过调用对象方法
多关键字排序：
sorted(student_objects, key=attrgetter('grade', 'age'))
sorted(list, key=itemgetter(0,1))
复杂排序：如先升序后降序，排序两次
s = sorted(student_objects, key=attrgetter('age'))
sorted(s, key=attrgetter('grade'), reverse=True)