1、元组Tuple与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用中括号。
元组可以查询，可以使用内置函数count、index。但是不能修改、增加、删除（儿子不能，孙子有可能）。
name = ('a','a','b')
print(name.count('a'))
2
可以索引，可以切片（步长）。
name = ('a','a','b')
print(name[2])
b

2、字典：
使用大括号来表示字典，前面是元素的名字，后面是元素的值（可以是字符，也可以是数字或其他任意类型），中间用冒号隔开。

info = {'name':'xiaowang','sex':'f','address':'中国北京'}
print(info)
{'name': 'xiaowang', 'sex': 'f', 'address': '中国北京'}

字典的查询效率比列表快，因为字典首先将key值进行hash并进行排序，当查询字典时只需查询key的hash值，而不需要从头进行循环，由于hash值进行了有序排序所以查询快
而列表不能对元素建立一个索引，所以只能从头循环查找

字典常见操作一：
2.1 按key值查询元素的值
>>> info['name']
'xiaowang'

2.2、get()查询
查询时，如果查询一个字典中不存在的元素，则程序会报错。为了不报错，可以使用get方法来查询字典
a.get('age') //不会返回任何值
a.get('age',0) //会将age的默认值设置为0，但是不会将默认值添加到字典中。
a.get('name','ddd') //会返回name的值abc，如果查询到了元素的值，则不会修改元素的值。

2.3、修改元素的值
>>> info['name'] = 'xiaozhang'
>>> info
{'name': 'xiaozhang', 'sex': 'f', 'address': '中国北京'}

2.4、添加元素的值
>>> info['high']= '170cm'

2.5、dict.setdefault(key, default)
许多时候我们需要往字典中的元素添加数据，我们首先要判断这个元素是否存在，不存在则创建一个默认值，存在则不变动。我们可以使用 dict.setdefault(key, default) 。
info.setdefault('sex','m')
print(info)
{'name': 'xiaowang', 'sex': 'f', 'address': '中国北京'}

2.6、删除元素的值,有del和clear、pop三种方法
>>> del info['high'] 删除high元素的值
>>> del info 删除整个info字典，如果del了整个字典后，再想在info中添加元素，则需要重新定义info字典。
>>> info.clear() 清空字典中所有元素的值，但是字典本身还在，只是成为了一个空字典
>>> info
>>> {}

pop(key) 函数，可以返回 key 对应的 value，并将该 key:value 键值对删除：

用pop()删除时可以指定字符串，如果要删除的key不存在时，则返回指定字符串，而不会报错
print(user.pop('tel','111'))
111
{'name': 'xiaozhang', 'sex': 'f', 'address': '中国北京'}

#popitem()会随机删除字典中的键值对
user.popitem()

2.7、创建字典
同 set 一样，字典也可以使用 dict 函数进行创建，参数是一个包含若干个二元组的元组（注意括号的数量）：
dic = dict(((1,'Linux'), (2,'Vim')))
print(dic)
{1: 'Linux', 2: 'Vim'}

2.8、len()
测量字典中键值的个数
>>>dict = {'name':'zhangsan','sex':'m'}
>>>len(dict)
2

2.9、keys
返回一个包含字典所有key的列表
>>>dict = {'name':'zhangsan','sex':'m'}
>>>dict.keys()
dict_keys(['name','sex'])

>>>for i in dict.keys():
print(i)

2.10、values
返回一个包含字典中所有值的列表
>>>dict = {'name':'zhangsan','sex':'m'}
>>>dict.values()
dict_values(['zhangsan','m'])

>>>for i in dict.values():
print(i)

2.11、items
返回一个包含所有（键、值）元组的列表
>>> info.items()
dict_items([('name', 'xiaowang'), ('sex', 'f'), ('address', '中国北京')])

for i,j in temp:
    print('key:%s,value:%s'%(i,j))

key:name,value:xiaowang
key:sex,value:f
key:address,value:中国北京

user = {'name': 'xiaozhang', 'sex': 'f', 'address': '中国北京'}
print(list(user.keys()))
print(list(user.values()))
print(list(user.items()))

['name', 'sex', 'address']
['xiaozhang', 'f', '中国北京']
[('name', 'xiaozhang'), ('sex', 'f'), ('address', '中国北京')]

#获取字典的key和value有以下两种方法，建议用第一种方法效率高，因为第二种方法是先将字典转换成一个列表，再输出
user = {'name': 'xiaozhang', 'sex': 'f', 'address': '中国北京'}
for key in user:
print(key,user[key])

for k,v in user.items():
print(k,v)

2.12、has_key(在python2中有，3中没有这个方法，3中使用get()方法）
如果key在字典中，返回True，否则返回False
>>>dict = {'name':'zhangsan','sex':'m'}
>>>dict.has_key('name')
True
>>>dict.has_key('phone')
False

2.13、type(info)
可以查看info的类型是字典
<class 'dict'>

2.14、help(info)
可以查看info字典可以用的方法，info是字典的名字。

2.15、dict.fromkeys() 生成一个字典，用列表中的每一个元素作为一个key，可以指定value的默认值，如果不指定则value为None
user = ['tom','Jack','mike']
dict_user1 = dict.fromkeys(user,1)
print(dict_user1)
{'tom': 1, 'Jack': 1, 'mike': 1}

也可以将value指定成一个列表
user = ['tom','Jack','mike']
dict_user1 = dict.fromkeys(user,[1,2,3])
print(dict_user1)
{'tom': [1, 2, 3], 'Jack': [1, 2, 3], 'mike': [1, 2, 3]}

但是如果更改了任意一个value列表中的某个值，则所有value的值都会跟着更改

dict_user1['mike'][0]=0
print(dict_user1)
#{'tom': [0, 2, 3], 'Jack': [0, 2, 3], 'mike': [0, 2, 3]}

2.16、update()将两个字典进行合并
dict_1 = {'a':1,'b':2}
dict_2 = {'c':3,'d':4}
dict_1.update(dict_2)
print(dict_1)

#{'a': 1, 'b': 2, 'c': 3, 'd': 4}

2.17、copy()  浅copy
第2个字典copy第1个字典，修改字典中的值时，如果元素是不可变数据类型，则另一个字典不会随着改，如果元素是可变数据类型（列表、字典），则另一个字典也会随着改变。2个字典的id是不一样的，但是字典内元素的id是一样的，所以如果元素是列表或字典，当更改列表或字典内的值时，2个变量都是改变。

card_1 = {'name':'tom','acc':{'id':111,'balance':1000}}
card_2 = card_1.copy()
card_2['name'] = "tom's wife"
print(card_1)
print(card_2)
card_1['acc']['balance']-=100
print(card_1)
print(card_2)

{'name': 'tom', 'acc': {'id': 111, 'balance': 1000}}
{'name': "tom's wife", 'acc': {'id': 111, 'balance': 1000}}
{'name': 'tom', 'acc': {'id': 111, 'balance': 900}}
{'name': "tom's wife", 'acc': {'id': 111, 'balance': 900}}

2.18、copy.deepcopy(x)  深copy
#修改字典中的值时，其他字典不会随着改变，深copy是形成了两个完全独立的变量，变量id和变量内元素的id，以及可变元素内层的元素id都是不一样的
card_1 = {'name':'tom','acc':{'id':111,'balance':1000}}
card_2 = card_1.copy()
card_2['name'] = "tom's wife"
import copy
card_3 = copy.deepcopy(card_1)
card_3['name'] = 'mike'
print(card_1)
print(card_2)
print(card_3)
card_1['acc']['balance']-=100
print(card_1)
print(card_2)
print(card_3)

{'name': 'tom', 'acc': {'id': 111, 'balance': 1000}}
{'name': "tom's wife", 'acc': {'id': 111, 'balance': 1000}}
{'name': 'mike', 'acc': {'id': 111, 'balance': 1000}}
{'name': 'tom', 'acc': {'id': 111, 'balance': 900}}
{'name': "tom's wife", 'acc': {'id': 111, 'balance': 900}}
{'name': 'mike', 'acc': {'id': 111, 'balance': 1000}}

2.19、排序

d = {'Tom':20, 'Jack':22, 'Mike':28, 'Rose':30}
print(sorted(d.keys())) #将key值进行排序
['Jack', 'Mike', 'Rose', 'Tom']

print(sorted(d.values()))#将value值进行排序
[20, 22, 28, 30]

print(sorted(d.items()))#按key值对键值对进行排序
[('Jack', 22), ('Mike', 28), ('Rose', 30), ('Tom', 20)]

print(sorted(d.items(),key=lambda i:i[1])) #按value值对键值对进行排序
[('Tom', 20), ('Jack', 22), ('Mike', 28), ('Rose', 30)]

-----------------------------------------------------
例子：
将字典中的key键含有'k'元素的所有键值对删除。
由于在循环一个字典时，不能改变该字典的大小，所以不能直接在for循环的时候直接删除字典中的键值对，只能将需要删除的key先保存在一个列表中，再循环这个列表去删除字典中的键值对。

dic = {'k1':'v1','k2':'v2','k3':'v3','name': 'alex'}
L1 = []
for key in dic:if 'k' in key:L1.append(key)
for key in L1:del dic[key]
print(dic)

结果：{'name': 'alex'}