Python3.x下列表，元组，集合，字典等工作中常用操作

平时工作中在处理一些数据上经常会用到几种数据结构的操作，list,tuple,dict,set

list：
基本操作：
append() 在尾部添加元素（常用）
insert(i,item) 在指定位置添加元素
extend()或者”+” 列表合并
del[i] 删除索引i下的元素
remove() 删除指定元素
i in list 判断元素i是否在list中（常用）
pop() 默认删除最后一个元素
pop(i) 指定位置取出索引i下的元素
index(i) 找出i的第一个匹配项的索引位置
clear() 清空列表（很少用）
reverse() 列表反转（很少用）
l1.count(1) 元素1在列表l1中出现的次数（常用）
len(l1) 计算列表长度（常用）

切片（不仅适用于列表list，也适用于字符串string）

l1 = [1,2,3,4,5]
l1[0:3] # [1,2,3]
l1[:3] # 等同于上面
l1[:] # 列表全部值
l1[3:] # [4,5]
l1[0:4:2] # [1,3]
l1[::2] # 取所有值，步长为2 [1,3]
l1[::-1] # 列表反转 [5,4,3,2,1]

sorted() 排序，默认升序（reverse=False），降序可以通过添加参数reverse=True来实现
如果遇到list中包含很多个小list，每个小list有几个元素，想按照某个位置的元素大小进行排序

from operator import itemgetter,attrgetter
# 按照每个小list的第二个元素，从大到小排序
sorted(l1,key=itemgetter(1),reverse=True)  

升级一点的操作：
列表中的元素求和 sum(a,b,c)
多个list之间按顺序相加减乘除（常用）

# 方法一
import numpy as np
l1 = np.array([a,b,c])
l2 = np.array([d,e,f])
sum_list = list(l1 + l2)
# 方法二
l1 = [a,b,c]
l2 = [d,e,f]
l3 = [x+y for x,y in zip(l1,l2)]

多个list的元素按顺序合并：（常用）

l1 = [1,2,3]
l2 = [4,5,6]
l3 = list(zip(l1,l2)) # [(1,4),(2,5),(3,6)]

将一个列表分割成几个小列表（列表表达式的应用）

l1 = [i for i in range(9)]
n = 3
l2 = [l1[i:i+n] for i in range(0, len(l1),n)] # [[0,1,2],[3,4,5],[6,7,8]]

列表中有小列表，现在要去除小列表的括号(可以计算每个小列表的和，并且放在列表头

l1=[[0,1,2],[3,4,5],[6,7,8]]
temp = []
for i in l1:
    temp.append(sum(i))
    for j in i:
        temp.append(j)
print(temp) # [3,0,1,2,12,3,4,5,21,6,7,8]

tuple:
创建元组（只有一个元素时，在元素后面加逗号，否则会被当成其他数据类型处理）：

tup = (1,)
print(type(tup)) # <'tuple'>
tup = (1)
print(type(tup)) # <'int'>

列表转元组，元组转列表（常用）

tup = (1,2,3)
l1 = list(tup) # [1,2,3]
l2 = [1,2,3]
t1 = tuple(l2) # (1,2,3)

索引，切片，计算元组长度，计数等和list的操作一样
元组没有列表中的增、删、改的操作，只有查的操作
元组中的元素是不允许删除的，但可以使用del语句来删除整个元组

set:
无序且不重复的集合
创建空集合

s = set()

比较

se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be)        #找到se中存在，be中不存在的集合，返回新值
print(temp1)        #{33, 11}
print(se)        #{33, 11, 22}

temp2 = se.difference_update(be) #找到se中存在，be中不存在的集合，覆盖掉se
print(temp2)        #None
print(se)           #{33, 11},

删除

se = {11, 22, 33}
se.discard(11)
se.discard(44)  # 移除不存的元素不会报错
print(se)

se = {11, 22, 33}
se.remove(11)
se.remove(44)  # 移除不存的元素会报错
print(se)

se = {11, 22, 33}  # 移除末尾元素并把移除的元素赋给新值
temp = se.pop()
print(temp)  # 33
print(se) # {11, 22}

取交集

se = {11, 22, 33}
be = {22, 55}

temp1 = se.intersection(be)             #取交集，赋给新值
print(temp1)  # 22
print(se)  # {11, 22, 33}

temp2 = se.intersection_update(be)      #取交集并更新自己
print(temp2)  # None
print(se)  # 22

判断

se = {11, 22, 33}
be = {22}

print(se.isdisjoint(be))        #False，判断是否不存在交集（有交集False，无交集True）
print(se.issubset(be))          #False，判断se是否是be的子集合
print(se.issuperset(be))        #True，判断se是否是be的父集合

合并

se = {11, 22, 33}
be = {22}

temp1 = se.symmetric_difference(be)  # 合并不同项，并赋新值
print(temp1)    #{33, 11}
print(se)       #{33, 11, 22}

temp2 = se.symmetric_difference_update(be)  # 合并不同项，并更新自己
print(temp2)    #None
print(se)             #{33, 11}

取并集

se = {11, 22, 33}
be = {22,44,55}

temp=se.union(be)   #取并集，并赋新值
print(se)       #{33, 11, 22}
print(temp)     #{33, 22, 55, 11, 44}

更新

se = {11, 22, 33}
be = {22,44,55}

se.update(be)  # 把se和be合并，得出的值覆盖se
print(se)
se.update([66, 77])  # 可增加迭代项
print(se)

集合的转换（转list，tuple等）

se = set(range(4))
li = list(se)
tu = tuple(se)
st = str(se)
print(li,type(li))
print(tu,type(tu))
print(st,type(st))

OUTPUT:
[0, 1, 2, 3] <class 'list'>
(0, 1, 2, 3) <class 'tuple'>
{0, 1, 2, 3} <class 'str'>

dict：
key是唯一的且不可变
value可以是任意数据类型

dict[key] 访问字典的值
cmp(dict1,dict2) 比较两个字典元素
len(dict1) 计算键的总数
str(dict1) 输出字典中可打印的字符串
dict.clear() 删除字典内所有元素
dict.copy() 返回一个字典的浅复制
dict.fromkeys(key,value) 创建一个新字典
dict.get(key,default=None) 返回指定key的值，如果值不存在返回default的值
dict.has_key(key) 如果key在字典中，返回True，否则返回False
dict.items() 以列表返回可遍历的(key,value)元组数组（常用）
dict.keys() 以列表返回一个字典中的所有key（常用）
dict.setdefault(key,default=None) 和get类似，如果key不存在于dict中，将会添加key并将值设为default
dict.update(dict2) 把字典dict2的键/值对更新到dict里
dict.values() 以列表返回字典中的所有值（常用）
key in dict1 如果键在字典dict里返回true，否则返回false（常用）

d1 = {'name':'Frank','age':23, 'gender':'male'}
d2 = {'height':180}
print(list(d1.values())) # ['Frank',23,'male'] 无序的
print(list(d1.keys())) # ['name', 'gender', 'age'] 无序的
print(list(d1.items())) # [('gender', 'male'), ('age', 23), ('name', 'Frank')] 无序的
d1.update(d2) # {'gender': 'male', 'height': 180, 'name': 'Frank', 'age': 23}
print('age' in d1) # True