字典的定义

字典是Python中很常用到的一种数据结构。

字典是无序的。

是以key->value的形式存储的。

d = {}   使用大括号来定义一个空的字典
d = dict()   使用工厂函数来定义一个空的字典
d = {'a':1, 'b':2}   使用大括号来定义一个有值的字典
d = dict([('a',1),('b',2)])   可迭代对象的元素必须是一个二元组，二元组的第０个元素为key，第一个元素为value
d = dict({'c':3, 'd':4})   定义一个有元素的字典，有点麻烦，所以很少使用这个

使用fromkeys 定义一个字典
>>> d = dict.fromkeys(range(5))   传入的参数为key，默认value值为 None
>>> d
{0: None, 1: None, 2: None, 3: None, 4: None}

>>> d = dict.fromkeys(range(5),'abc')   传入的第一个可迭代参数为key， 值全都都是第二个参数的值
>>> d
{0: 'abc', 1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc'}

字典的基本操作

增加与修改

>>> d
{0: 'abc', 1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc'}
>>> d['a'] = 0   给某个不存在的下标赋值的话，就是给字典添加元素的，当值存在则修改元素
>>> d
{0: 'abc', 1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc', 'a': 0}

>>> d.update([('b',3),('c',4)])   update方法也可以给字典添加数据，传入的参数是可迭代对象
>>> d
{0: 'abc', 1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc', 'a': 0, 'b': 3, 'c': 4}

>>> d.update({'e':5,'f':6})   update也是可以接受一个字典作为参数，给字典添加元素，当key存在则修改key对应的value，通常用于合并字典的
>>> d
{0: 'abc', 1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc', 'a': 0, 'b': 3, 'c': 4, 'e': 5, 'f': 6}

删除

** ----pop删除key---- **
>>> d
{'w': 4, 's': 2}
>>> d.pop('w')   通过key删除dict中的元素，并且返回被删除元素的value值。
4
>>> d
{'s': 2}

>>> d.pop('w')   当删除一个不存在的key的时候，会抛出KeyError的错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'w'

>>> d.pop('w','default')   当删除不存在的key，并且指定了默认值时，不会抛出KeyError，并且返回默认值
'default'

** ----popitem删除key---- **
>>> d
{0: 'abc', 1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc'}
>>> d.popitem()   随机删除一个元素，并且返回一个二元组
(4, 'abc')
>>> d
{0: 'abc', 1: 'abc', 2: 'abc', 3: 'abc'}

>>> d
{}
>>> d.popitem()   对空字典 popitem 会抛出KeyError的异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'

** ----清空一个字典---- **
>>> d
{0: 'abc', 1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc'}
>>> d.clear()   清空一个字典
>>> d
{}

** ----del删除key---- **
>>> d
{0: 'abc', 1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc'}
>>> del d[0]   通过下标删除字典元素，通常不用del来删除key
>>> d
{1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc'}

访问

单个元素的访问

** ----直接通过下标访问key获取value---- **
>>> d 
{1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc'}
>>> d[1]   直接通过key访问value
'abc'

>>> d
{1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc'}
>>> d[0]   访问一个不存在的key的时候，会抛出KeyError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 0

** ----通过get获取字典value---- **
>>> d
{1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc'}
>>> d.get(1)   get方法通过key访问value
'abc'
>>> d.get(0)   get方法访问不存在的key的时候，返回默认值，默认值默认为None
>>> 
>>> d.get(0,'default')   第二个参数为默认值
'default'

** ----setdefault 方法---- **
>>> d
{0: 'a', 1: 'a', 2: 'a', 3: 'a', 4: 'a', 'a': 'default'}
>>> d.setdefault(0,'default')
'a'
>>> d
{0: 'a', 1: 'a', 2: 'a', 3: 'a', 4: 'a', 'a': 'default'}
直接使用代码原型表示出来：
def setdefault(d,k,default=None):
    value = d.get(k,default)
    d[k] = value
    return value
setdefault 就是给字典添加数据的时候，当key不存在的时候，则创建key->value，若是key存在，则返回key对应的value

字典的遍历

字典都是key->value，成对出现的。

** ----直接遍历---- **
>>> d
{0: 'a', 1: 'a', 2: 'a', 3: 'a', 4: 'a', 'a': 'default'}

>>> for i in d:
...     print(i)
... 
0
1
2
3
4
a
直接使用for in 遍历字典，遍历的是字典的key

** ----dict的values方法---- **
values 返回的是一个可迭代对象，元素是字典的所有的value
>>> d.values()
dict_values(['a', 'a', 'a', 'a', 'a', 'default'])

>>> for i in d.values():   可直接遍历出所有的value，但是没有对应的key
...     print(i)
... 
a
a
a
a
a
default

** ----dict的items方法---- **
>>> d.items()    items方法返回一个可迭代的对象，元素是字典的所有(k,v)对
dict_items([(0, 'a'), (1, 'a'), (2, 'a'), (3, 'a'), (4, 'a'), ('a', 'default')])

>>> for x in d.items():
...     print(x)
... 
(0, 'a')
(1, 'a')
(2, 'a')
(3, 'a')
(4, 'a')
('a', 'default')

做一个数据的解构，更加清晰的获取字典的key，value
>>> for k,v in d.items():
...     print(k,v)
... 
0 a
1 a
2 a
3 a
4 a
a default

** ----dict的keys方法---- **
>>> d.keys()   keys方法返回一个可迭代对象，元素是字典的所有的key
dict_keys([0, 1, 2, 3, 4, 'a'])

Python2 和 Python3中的区别

在Python2中items，keys，values，返回的是一个list，会复制一块内存空间。
在Python3中items，keys，values，返回的是一个生成器，是不会占用系统资源的。
因此在Python2中如果你需要遍历字典的时候，数据量达到千万级别的时候，那么你用items，keys，values，就是变得很慢。
但是在Python2中有类似和Python3中对应的不复制内存的方法：
    Python2中的 'iterkeys' 对应Python3中的 'keys'
    Python2中的 'itervalues' 对应Python3中的 'values'
    Python2中的 'iteritems' 对应Python3中的 'items'

字典的限制

字典的key不能重复

字典的key需要可hash

>>> d = {} 
>>> d[[1,2,3]] = 3   当使用list为key的时候，抛出TypeError的错误，list不能hash，因此不能为字典的key
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
依此类推，元组，bytearray，dict，set都是无法为字典的key