三，Dict:字典
Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。
在这里可以举一个例子，假如你通过列表来查看工人的名字和对应的工资的话，在这里你需要设置两个列表，一个用于存储名字，一个用于存储工资：
1 >>> name = ['zhangsan','lisi','wangwu','doubie']
2 >>> name
3 ['zhangsan', 'lisi', 'wangwu', 'doubie']
4 >>> salary = [20000,30000,200000,123000]
5 >>> salary
6 [20000, 30000, 200000, 123000]
7 >>>
给定一个名字，要查找对应的成绩，就先要在name中找到对应的位置，再从salary取出对应的成绩，list越长，耗时越长。
如果用dict实现，只需要一个“名字”-“薪水”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。
用Python写一个dict如下：
1 >>> dict1 = {'zhangsan':30000,'lisi':321000,'wanger':123654,'wangwu':123878}
2 >>> dict1
3 {'lisi': 321000, 'zhangsan': 30000, 'wanger': 123654, 'wangwu': 123878}
4 >>>
为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。
第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字，无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。
dict就是第二种实现方式，给定一个名字，比如'zhangsan'，dict在内部就可以直接计算出zhangsanl对应的存放成绩的“页码”，也就是30000这个数字存放的内存地址，直接取出来，所以速度非常快。
你可以猜到，这种key-value存储方式，在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。
把数据放入dict的方法，除了初始化时指定外，还可以通过key放入：
1 >>> dict1 = {'zhangsan':30000,'lisi':321000,'wanger':123654,'wangwu':123878}
2 >>> dict1
3 {'lisi': 321000, 'zhangsan': 30000, 'wanger': 123654, 'wangwu': 123878}
4 >>> dict1['zhangsan']
5 30000
6 >>> dict1['wangwu']
7 123878
8 >>> dict1['lisi']
9 321000
10 >>>
油魚一個key只能對應一个值，因此，倘若你多次对同一个key赋值的话，以前赋的值会被覆盖掉。
1 >>> dict1
2 {'lisi': 321000, 'zhangsan': 30000, 'wanger': 123654, 'wangwu': 123878}
3 >>> dict1['zhangsan'] = 1000000
4 >>> dict1
5 {'lisi': 321000, 'zhangsan': 1000000, 'wanger': 123654, 'wangwu': 123878}
6 >>> dict1['zhangsan'] = 100
7 >>> dict1
8 {'lisi': 321000, 'zhangsan': 100, 'wanger': 123654, 'wangwu': 123878}
9 >>>
如果你想赋值的key不存在就会报错：
1 >>> dict1['xidada'] = 4563221
2 >>> dict1
3 {'lisi': 321000, 'xidada': 4563221, 'zhangsan': 100, 'wanger': 123654, 'wangwu': 123878}
4 >>> dict1['wangcc']
5 Traceback (most recent call last):
6 File "<stdin>", line 1, in <module>
7 KeyError: 'wangcc'
8 >>> dict1['wyl'] = 888888
9 >>> dict1
10 {'wanger': 123654, 'xidada': 4563221, 'lisi': 321000, 'wangwu': 123878, 'wyl': 888888, 'zhangsan': 100}
11 >>>
由以上的代码可以看出，当你的字典中没有这个key，但是你还给这个key赋值的话，是不会报错的，并且你的值可以插入这个字典中，但是假如你访问一个没有的key值，就会报出一个KeyError，
因此，要想判断key值是否存在，可以有两个方法。
方法一：使用in语句判断：
1 >>> dict1
2 {'wanger': 123654, 'xidada': 4563221, 'lisi': 321000, 'wangwu': 123878, 'wyl': 888888, 'zhangsan': 100}
3 >>> 'zhangsan' in dict1
4 True
5 >>> 'liudehua' in dict1
6 False
7 >>> dict1
方法二：使用dict提供的get()方法，若key值不存在就返回None或者自己指定的返回值：
1 >> dict1
2 {'wanger': 123654, 'xidada': 4563221, 'lisi': 321000, 'wangwu': 123878, 'wyl': 888888, 'zhangsan': 100}
3 >>> dict1.get('zhangdada','not any')
4 'not any'
5 >>> #使用自己定义的返回值
1 >>> dict1
2 {'wanger': 123654, 'xidada': 4563221, 'lisi': 321000, 'wangwu': 123878, 'wyl': 888888, 'zhangsan': 100}
3 >>>
4 >> dict1.get('zhangsan')
5 100
6 >>> dict1.get('xielaoda')
7 >>> #什么都没有返回（NONE）
8 ...
9 >>>
注意：返回None的时候Python的交互式命令行不显示结果。
和列表和元组类似，当你要删除一个字典值的时候，你可以使用pop(key)的方法达到删除字典元素的目的：
1 >>> dict1
2 {'wanger': 123654, 'xidada': 4563221, 'lisi': 321000, 'wangwu': 123878, 'wyl': 888888, 'zhangsan': 100}
3 >>> dict1.pop('wanger')
4 123654
5 >>> dict1
6 {'xidada': 4563221, 'lisi': 321000, 'wangwu': 123878, 'wyl': 888888, 'zhangsan': 100}
7 >>> dict1.pop('xidada')
8 4563221
9 >>> dict1
10 {'lisi': 321000, 'wangwu': 123878, 'wyl': 888888, 'zhangsan': 100}
11 >>>
注意，dict内部存放的顺序和key放入的顺序是没有关系的。
和list比较，dict有以下几个特点：
查找和插入的速度极快，不会随着key的增加而增加；
需要占用大量的内存，内存浪费多。
而list相反：
查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。
这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。
要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：
字典的高级应用：
1 >>> dict2 = {'a':1,'b':2,'c':3}
2 >>> dict2
3 {'a': 1, 'c': 3, 'b': 2}
4 >>> dict3 = dict2
5 >>> dict3
6 {'a': 1, 'c': 3, 'b': 2}
7 >>> del dict2['a'] #删除key为'a'的条目
8 >>> dict2
9 {'c': 3, 'b': 2}
10 >>> dict2.clear()
11 >>> dict2.clear()
12 >>> dict2.clear()#清空字典；
13 >>> dict2
14 {}
15 >>> del dict2 #直接删除整个字典
16 >>> dict2
17 Traceback (most recent call last):
18 File "<stdin>", line 1, in <module>
19 NameError: name 'dict2' is not defined
20 >>> #删除之后再输出dict2字典确实出错了
21 ...
22 >>>
字典键的特性：
(1)，在字典中同一个key不可以出现两次或以上：
1 >>> dict4 = {'name':123,'name':1236}
2 >>> dict4
3 {'name': 1236}
4 >>> #两次设置name但是只显示一次
(2),键必须不可变，所以可以用数，字符串或元组充当，所以用列表就不行，如下实例：换言之就是
1 >>> dict4 = {'name1':123,'name2':1236,'name3':1}
2 >>> dict4
3 {'name2': 1236, 'name3': 1, 'name1': 123}
4 >>>
字典的内置函数和方法：
(1),字典中的cmp函数用于比较两个字典是不是相等的：
1 >>> dic1 = {'a':1,'b':2,'c':3}
2 >>> dic2 = dic1
3 >>> dic3 = {'e':3,'r':5,'y':7}
4 >>> cmp(dic1,dic2)
5 0
6 >>> cmp(dic2,dic3)
7 -1
8 >>> #两个字典比较，如果相同就返回0 否则返回-1
9 ... #cmp函数就是用于比较两个字典是不是相等的字典内置函数
(2),len(dict)：计算字典元素个数，即键的总数。
1 >>> len(dic1)
2 3
3 >>> len(dic2)
4 3
5 >>> len(dic3)
6 3
7 >>> len(dict1)
8 4
9 >>>
(3),str(dict)：输出字典可打印的字符串表示。
1 >>> str(dic1)
2 "{'a': 1, 'c': 3, 'b': 2}"
3 >>> str(dic2)
4 "{'a': 1, 'c': 3, 'b': 2}"
5 >>> str(dic3)
6 "{'y': 7, 'r': 5, 'e': 3}"
7 >>> str(dict1)
8 "{'lisi': 321000, 'wangwu': 123878, 'wyl': 888888, 'zhangsan': 100}"
9 >>>
(4),type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型。
1 >>> type(dic1)
2 <type 'dict'>
3 >>> type(dic2)
4 <type 'dict'>
5 >>> type(dict1)
6 <type 'dict'>
7 >>>
Python字典包含了以下内置方法：
1、radiansdict.clear()：删除字典内所有元素
1 >>> dic1
2 {'a': 1, 'c': 3, 'b': 2}
3 >>> dic1.clear()
4 >>> dic1
5 {}
6 >>>
2、radiansdict.copy()：返回一个字典的浅复制
1 >>> dic3
2 {'y': 7, 'r': 5, 'e': 3}
3 >>> dic3.copy()
4 {'y': 7, 'r': 5, 'e': 3}
5 >>> dic3
6 {'y': 7, 'r': 5, 'e': 3}
7 >>>
3、radiansdict.fromkeys()：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4、radiansdict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值
1 >>> dict1.get('zhangxueyou','not any')
2 'not any'
3 >>>
5、radiansdict.has_key(key)：如果键在字典dict里返回true，否则返回false
1 >>> dict1
2 {'lisi': 321000, 'wangwu': 123878, 'wyl': 888888, 'zhangsan': 100}
3 >>> dict1.has_key('wangwu')
4 True
5 >>> dict1.has_key('wang')
6 False
7 >>>
6、radiansdict.items()：以列表返回可遍历的(键, 值) 元组数组
1 >>> dict1.items()
2 [('lisi', 321000), ('wangwu', 123878), ('wyl', 888888), ('zhangsan', 100)]
3 >>>
7、radiansdict.keys()：以列表返回一个字典所有的键
1 >>> list2 = {'a':1,'b':2,'c':3,'d':4}
2 >>> list2
3 {'a': 1, 'c': 3, 'b': 2, 'd': 4}
4 >>> list2.keys()
5 ['a', 'c', 'b', 'd']
6 >>>
8、radiansdict.setdefault(key, default=None)：和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
9、radiansdict.update(dict2)：把字典dict2的键/值对更新到dict里
10、radiansdict.values()：以列表返回字典中的所有值
1 >>> list2
2 {'a': 1, 'c': 3, 'b': 2, 'd': 4}
3 >>> list2.values()
4 [1, 3, 2, 4]
5 >>>
四，set
本来，打算只讲一下字典，元组，列表的一些基本用法，但是现在扩展探讨一下python中的set的用法：
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
要创建一个set，需要提供一个list作为输入集合：
1 >>> s = set([1,2,3,4,5,6,7,8,9]) 2 >>> s 3 set([1, 2, 3, 4, 5, 6, 7, 8, 9]) 4 >>>
注意，传入的参数[1, 2, 3]是一个list，而显示的set([1, 2, 3])只是告诉你这个set内部有1，2，3这3个元素，显示的[]不表示这是一个list。
重复元素在set中自动被过滤：
1 >>> s = set([1,2,3,4,5,6,7,8,9])
2 >>> s
3 set([1, 2, 3, 4, 5, 6, 7, 8, 9])
4 >>> s = set([1,2,3,4,5,6,7,8,9,1,2,3,3,4,5,6,7,89,97,7])
5 >>> s
6 set([1, 2, 3, 4, 5, 6, 7, 8, 9, 97, 89])
7 >>>
这一点，有点想数学中的集合的互异性类似。
在此，你还可以使用add()方法添加元素到set找你刚，当你重复添加的时候是不会报错的，只是不会在set中看到重复的值，它会自己过虐掉的。
1 >>> s
2 set([1, 2, 3, 4, 5, 6, 7, 8, 9, 97, 89])
3 >>> s.add(100)
4 >>> s.add(100)
5 >>> s.add(123)
6 >>> s.add(321)
7 >>> s
8 set([1, 2, 3, 4, 5, 6, 7, 8, 9, 321, 97, 89, 123, 100])
9 >>>
若你想删除set中的值，你可以使用方法remove(key)达到你想要的效果。
1 >>> s
2 set([1, 2, 3, 4, 5, 6, 7, 8, 9, 321, 97, 89, 123])
3 >>> s.remove(1)
4 >>> s
5 set([2, 3, 4, 5, 6, 7, 8, 9, 321, 97, 89, 123])
6 >>>
set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：
1 >>> s1 = set([1,2,3,4,5,6,7,8,9])
2 >>> s1
3 set([1, 2, 3, 4, 5, 6, 7, 8, 9])
4 >>> s2 = set([4,2,3,6])
5 >>> s2
6 set([2, 3, 4, 6])
7 >>> s1 & s2
8 set([2, 3, 4, 6])
9 >>> s1 | s2
10 set([1, 2, 3, 4, 5, 6, 7, 8, 9])
11 >>>
set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。
