参考：dict and set
Note：
A.dict
Hint：注意最后三点。
1.Python内置字典dict，全称directory，在别的语言如C++中称为map，使用键值-value存储，查找速度极快。
2.给定一个键值key，dict在内部根据键值计算出存储的内存地址，从而迅速的得到value。
3.dict初始化时，必须是key-value的形式。eg. 'Chen' : 90;
4.dict支持根据key赋值，即dict['key'] = value。
5.可以通过dict.get('key_name'[, value])函数来判断'key_name'这个key是否在dict中，如果不在，则返回none或者自定义的值value。也可以通过 'key_name' in dict 的形式，在 => 返回True，不在 => 返回False。
6.删除一个key，使用的是dict.pop('key_name')方法。
eg.
#!/usr/bin/env python3
score = {'Chen' : 90, 'Michael' : 89, 'Li' : 78, 'Wang' : 0}
score['Wang'] = 69 # dict['string'] = value
score['Wang'] = 79
print(score)
name = input()
print(score[name])
score.pop('Wang') # dict.pop('string')
print(score.get('Wang', -1))
print(score)
Output：
sh-3.2# ./dict1.py
{'Michael': 89, 'Chen': 90, 'Li': 78, 'Wang': 79}
Wang
79
-1
{'Michael': 89, 'Chen': 90, 'Li': 78}
7.dict内部存放的顺序和key放入的顺序是没有关系的，原因是内部使用hash散列决定key-value的存储位置。
8.dict的key，必须是不可变对象，即整数、字符串等，不能是list。要保证hash的正确性，作为key的对象就不能变。
9.dict与list的比较：
和list比较，dict有以下几个特点：
- 查找和插入的速度极快，不会随着key的增加而变慢；
- 需要占用大量的内存，内存浪费多。
而list相反：
- 查找和插入的时间随着元素的增加而增加；
- 占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
B.set
Hint：注意第5点。
1.set即集合，元素互异、无序、确定。
2.创建set时，需要传入一个list，list中的重复元素自动被过滤。 set_name = set([v1, v2, ..., vn])
3.add(key)方法传入元素，remove(key)方法删除元素。注意，add(key)如果之前key值已经存在与set中，则不会有效果。
4.两个集合之间可以通过 & 和 | 进行与和并的运算。
eg.
#!/usr/bin/env python3
s = set([1, 2, 3])
print(s)
s = set([1, 2, 3, 3, 4, 4, 4])
print(s)
s.add(5)
print(s)
s.add(5)
print(s)
s.remove(4)
print(s)
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
print(s1 & s2)
print(s1 | s2)
output：
sh-3.2# ./set1.py
{1, 2, 3}
{1, 2, 3, 4}
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}
{1, 2, 3, 5}
{2, 3}
{1, 2, 3, 4}
5.set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。
再议不可变对象
1.对于可变对象list，进行相关操作list是会变化的。
eg.
sh-3.2# python3
Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 26 2016, 10:47:25)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> list = [3, 2, 1]
>>> list.sort()
>>> print(list)
[1, 2, 3]
>>>
2.对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。
调用自身的方法 => new 对象 and 返回 => 自身不变。
eg.
>>> str = 'abc'
>>> str.replace('a', 'A')
'Abc'
>>> print(str)
abc
上述代码中调用replace()方法，新建了一个str对象并返回，原有str对象不变。
可以写为：
>>> str = 'abc'
>>> b = str.replace('a', 'A')
>>> print(b)
Abc
>>> print(str)
abc
在内存单元中存储如图：
实验：Tuple 放入 dict
1.Tuple中不含list：
dict0 = {(1, 2, 3) : 90}
print(dict0[(1, 2, 3)])
正常输出90。表明不含dist的Tuple是不可变对象，可被hash。
2.Tuple中含list：
dict0 = {(1, 2, [3, 4]) : 90}
print(dict0[(1, 2, [3, 4])])
报错：
Traceback (most recent call last):
File "./dict1.py", line 25, in <module>
dict0 = {(1, 2, [3, 4]) : 90}
TypeError: unhashable type: 'list'
表明含list的Tuple为可变对象，不能作为dict和set的元素。
2017/1/28