13.python中的字典

　　字典其实和之前的元祖和列表功能相似，都是用来储存一系列对象的。也就是一种可变容器，或者是我所比喻的革新派的菜单。

　　但也不是完全相同，我在之前曾经将字典称为特殊的'序列'，是字典拥有序列的部分特性，但是又不符合序列的定义。

　　首先我们来看下字典是如何创建的：

a = {'a':1,'b':2,'c':2}
b = {}
c = dict(a=1)
print a
print b
print c

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAVEAAAA/CAIAAADWnWyLAAACvUlEQVR4nO3dXXaqMBQG0AyLCclwmA2jYTDeB/CnigRIoL2evZ9cS4qnLZ/J0QDpCkSSfrsA4FQyD7HIPMQi8xDLTOb7NqXU9tPD8cGCNdvUErmep38LFHjPfN+mphtuj+8PP1qzTS1/vJ6+Te+5rFfP0DVCT7HZzI8H1tA12aN1zTYf9e2mI/jIeoauSZPVNc2+1suoXreeM6cwfK2FzB9pHBH/yhE8dJfHzKasqip/vU/1yDwVvGW+zgTy/2q8n58trGrlj++r57ntgp1eMp//oOg+6yzOa6XM1yvoWtirXK/jL9W2KaU66XytR0tPsa3j/D2o5YmtNA2eyq2wt+LAXx9z8Rr7etuHcZ4KtvfzUytePrBWyXy1BqFSnqq9J87Vo5+ngq2Zvz1bYZL58kL7DuhHHUPX7a5n6Jr7a9/2s6+eW1TLxvm5enaXBD8sfz8/Zxznm8ulWehZ108W7tvt/R77tqtc0ctvZE+mHe2rp++6fvyAIff7b61HM08dy+vwTlOj/a3pr9VztQ6PWqy3h1hkHmKReYhF5iEWmYdYZB5ikXmIReYhluy1sawDga+SW3trvSd8l+w5Ns7rgK8i8xBL9poZrtMAX2XFtbG09PBFjPMQi34eYpF5iMX38xCLdXgQi/X2EIvMQywyD7HIPMQi8xCLzEMsMg+xyDzEkl2Tk12RU2txrvU/cIbltbdr7s26936y76zzheMtnGOz5t6sRfdv7duXhDufBw6XPa/uGNMd1mUezpa9ZsY++z4IcH0OONyKa2P9NHRNmhujt5t7X9DSw8G2jvP3oJbPw43z8Au29/NTK14+0s9m3iAPx9qa+duzFSbhMg+/IHdtrHfjON9cLk36vOH6ycLTdpp5ON7yOrwzWYcHZ7DeHmKReYhF5iEWmYdYZB5ikXmIReYhFpmHWGQeYvkH84dcj4+pPLcAAAAASUVORK5CYII=" alt="" />

　　我们可以使用{} 或者dict() 来创建一个字典对象。

　　但字典里面写的是什么？下面我来分析一下。

　　首先，字典是以键值对的形式来储存对象的，即 key:value ,键和值之间用冒号分隔，而每个键值对之间用逗号分隔。

　　这个是时候可以联想一下序列的形式，在序列中，对象之间也是用逗号分隔的，但不同的是，序列是使用索引作为key，且索引是提取定义好的，按照一定顺序的。但是字典中，key是自定义的，相当于我们为对象起一个变量名，只不过变量名在字典的key中是以字符串的形式存在的，就像 c 中的创建方式，变量名为 a ，最终得到的键为 'a'。

　　那是不是字典的键就只能是字符串类型呢？并不是，我们也可以像序列一样用数字作为键。

a = {666:'scolia',}
print a

aaarticlea/png;base64,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" alt="" />

　　当然，为了提高代码可读性，我在只有单个对象的时候还是用了逗号。

　　元祖和列表也可以作为键吗？

aaarticlea/png;base64,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" alt="" />

　　答案是：NO!

　   虽说几乎所有类型的python对象都能作为键(只要该对象是可哈希的)，但是一般还是以数字或者字符串最为常用。

　　看到这里，我们可能会想字典无非就是高级一点的列表而已，为什么又不是序列呢？

　　因为字典是无序的。

　　我们看变量 a 中的字典：

a = {'a':1,'b':2,'c':2}

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMMAAAAeCAIAAAAevT0MAAABlklEQVR4nO2YW7KDIBBEZ1lsSJbDblgNi+F+gGgZw7NNILfPl1Uh2MJxmFI8IQjk2wHIj0CTCAaaRDDQJIKBJhEMNIlgoEkEA00iGGgSwUCTCAaaRDBUmWS1iGgbL8NFfnhxDIr/nOe0LRNQY5LVoozbr9NlZnx5DIrJ81gtr7uNy+OMmkalSpNCXGdUcQ1qxmTu1LQuT+ZxRkmkOtPtvS4VCJvnk+W2QJNJTxLe3lnWxZntqMJjqSCr9y7PWiZhSuhaDc3518FUlX/vy3NuPL5M0aRyW5fq7rAFIJNwgfzgae19eCitRQSz59c807RK4zUpbf+4B6CDIMYFzDaskT9OI8RcL3OsVJN8eUtiizNeBCAmwY5I0C7B3rS7PGv1SZVHOKDMXm7Ut0xHDmdMdx5nVLr3Pk9fnl2AsZp0l6c70iO0fk9687uIqG1TmV6gvrClcb3fXfapSqHzr8eJOFFfHmuMDY1b6flb80zUJPn2b9wfA9FWIJktj1/xGzchZWgSwUCTCAaaRDDQJIKBJhEMNIlg+ANd47w5a2J1YgAAAABJRU5ErkJggg==" alt="" />

　　我们在创建的时候明明是按一定顺序排列的，为什么输出的时候顺序却乱了？

　　这正是字典无序性的体现。

　　首先序列之所以被称为序列：正如其名，有序的、队列式的。我们在序列中逐一放入元素的时候，会自动的按照从左到右进行编号，也就是索引，而每一个索引对应一个对象。而字典却失去了索引的约束，用了自定义的键来取代，当我们在获取对象时也是用键名来获取，只要知道了键名，那么对象在字典中的哪个位置也无所谓了，所以字典是无序的，也就不能称为序列。

　　但我们依然可以将其想象为是一种高级的列表，只不过这个列表的索引是自定义的，无序的。

　　另外，当字典中的出现了同名的键会怎么办？

a = {'scolia': 1,'scolia':2,'scolia':3}
print a

aaarticlea/png;base64,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" alt="" />

　　就像变量命名一样，前面的都被冲突掉了。

　　这时又有同学问：不是说字典是无序的吗？我怎么知道谁在前谁在后？

　　我曾经把索引比作是特殊的变量名，只不过普通的变量名不能只是数字，而索引则是通过数字去内存取值。同理，字典里的键也可以看作是变量名，在字典里的元素打包成一个字典之前，先进行了变量的赋值操作，而对同一个变量进行多次赋值相当于切换其在内存的引用，只有最后一个赋值有效，这里也是一样的。在键值对创建的时候，按照我们写时候的顺序先进行赋值操作，然后保存在字典中，保存之后才是无序的。

　　那么值相同的时候是否也是同一个对象呢？

a = {'a':300,'b':300}
print id(a['a']),id(a['b'])

aaarticlea/png;base64,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" alt="" />

　　看来是的，和序列中的一样，也是节省内存的优化。

---

　　接下来我们就可以开始学习字典的内置方法了，首先按老规矩先使用 help(dict) 查看其帮助文档。

Help on class dict in module __builtin__:

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
 |
 |  Methods defined here:
 |
 |  __cmp__(...)
 |      x.__cmp__(y) <==> cmp(x,y)
 |
 |  __contains__(...)
 |      D.__contains__(k) -> True if D has a key k, else False
 |
 |  __delitem__(...)
 |      x.__delitem__(y) <==> del x[y]
 |
 |  __eq__(...)
 |      x.__eq__(y) <==> x==y
 |
 |  __ge__(...)
 |      x.__ge__(y) <==> x>=y
 |
 |  __getattribute__(...)
 |      x.__getattribute__('name') <==> x.name
 |
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |
 |  __gt__(...)
 |      x.__gt__(y) <==> x>y
 |
 |  __init__(...)
 |      x.__init__(...) initializes x; see help(type(x)) for signature
 |
 |  __iter__(...)
 |      x.__iter__() <==> iter(x)
 |
 |  __le__(...)
 |      x.__le__(y) <==> x<=y
 |
 |  __len__(...)
 |      x.__len__() <==> len(x)
 |
 |  __lt__(...)
 |      x.__lt__(y) <==> x<y
 |
 |  __ne__(...)
 |      x.__ne__(y) <==> x!=y
 |
 |  __repr__(...)
 |      x.__repr__() <==> repr(x)
 |
 |  __setitem__(...)
 |      x.__setitem__(i, y) <==> x[i]=y
 |
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |
 |  fromkeys(...)
 |      dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
 |      v defaults to None.
 |
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |
 |  has_key(...)
 |      D.has_key(k) -> True if D has a key k, else False
 |
 |  items(...)
 |      D.items() -> list of D's (key, value) pairs, as 2-tuples
 |
 |  iteritems(...)
 |      D.iteritems() -> an iterator over the (key, value) items of D
 |
 |  iterkeys(...)
 |      D.iterkeys() -> an iterator over the keys of D
 |
 |  itervalues(...)
 |      D.itervalues() -> an iterator over the values of D
 |
 |  keys(...)
 |      D.keys() -> list of D's keys
 |
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
 |      If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
 |      In either case, this is followed by: for k in F: D[k] = F[k]
 |
 |  values(...)
 |      D.values() -> list of D's values
 |
 |  viewitems(...)
 |      D.viewitems() -> a set-like object providing a view on D's items
 |
 |  viewkeys(...)
 |      D.viewkeys() -> a set-like object providing a view on D's keys
 |
 |  viewvalues(...)
 |      D.viewvalues() -> an object providing a view on D's values
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None
 |
 |  __new__ = <built-in method __new__ of type object>
 |      T.__new__(S, ...) -> a new object with type S, a subtype of T

dict

 　　按照其功能可分为：

　　1.大于、小于、等于等比较运算符

　　2.成员判断

　　3.内置函数相关的（参考这里）

　　4.增删改查相关操作

---

1.比较运算符

　　因为字典不是序列了，所以就不能像序列一样按照索引逐个打擂台了。

　　不过大小的比较规则还是一样的，只是上场的顺序未知而已。

　　那到底比较的时候顺序是怎么样的，看下面的例子。

a = {'a':1,'b':2,'c':3}
for x in a:
    print x

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAasAAABMCAIAAABcRQ+0AAAGlUlEQVR4nO3dy5WjOBSAYYWlECYRKwwcwWjnVU8GbEt7R8GGDJwEs+ClJ2AbKLfv/50+fbqqhST0uEiyy6U6AJBK/XYFAODXEAEByPV8BGzvWt/bd8ttjKqUqt27+eR8fg3P4Wq1QzvsUtbD6uXGbMx6U29J8xu2tvPuI2rXBjlutJw5Dp8XRcB+pF6VuirTFC55WH2z3g05M16iruaJDnmp/9q7VlVYllfnoaHjGr7q06bclt4JEhs39I5xXWtv2y58sWJjd5QabbkxH/ayOkm2pDmff++r9h1RD6v3yu2pu/iQnPcRRMDW3rR9dF3XdY0ph20vWTck7vu1vevFDm7t3fvfF0aDNwdcPT5OGzvW2Y3ZJTXc6u0aHmhj7wzmB+90F4fdjv+Qb+9aZUf8SY0Z9uCxV3Xdswuc3x9R+TsN72LPNjwu550EEdBfOnmlJt0WbzM3RsAonxdGg39JfHnQTC9uhN+v4XEeW3tnSJwuyg66nfAh72plapNZaZ7TmK+V8nLdnl3g/PqIWh0tpTSflvNuggi4vSRnohvzd6bDl8b1K7WrUvXP8I/+zzwhrb0pdZ3Xa8Mmt5/qw7lJnKZPmKxDbZjAr6EzlVK1MdWYzxk1DGSuutk2PBgK0qSeGQfBgzcTAeeDi3DtNpQ+tokbvlm+Ki6rb/Zwd9bnpm9a1X/sTamb1pXS9UVXQ4tNxc0VTlo1TpOrT9iDP4W7GE4DplOUTL9vao3w3hujKmNqpa7G1OU+bUwwDpORWSorHRtpg6RppiOj/oGUvdOoB1dbIzt6z885HgYrs3th4rwYATtXeydK6eSct2nOplNx+rIaa9x/f1zmzCu4NE3XZTe57h4HjriGlXFhzkfWMDQt36ZC+xjhH2ylaSLbI2DpwbuwGExLb4yqVHalv1TWkI8zY3TzW0zVP11jhiHe/11a0WdbdcsKPZNP4S4Wcs73crLbDe7dmf7Ga9c2rl1q1Xgc5r4TlpXWJ612doxV44qkuHPKLWMLrbE0ek/OObJxducVd8Fd+1i8crlZxyDl6vIaeGFmLk1ab3bNnFmeDJl8jqthrq2q5DnWR4HlNL7H1t6JT6ZKcz5am0Sll+JLshKJy4rWiUHpP8OX/t9RJZfrnDxo41Xzhig5Lyu2l17IJ1wLa3sPX+1daNWnBlLpv9IO3dKD4Tcz55i5p8jK6D035+JNLc/uvPIrIWsvGnrbzOLqQGU7zDWFLs8+e4M0rb1Nt7R2FhbVMH2KHlLDHC94DZFrfNbNu8U0TWxb72QfvPMqrK/q9NpRfF9z6Zl5mLsqLKu9X8aHU78mmnN2tdo5Aqb16co9mOQcnFlHVy308nI7V8ZGAyxt1TTnLWVtXwP6Y2yoYWamzHeanmMWWqNbGL1n5pzaOLvzSu+GWd1uTNvM8ZJ07+bqcLE2pjTNHP5NE+zVM+cCfpr//pkfGtfcUVe2hkMbaT2eDhxYw2mSh4ITmWmb0+TOAZffh7TWO7mXJuOTr+y7avzSvcMXr32Sq/ILwOCE1HXjmsvURlVK/zuelA1/e4df8Tly0KpxmsJd+D2Yv4vpXLK+6Mp7+1SVaw3/HDDMJ9fOztSuezjnlRX3aWNtY4NxGI7MUp3zZ8Rh16fjZ8wt04n5HsyliXMujN7Tcs4/1bbM7rx3fiYkXa8GcjvTk001LC0Sf72G+zrzvVef/j6vI+1476tbvLK1N5+t+Zr3AL41u4/4qbhmfi3mMwwvGgZrxs+qIWRKRuYW0/HZLm/7/+u9Obv5uWAAchEBAchFBAQgFxEQgFxEQAByEQEByEUEBCAXERCAXERAAHIRAQHIRQQEIBcREIBccQRsrVZKKaX41AAAXy+KgM4MoW/6BwB8rWQX7IxSrAIBiFBYA7ZWEwEBfLvCGlBfLlopzScwAvhmvBYMQC4iIAC5iIAA5CICApCLCAhALiIgALmIgADkIgICkIsICEAuIiAAuYiAAOQiAgKQiwgIQC4iIAC5kgjIx+QDECOKgNMno/Ip+QC+X+n3hADA9yutAbvWWkIhgO9W/E1JfEI+gK/Ha8EA5CICApCLCAhALiIgALmIgADkIgICkIsICEAuIiAAuYiAAOQiAgKQK4iAhk/FAiAJnw0DQC4iIAC5iIAA5MpEQGP4dCwAIqQRUBnXda3VhEAA3660C2Y7DOD7pRFQ25Y1IAAR4ghoret/XSYrQABfj58JASAXERCAXERAAHIRAQHIRQQEIBcREIBcREAAcv0P2PmCtWjhbQ4AAAAASUVORK5CYII=" alt="" />

　　我们使用for循环来看看比较时的顺序，可以看出，顺序是无可预估的，虽然这里只有三个键值对，貌似有一定的规律，但是一旦里面的对象多起来，就得不出规律了，而且不可能每次比较的时候都要自己看一下里面是怎么比的，那样实在太累，所以我们得出一个结论：少用字典间的比较，要比较用序列去。

　　另外这里补充一点：当我们使用for循环时，我们得到的是键名，如果我们要取到值怎么办？可以像下面这样写：

a = {'a':1,'b':2,'c':3}
for x in a:
    print a[x]

aaarticlea/png;base64,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" alt="" />

　　当然还有其他写法，看完内置方法后自己总结吧。

---

2.成员判断

1. in

　  在序列中判断里面有没有某个元素时使用的是 in ，但细心的同学会发现，在帮助文档中并没有出现 in ，是不是in不能用了呢？

　　看下面这个例子：

a = {'a':1,'b':2, 3:30}
b = 2
print b in a
print 2 in a
print 'b' in a
print 3 in a

aaarticlea/png;base64,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" alt="" />

　　还可以使用，但是这里 in 只能判断字典里是否有哪个键，而不是键对应的值。

2. D.has_key(k) -> True if D has a key k, else False

　　和 in 一样，判断里面是否有某个键，返回布尔值。

a = {'a':1,'b':2, 3:30}
print a.has_key('b')
print a.has_key(3)

aaarticlea/png;base64,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" alt="" />

3. D.__contains__(k) -> True if D has a key k, else False

　　判断是否有某个键，和上面的一样，就不多说明了。

4.判断字典里面是否有某个对象。

　　字典中并没有内置的方法能直接判断，但是我们可以自己写一个。

a = {'a':1,'b':2, 3:30}
b = 30
c = a.values()  #返回一个由字典的值组成的列表
print c     #同样我们无法预估字典里的顺序
print b in c

aaarticlea/png;base64,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" alt="" />

　　我们转了一个弯，这就要考验思维的灵活性了。

---

3.增

1. x.__setitem__(i, y) <==> x[i]=y

　 这个和列表中的不同，列表的这个写法是修改元素，如果给的索引不存在是会报错的。但在字典中，这个方法除了可以用来修改元素之外，如果给定的键不存在，则会在字典中创建这个键值对。

a = {'a':1,'b':2, 3:30}
a['scolia'] = 'good'
print a

aaarticlea/png;base64,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" alt="" />

2.  dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v. v defaults to None.

　　这个方法用于创建新的字典对象，我这里将其归类到这里。

　　其中，S 为一个键的序列，v为值，将为S所指定的所有键设置同一个值，默认为None。

a = dict.fromkeys(('scolia'),123)
b = dict.fromkeys(('scolia',))
print a
print b

aaarticlea/png;base64,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" alt="" />

　　注意S的写法，这就是为什么在元祖只有一个元素的时候一定要加一个逗号，否则解释器会将其当作传参，将字符串传进去，而字符串也是一个序列，所以没一个字符都被当做一个键，就造成了a的输出了。将S写成一个列表就不会有这样的错误，但元祖消耗的资源少，具体选择看个人。

a = dict.fromkeys(['scolia'],123)
print a

aaarticlea/png;base64,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" alt="" />

a = {'scolia': 1,'good':1,1:0}
print a.fromkeys(('k'),123)
print a

aaarticlea/png;base64,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" alt="" />

　　这里很特殊，创建的对象并没有添加到原字典中，而是所为一个返回值。

3. D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

　　这是一个集查询、修改、增加键值对的方法。

a = dict.fromkeys(['scolia'],123)
print a.setdefault('s',123)
print a

aaarticlea/png;base64,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" alt="" />

　　这里解释这个方法的细节：首先k是必须的参数，如果只给k一个参数，则d默认为None，也可以指定d的值。

a = dict.fromkeys(['scolia'],123)
print a.setdefault('scolia')
print a.setdefault('s')
print a

aaarticlea/png;base64,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" alt="" />

　　其执行顺序为：

　　1.先用给定的k看看里面有没有对应的键，有就返回这个键的值。

　　2.如果没有k这个键，则创建这个键，然后用d作为其值，如果d没给就默认为None（空对象）。

---

4.删

1. del x[y] 

　　用del关键字删除对象，在列表中讲过，只不过y从索引变成了键名。这里不再重复。

2.  D.clear() -> None. Remove all items from D.

　　删除整个字典里的元素，返回值为None。

a ={'scolia':123}
print a.clear()
print a

aaarticlea/png;base64,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" alt="" />

　　不需要传参，但要注意就算清空了字典里的所以元素，最后得到的还是一个空字典，而不是空对象None。

3. D.pop(k[,d]) -> v, remove specified key and return the corresponding value.

　　删除指定的键值对，并返回相应的值。如果没找到键返回d，若连d都没给，则触发KeyError错误。

a ={'scolia':123,123:321}
print a.pop(123)
print a.pop(666,'没找到')
print a.pop(999)

aaarticlea/png;base64,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" alt="" />

4. D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty.

　　删除字典中的第一个元素，并将其按一个元祖返回，如果字典为空则触发KeyError错误

a ={'scolia':123,123:321,555:777}
print a
print a.popitem()
print a

aaarticlea/png;base64,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" alt="" />

　　但还是那句话，字典中元素的顺序是未知的，谁知道第一个是什么，所以多配合迭代循环使用，逐个删除掉。

---

5.查

1. D.keys() -> list of D's keys

　　返回一个由键组成的列表

a ={'scolia':123,123:321,555:777}
print a.keys()

aaarticlea/png;base64,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" alt="" />

2. D.values() -> list of D's values

　　返回一个由值组成的列表

a ={'scolia':123,123:321,555:777}
print a.values()

aaarticlea/png;base64,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" alt="" />

3. D.items() -> list of D's (key, value) pairs, as 2-tuples

　　返回一个由键值组成的元祖的列表。

a ={'scolia':123,123:321,555:777}
print a.items()

aaarticlea/png;base64,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" alt="" />

4. D.iterkeys() -> an iterator over the keys of D

　　返回一个包含所有键的迭代对象

a ={'scolia':123,123:321,555:777}
b = a.iterkeys()
for x in b:
    print x

aaarticlea/png;base64,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" alt="" />

5. D.itervalues() -> an iterator over the values of D

　　返回一个包含所有值的迭代对象，原理同上，不再详细说明。

6. D.iteritems() -> an iterator over the (key, value) items of D

　　返回一个包含键值对元祖的迭代对象，同理。另外注意下元祖的迭代循环技巧。

7. D.viewkeys() -> a set-like object providing a view on D's keys

　　返回一个键的类似集合的对象。集合的作用是去除重复，但字典对于键的重复已经有相应处理，感觉意义不大。

a = {'scolia': 1,'scolia':2,1:123}
print a.viewkeys()
print type(a.viewkeys())

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAawAAAA8CAIAAAC1uxkMAAAIfElEQVR4nO2dy7HrKBCGCYsQJhEThlwTwLDzZmYy0PawdxTaqCYBJ6FZCEnQ3SCsl+Wj/6tbp+7xRTwa+GlamKv+AwCAC6P+BgCAC6M6AAC4MBBBAMClgQgCAC7NIhFsn1o/27VFN0ZVStVubT4S56/hMbhabWCHTcp6WZ03ZmPmTV2S5hOU2nnzEbWpQfYbLUeOw/fhItgP1rtSd2WaxFMvqx82aJMzwyPqbt7ok0Vd2D61quKygjp7W9MaLuVss66kd6LExvneMa5r7aPswYUVG7ojZbS8MV/2NjtPStIcT9j2WbYdUS+rt8rtrVacJOdtoCLY2oe2r67ruq4xafEOknU+cd+17VNn+7i1z+BfFwyIYBq4elhUGzvU2Q3ZsRqWsrqGO1LYO55p+R1bsVtzwqW+fWolDvqDjBn34L5Pdd27bs7nR5Tc0rgVW9pwv5w3gopg6EAFBbOeo/vNQhEk+SwYEOEj9PHIUgt3xOtruB+v0t7xiblrtlNz4qXe1crURvA3jzHmslIW1+1dN+fjI2p2tKTSnC3nzaAiWF6YM6Rt4RbV/2pc76/dlap//F/6P9OctPah1H3y2vxut5/tPoZC0/QJmTdq4wRhDZ2plKqNqYZ8jqhhhPDUw7ZxkChKw3lnKETLryCCUwQj9uB86YNNnP8w/RQtqzd7vE3rc9MPrep/7EOph9aV0vVNV95iY3FThZlVaRqpPnEP/iRa4cMCYzhF6Pcia8Rtb4yqjKmVuhtTp/u0MdE4ZCMzVRYfG9wgPM0YO+rXJLGlpAdnrSGO3uNzpsNgZnZnJs5yEexcHUSX+Pyc9mvO8tk4/loNle4/H5ydyY/jabpO3O26J9UOWsPKuDjnPWsYMzpxY6G9TIRBLp6GUC6CqeU34xLy0hujKiX6+7myfD7ODAIXWkzVP11j/Cjvf6b8etGqJX66kE+iFZmc5V5m296o7c70Da9d27g2Z1U6DqVP4rJ4fXi1xTFWDU5Jcv8kObMJa+RG78E5Ewpnt0xuO9y1r+zDecsOOuXqtDOcmZy5eRtMsAln8vNByGe/Gkq2qthq1gtBPk3Iq7R3aJQqNe2Jh0JKT0kM80doWcRbjEr/8b+GP0kl83Vmay31nQuEcnIuyktP5BN7xNo+4/e/Gau+NZBS/8Q7tKQH4w+FmKa0kMyM3mNzTjYqP7tlsi9G5l4jBvvNpI+gxD5zTaLXxRU4StPax9iqubgYqSFfS3epoUSgX168hhVv2jbyNJSy3hGX38kX66s6vkqi7ZpKF6ai9FRcVvu8DetT7xlNObtabSyCvD5dugdZzlH8mjyV6eW8nStjyQDjVuU5l5RV7gmGY8zXUJgpU0t5TDNhjS4zeo/MmVM4u2UyR2Rm9x3jfnN4hG/iXB27bENK00yLgGmifbsQIwjT/PvHtHTcpbCXWENvJq2HSMGONRzneUwUnRn3O40UE8wfTprrHellJY2CiUdtwtKDQExgH/aU7AZG0VLXDZ6XqY2qlP5riJr5n0EgjMaUI6vSNIlWhD0ot2KMUdY3XQVnqirJGmFMMM5HsrMztetezgVl0T5trG1sNA7jkZmqsxwvjruej58hN6ET5R6U0tCcE6P3sJzlha1kdsus/MYId1wjpC3qwYw1TLmKH6/hthx5Juvs57/2ZMO2z+710sydSJvj15wNXDW7d/raXDO9nTkH/jVi5Dmeq4bgmrCRWcIYStvkGwFfz8rZje8OAwAuDUQQAHBpIIIAgEsDEQQAXBqIIADg0kAEAQCXBiIIALg0Xy2Crb0F32E1SimllF5xcsoZ9cGDg6z01uq+TdPHUZMBAOtJiWA//4ILMlargzPRbF6PM5HeObteHUiWCxm0izR21oap0ltrXfibxglvALYj4wmGk3YTB2RTP4tpARdBZ94qrrV6CwkcC6eNzdswU3osgltJNQCg67piESyCTtbVGb6VVySCfm98pr3tcphdP7trB+B3saEIFmz3Npu7QlbMEzxZgG85fHGBCgKwGZII9m6U1rqfaaJXRWL2w1uJrP/lp24UHPT59Pu7oCT+1+idx3EiKJTO31dErZBKl2wovPaQgQgCsCNcBIfgVGt18sXI+G/h56WeYBCqGwNhY5hrincNoiZme5gISqE92vbAYjmZJp+Mv87WEyIIwI5wERQnZ2oCiw+m8O6Q5sdaAn/IK0n0UsO7pvH/dExfDuy2HSalZ9QtvySwT6bWvymCeEEMwHakPUFn0kdkJi8xmKBDGucSE9QnCN6SBr5T2w4SRk/nDOJGN5hEBedEcJkm8tJ529d5gpHHLUJFEBoIwIakY4LG+Nhd4K5Nc084mpw4HkdydX06EhNURB+EbFnOuXOCQp2XHSyRSudtj2OCwTNq3OUnbahvN50/4o1zggDsyBm/MVJ8vq/8GyPbngE8CnxjBID92UkEo7fFRa9Ag6fg6AAADuOMniAAABwGRBAAcGkgggCASwMRBABcGoggAODSQAQBAJcGIggAuDSfFcFvvAjgG+sMAEjyaRFMXSh/3sv9ca8zAL+K7KWq+3o8+a+ynfNyf7nOe1sKALAfKRGkkjF3df7mnPpy/2MzBwDsiCiC/KKS4yf5mS/3T+SPbTIAX4gggnQ2x1fn/0iX4P9pxru3khdMlfIFl/snwCVXAHwhmZulMx+Kl+D7G1P1dKseuTq/hK+43H+mCADAFyFuh+evhmeX4PMr5oWr8wv4jsv9szUHAHwThS9G+NX5/BQLuWJevDp/li+53D+ROQDg6yg8IiNdnR9tc51RWmt6C3Lh/ylJilVjgPHEl/vHmUMBAfhWlh+Wjmf+73GFoGgAXIoFIii8r+Xxto+Cy/0BAKXgAgUAwKWBCAIALg1EEABwaSCCAIBLAxEEAFwaiCAA4NL8DziIjqU8cXLwAAAAAElFTkSuQmCC" alt="" />

8.  D.viewvalues() -> an object providing a view on D's values

　　返回一个值的视图对象，注意不是集合对象，没有去重作用。

a = {'scolia': 1,'good':1,1:123}
print a.viewvalues()
print type(a.viewvalues())

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAbEAAABBCAIAAADQVw1LAAAImklEQVR4nO2dy5HrthKGERZCcCJCGFQ5AGOnzb3OgNvBzgtFwQ3LCSgJekG8GmiAEEVSlOb/6tSpGQ0ejdfPRhMixb8AAAAc4t0GAADAiRD/AwAA4BATAAAABzQRAAAC0EQAAAi8rInjXcr7+GopgxKdEL15tRyO81t4DKYXG/TDJnU9tKx35qCWu7olzTto7efNZ9SmHbLfbDlyHq6ironz3L0KcRVqKKe56aiJRrks4qqeGKJVIzrepehoXZHNtutTC9dytkXYMjoksTJ2dJSZRn1ry7jSMDccpU6rd+ZDXxaXTUua44nbvsi2M+qh5ValPdWKk5S8GTVNHPVN6sc0TdM0qLK0R8kmm3ge6fEuq0M+6nv01xXzI1oVpneX3EE7m40rLrOwlZct3JHG0bGEi7NvxW7NiR2B8S4FuwYO6kw6gvvmmqZnnaD3zyi+pbQVW/bhfiVvR00TY/cqsiMbyHRz2qiJSTkr5kecJc1OOm7l9vl1C/fj0To6NnHuuO3UHOoImF6oXjHe6DGdua6W1bY96wS9fUYtzpZSmrOVvCU1TWyv26ikqfF+1v6qzOzNXYXof+wP87+wRLW+CXENPp3dGs+L38Zf0jRzwsxX1TRBbKFRnRC9Up0r5wgLCUyumx5pgImkyXlmZpCLM6OJIdxB/Ttbu+sTYz8s50rrmrud7unm0uRNiv7/+ibETcpOyP4iO9tjvrpgcNaraRrOHjqCP4VW2BiCj70w497UG7TtgxKdUr0QV6X68pgOiszDbGaW6srnRt4heRofaJovUWxLkxFc7A129h5fcjoNFlZ3feFso4mT6aPIVL5cw+bO6Hxx+l8714b5c+cKBS8vTzNN7NbY3FMpSS3slKEl72khxbt4vtJZNeIAWZ4moV0TSxfnisOY1z4o0Ql2N1Cry5ZjlNO7uMdE/zMNyk76+f+S18/2aosXz5RTaEWlZH6Usz0yabtRc8N7Mw5mrPVqOg+5T2hduT252ewc65yPUtxdca5uoTdqs/fgkhMaV3eR1r3zND6qZdU72smW6cuec2Wt1pZxtN4CRtWXB1POfhZyfdVl17pZF+ppYh6to5NGuEoqkPgvSe0lxcm8lbSuxJcktf/YX+P/EyPrNmeX3tSzbtDN4Hq0114oh/rLUt/pneVKrz41kUp/yge0ZQTph0w8lLuuLMzeY0suNqq+uos032NZukEZbU6LHoRgh9AMhUnAXp9JmlHffCOXYmqJhfmVdhcLOSI5s1rmrodhj5mnSWkbHfbiHDy12VR/VyptV6idWZlcLlrXeL+4y9XsN4WSTS821sTcnqk8glnJJPad5KqMcr2fO6WTCZb3al5yS13tfmI8x6yFzEoJLc3joYXemCqz98iScxpXd5HGsziLmxS/OXVZ8h2f6alD51KqIVwi1ED2/Ex8IU7z9x/hwnLlQmashXOCm5QuyrCjhX7ZU0hkx2+OBi6eWD8FtTQ63G3QNILGnumJa4+COFH/ZLl4J5FEWs3k/DLVK9EJ+ZeLuNn/oyBaGo8mvZqmKbQiHkG+FT6+2V9kFx3e6rjeiOOJtByun43qzfQwJqorHdNB60GTeUhnZslmPtZMhz6fP640ZhD5EeTSpCUXZu9hJfPXuZbVXWTD77HkXi6B288ejLew5Ei+3cJtOfIs2AecO9uNDdu+uDEss3T0bYmvOZP46uo+4Lt9Q7jvcw7sDUriV57LQvA7yWZmCz4Mt8kXEz6e11c3vu8MAAABaCIAAASgiQAAEIAmAgBAAJoIAAABaCIAAASgiQAAEPhVmjjqS/TdXCWEEELIzzjVNWo52xvOWZHmAAA2oUUT5+UYPfJDHHG62YnAZnUZReTP6E8UlFFrE/8mcdAcgE1p9BNjHTzSPdlOfzP5yDXRqCiF98u8KjvHcoVOk5JfykU1MRN6AMCLrNDEJtK1u5LNNDEviGii1TtO940SQv3E4jNq2W5VWvKLubJ+PchrB+C3sJMmbrVSdywn8xPjNKWf1xm1rhVsrvxaA1EEYEuWNHF2WKS0nhHrvyTh/2iPWfCP5hTK2J9sGuYuAl3wPnGcy2ULW8hQP/nsKU0kjZPJjZmnJQiaCMDHUNdEJwhkt5gsQv+3qm+VFWz3pkGZfJZKOXkaL1l+b8tWvVITqSBWEtaBJgLwMdQ18SmdYjOWmNWGrvDg4LVrYuyUxrnSQzb5vYhFTTSqdE7nmEhCmybi1jMAm9LmJxpV1qngQ0br1aUxprhe022oy1LzSX2x3p7IkxtH6nnSvJko1jUxlppRa3KPJYhlo9i1XEUWc3lb0rgFJBGADWmLJyplBYw9j8Kcfm45XJid6bHu3eUihZD6n3AYRpBbvrE9Ux6GzA/R+OLL5xPTdpGYqHC7c8YhXTwJw/TYulyuA3A+EYA9wfdYVp/v44ON++TC91gAOIgDNJH6XEveIwAAvJFf5ScCAMAC0EQAAAhAEwEAIABNBACAADQRAAAC0EQAAAhAEwEAIHAeTfzWZxl8a7sA+E7OpIn89zs+/c0HeBI2AJ9E8zNl9xWi+jfePvfNB6WHjcFzBOCktGhiKg0bvVegnY9/88GBJQMAXmJRE/NHrxy/nj/9zQeFwrGnBuB8LGhiunDpewV+4ncRuB//VP5hXtEzZ7I3BDTxJW8+KIAnfQFwPhqfs135MMimeyKhe+JrCKblbwho4WvefFACO2gATsfi3pl5CWgWXpRSj9GNg8Y3BCzyPW8+qLYOAHAiVtxjyd8rkB+Xcf5d6if6NwS08EVvPmCqhyACcEZWnMXhju6RPbFRQkqZPhM6D9e1VCt8cPLD33xAq4IgAnBStjmzTRc5nCAAwKfyoiYyd4LtR2c5aII3HwAAnuA83+0DAID3A00EAIAANBEAAALQRAAACEATAQAgAE0EAIAANBEAAALQRAAACEATAQAgAE0EAIDAf0fYZD3sogMTAAAAAElFTkSuQmCC" alt="" />

9.  D.viewitems() -> a set-like object providing a view on D's items

　　返回一个由键和值组成的元祖的类集合对象。

a = {'scolia': 1,'good':1,1:123}
print a.viewitems()
print type(a.viewitems())

aaarticlea/png;base64,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" alt="" />

　　同样感觉意义不大，原因同上。

---

6.改

1. x[i]=y

　　和列表中的类似，只是 i 不是索引而是键名，当键名不存在时，就相当于新增键值对了。这里不重复说明了。

2. D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

　　上面讲过了，不再重复

3. D.update([E, ]**F) -> None.

　　从字典或可迭代对象E和F中，更新元素到字典D中。这里其实也可以归类到增加对象那里去，但字典的增操作和改操作其实很多方法是可以相通的，这里就放到这里了，让这里看起来不会太单薄。

　　这里的**F的写法其实是解决冗余参数的写法，详细我们会在函数中讲。

　　当E .key() 有方法时。

for k in E:
    D[k] = E[k]

　　即当E也是字典时，我们可以将一个字典添加到另一个字典中：

a = {'scolia': 1,'good':1}
b = {'scolia':2, 666:999}
a.update(b)
print a
print b

aaarticlea/png;base64,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" alt="" />

　　a中的同名键会被b的覆盖掉，且不会影响b本身。

　　当E没有.key()方法时。

for (k, v) in E：
    D[k] = v

　　即E为二元元祖序列，以二元元祖中的第一个元素为键，第二个元素为值，添加到字典中。

a = {'scolia': 1,'good':1,1:0}
b = [('a',123),('b',321),(1,1)]
a.update(b)
print a

aaarticlea/png;base64,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" alt="" />

　　所谓二元元祖序列，即里面放多个元祖，每个元祖只有两个元素，而其外层为序列，元祖、列表都行。

　　注意：有些同学在学完函数后可能会纠结，**F其实也算是一个字典，那我传进去的字典究竟是传给了谁？

　　　　首先**F是处理冗余参数的，要想有作用，首先参数要超过需要的，而当我们传一个字典或其他对象的时候，是传给了E，当传多个对象的时候，多出来的就到了**F中了，而**F中的对象这里并没有做处理，就相当于多出来的就扔到垃圾桶里去了。