Python基本数据类型——字典

字典 dict

字典是Python的另外一种有序的可变数据结构，且可存储任意类型对象。

字典是一种键值对的数据容器，每一个键值(key：value)对用冒号(:)分割，每一个对之间用逗号(,)分割，整个字典包括在花括号“{}”中。键和值二者一一对应，与表不一样的是，词典的元素没有顺序，不能经过下标引用元素。字典是经过键来引用。

字典中的键必须是惟一的同时不可变的，值则没有限制。

建立 dict

>>> dict1 = {'key1':'value1' , 'key2':'value2' , 'key3':'value3'}
>>> dict1
{'key3': 'value3', 'key2': 'value2', 'key1': 'value1'}

字典中的键必须是惟一的,类型是不可变类型。所以，也能够经过以下方式建立

>>> dict1 = {'key1':'value1' , 'key2':'value2' , 3:'value3'} 
>>> dict1
{'key2': 'value2', 'key1': 'value1', 3: 'value3'}

甚至：

>>> t = (1,2,3) # 元组是不可变的类型，能够做为键
>>> dict1 = {'key1':'value1' , t:'value2' , 3:'value3'}
>>> dict1      
{'key1': 'value1', 3: 'value3', (1, 2, 3): 'value2'}

因为一个key只能对应一个value，屡次对一个key放入value，后面的值会把前面的值覆盖掉：

>>> dict1['key4'] = 'VALUE4'
>>> dict1
{'key3': 'value3', 'key2': 'value2', 'key1': 'value1', 'key4': 'VALUE4'}

把数据放入dict的方法，除了初始化时指定外，还能够经过key放入：

>>> dict1['key4'] = 'value4' 
>>> dict1
{'key3': 'value3', 'key2': 'value2', 'key1': 'value1', 'key4': 'value4'}

要避免key不存在的错误，有两种办法：

# 一是经过in判断key是否存在：
>>> 'value4' in dict1 
False

# 二是经过dict提供的get方法，若是key不存在，能够返回None，或者本身指定的value：
>>> dict1 = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
>>> dict1
{'key3': 'value3', 'key2': 'value2', 'key1': 'value1'}
>>> dict1['key5'] = dict1.get('value5','value5')
>>> dict1
{'key3': 'value3', 'key2': 'value2', 'key1': 'value1', 'key5': 'value5'}
>>>

注意：返回None的时候Python的交互式命令行不显示结果。

dict函数快速构造字典：

>>> zip(["a","b","c"],[4,5,6])
[('a', 4), ('b', 5), ('c', 6)]
>>> dict(zip(["a","b","c"],[4,5,6]))
{'a': 4, 'c': 6, 'b': 5}
>>> dict(name="lans",age="22")
{'age': '22', 'name': 'lans'}
>>>

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有如下几个特色：

1. 查找和插入的速度极快，不会随着key的增长而增长；
2. 须要占用大量的内存，内存浪费多。

而list相反：

1. 查找和插入的时间随着元素的增长而增长；
2. 占用空间小，浪费内存不多。

因此，dict是用空间来换取时间的一种方法。

dict能够用在须要高速查找的不少地方，在Python代码中几乎无处不在，正确使用dict很是重要，须要牢记的第一条就是dict的key必须是不可变对象。

这是由于dict根据key来计算value的存储位置，若是每次计算相同的key得出的结果不一样，那dict内部就彻底混乱了。这个经过key计算位置的算法称为哈希算法（Hash）。

要保证hash的正确性，做为key的对象就不能变。在Python中，字符串、整数等都是不可变的，所以，能够放心地做为key。而list是可变的，就不能做为key：

>>> key = [1, 2, 3]
>>> d[key] = 'a list'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

访问 dict 中的元素

dict在建立时就指定了key:value的关系，程序能够经过key来访问对应的元素。

>>> dict1 = {'key1':'value1' , 'key2':'value2' , 'key3':'value3'}
>>> dict1['key1']
'value1'

字典中的常见的方法：

• clear()：从字典中删除全部项

例：

>>> dict1.clear()
>>> dict1
{}

• copy()：建立并返回字典的一个浅拷贝（新字典中的元素是对原始字典中元素的引用）

例如：添加一个元素“a”，返回其在列表中个数

>>> d1 = {1:'a',2:'b',3:'c'}
>>> d2 = d1.copy()
# 用id()函数能够看出值是同一个对象
>>> id(d1[2])
140415073723656
>>> id(d2[2])
140415073723656
>>> 
# 但两个字典自己不是同一个对象
>>> id(d2)
140415072754216
>>> id(d1)
140415072754776
# 修改d2中的一个值，d1中的将不会被改变，此时d1[1]和d2[1]已经不是同一个对象了。
>>> d2[1]="A"
>>> d2
{1: 'A', 2: 'b', 3: 'c'}
>>> d1
{1: 'a', 2: 'b', 3: 'c'}

• get(key [ , returnValue])：返回key对应的值；若是key不在字典中，同时指定了returnValue，就返回指定的值。若是没有指定returnValue，就返回none。

• has_key(key)：若是key在字典中，就返回1，不然返回0

例如：

>>> d1 = {1:'a',2:'b',3:'c'}
>>> d1.has_key(1)
True
>>> d1.has_key(4)
False

• items()：返回一个由元组构成的列表，每一个元组包含一个键-值对

例如：

>>> d1.items()
[(1, 'a'), (2, 'b'), (3, 'c')]

• keys()：返回字典中全部键的列表

例如：

>>> d1.keys()
[1, 2, 3]

• values()：返回字典全部值的一个列表

例如：

>>> d1.values()
['a', 'b', 'c']

• popitem()：删除任意键-值对，并做为两个元素的一个元组返回。若是字典为空，会产生KeyError异常

• update(newdic)：未来自newdic的全部键-值对添加到当前字典中，并覆盖同名键的值

例如：

>>> d1 = {1:'a',2:'b',3:'c'}                
>>> d2 = {3:'A',4:'B',5:'C'}        
>>> d1.update(d2)    
>>> d1
{1: 'a', 2: 'b', 3: 'A', 4: 'B', 5: 'C'}

• pop(key)：指定key 删除对应的value

例如：

>>> d1.pop(1)
'a'
>>> d1
{2: 'b', 3: 'c'}
>>> d1.pop(3)
'c'
>>> d1
{2: 'b'}

• fromkeys(seq[, value]))：将seq中的元素做为key，返回一个字段。对应的value为可选的，默认为None

例如：

>>> dict = dict.fromkeys(seq)
>>> dict
{'age': None, 'name': None, 'sex': None}

• iterkeys()：返回字典键的一个迭代器

• itervalues()：返回字典值得一个迭代器

• iteritems()：返回键-值对的一个迭代器