Python入门(六)：对象类型之字典

1. 字典特性

  列表是有序对象的集合，字典可以看作是无序对象的集合。差别就在于，列表通过偏移来存取数据，而字典通过键(key)来存取数据。字典主要有以下特点：

1). 无序集合、通过键来读取数据

Python中，字典的各项从左到右随机排序，以便快速查找。字典通过键(key)将一系列的值联系起来，因此字典有时候又叫关联数组(associated array) 或 散列表 (hash)。

2). 可变长度、异构以及任意嵌套

与列表类似，字典也可以可以实时增加、减少长度；可以包含不同类型的对象(异构)；可以嵌套列表以及其他字典(嵌套)

3). 可变映射类型

字典不支持用于字符串和列表中的序列操作，它通过键(key)实现到值(value)的映射，支持通过键(key)的索引赋值实现原处修改。

理解字典的最好方式，就是将它看做是一个 (键: 值) 对的集合，在一个字典中，键必须是唯一的，有点像函数的一一映射。和列表一样， 字典的存储是对象引用而不是拷贝。

2. 字典的常见操作

2.1 基础操作

• 创建字典

1. 通过{ key1: value1, key2 : value2… } 这种方式创建，或者通过dict( key1 = value1, key2 = value2, …) }来创建。

## 空字典
>>> d = {}
>>> d
{}

>>> d = {'name':'Bob','age':18,'gender':'male'}
>>> d
{'name': 'Bob', 'age': 18, 'gender': 'male'}

>>> d = dict (name='Bob', age = 18, gender = 'male')
>>> d
{'name': 'Bob', 'age': 18, 'gender': 'male'}

2. 通过dict.fromkeys( [ iterabe [,value] ] )创建,其中iterable是一个可迭代对象，用于创建字典的键，value是键对应的值。需要注意的是，value赋值是把整个value赋值给每一个键。

>>> iterable = ['name','age','gender']
>>> d1 = dict.fromkeys(iterable)
>>> d1
{'name': None, 'age': None, 'gender': None}

## 赋值
>>> d2 = dict.fromkeys(iterable,values)
>>> d2
{'name': ['Bob', 18, 'male'], 'age': ['Bob', 18, 'male'], 'gender': ['Bob', 18, 'male']}

3. 通过dict([ (key1, value1), (key2, value2)… ])来创建，也就是包含键值对的元组的列表来创建。

>>> d = dict([('name','Bob'),('age',18)])
>>> d
{'name': 'Bob', 'age': 18}

4. 通过dict( zip ( keylist, valuelist ) ] )创建，其中，keylist是键的列表，valuelist是值的列表，这样子就可以实现，键列表和值列表的一一映射。

>>> keylist = ['name','age','gender']
>>> valuelist = ['Bob', 18, 'male']
>>> d = dict(zip(keylist, valuelist))
>>> d
{'name': 'Bob', 'age': 18, 'gender': 'male'}

如果keylist中元素数目不等于valuelist，那么将以二者中元素数目较少的，按顺序完成keylist所有键到valuelist的值的映射。

## keylist < valuelist
>>> keylist = ['name','age']
>>> valuelist = ['Bob', 18, 'male']
>>> d = dict(zip(keylist, valuelist))
>>> d
{'name': 'Bob', 'age': 18}

## keylist > valuelist
>>> keylist = ['name','age','gender']
>>> valuelist = ['Bob', 18]
>>> d = dict(zip(keylist, valuelist))
>>> d
{'name': 'Bob', 'age': 18}

• 字典对键和值的操作

1. 按键索引与get方法索引
   注意，按键索引时，输入的键不存在，会发生报错。但是get方法不会发生报错， d.get (key [,default ] )也是根据键来索引，如果键不存在，则返回default，default默认为None，因此不会发生报错。

## 按键索引
>>> d = dict (name='Bob', age = 18, gender = 'male')
>>> d ['name']
'Bob'

## 二维索引
>>> d2 = {'dict1': d, 'other': 1}
>>> d2['dict1']['name']
'Bob'

## get方法索引
>>> d.get('name')
'Bob'

>>> d.get('aaa','not exist')
'not exist'

2. 取出键和值. 通过d.keys(), d.values(), d.items()分别取出字典的键，值以及键和值组成的元组。注意返回的类型均为迭代器，而不是一个物理的列表，我们可能需要使用 list() 函数，以便我们将它们打印出来。

>>> d = dict (name='Bob', age = 18, gender = 'male')
>>> d.keys()
dict_keys(['name', 'age', 'gender'])
>>> type(d.keys())
<class 'dict_keys'>

>>> d.values()
dict_values(['Bob', 18, 'male'])
>>> type(d.values())
<class 'dict_values'>

>>> d.items()
dict_items([('name', 'Bob'), ('age', 18), ('gender', 'male')])
>>> type(d.items())
<class 'dict_items'>

##用列表的方式打印
>>> list(d.values())
['Bob', 18, 'male']

• 长度、成员关系
  内置函数len()能够返回字典的长度，字典的长度就是元素的数目，也等于keys的个数。
  通过 in 能判断字典中的键存在与否。

>>> d = dict (name='Bob', age = 18, gender = 'male')
>len(d)
3
>>> 'name' in d, 'other' in d
(True, False)

• 合并、增加、删除、修改字典

1. 合并字典
   通过d1.update(d2)实现字典的合并。

>>> d1 = dict(name = 'Bob', age = 18)
>>> d2 = dict(gender= 'male')
>>> d1.update(d2)
>>> d1
{'name': 'Bob', 'age': 18, 'gender': 'male'}

当两个字典中有相同的键的时候，若它们的值也相同，则保留其中一个；若它们的值不同，d1.update(d2)，字典d2的值会覆盖掉字典d1的值。

>>> d1 = dict(a = 1, b = 2, c =3 )
>>> d2 = dict(a = 1, b = 5, d = 5)
>>> d1.update(d2)
>>> d1
{'a': 1, 'b': 5, 'c': 3, 'd': 5}

2. 通过赋值修改和新增字典元素

>>> d = dict (name='Bob', age = 18, gender = 'male')
## 修改
>>> d1['name'] = 'Jack'
>>> d1
{'name': 'Jack', 'age': 18, 'gender': 'male'}

## 新增
>>> d1['height'] = 175
>>> d1
{'name': 'Jack', 'age': 18, 'gender': 'male', 'height': 175

3. 删除元素
   通过 d.pop(key) 或者del d[key] 来删除字典中的元素。前者会返回被删除的key对应的value，后者不会返回。

>>> d = dict (name='Bob', age = 18, gender = 'male')
## pop
>>> d.pop('name')
'Bob'
>>> d
{'age': 18, 'gender': 'male'}

## del
>>> del d['age']
>>> d
{'gender': 'male'}

因为 d.pop(key) 会返回值，因此同时使用赋值和 d.pop(key) ，我们可以实现字典中对键的修改。

>>> d = dict (name='Bob', age = 18, gender = 'male')
>>> d['firstname'] = d.pop('name')
>>> d
{'age': 18, 'gender': 'male', 'firstname': 'Bob'}

2.2 字典的排序和比较

2.2.1 字典排序

  我们使用sorted()函数对字典进行排序。
sorted(iterable, key =None, reverse = False).默认按照升序排列，根据ASCII码和Unicode的大小排列，最后返回iterable对象的列表形式。iterable为一个可迭代对象；key为比较方法，指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower， key = abs, key = len )；reverse为反向比较，默认为Fasle，如果为True,从右向左比较，结果与False的时候相反。

直接对字典排序(默认是对字典的键进行排序) 注意：key的类型不同的时候，比较会出错

>>> d = dict(a = 1, c=3, b=2)
>>> sorted(d)
['a', 'b', 'c']

对字典的value排序。注意：value类型不同的时候，比较会出错

>>> d = dict(a = 1, c=3, b=2)
sorted(d.values())
[1, 2, 3]

### 不同类型比较报错
>>> d2 = dict(a = 1, b = 2, c='a', d = 'abc', e = 'ba')
>>> sorted(d2.values())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'

对字典键值对(items)排序，排序准则依照列表和元组，可参见下一小节的字典比较。

>>> d2 = dict(a=1,b=2,f='a',aa='abc',e='ba')
>>> sorted(d2.items())
[('a', 1), ('aa', 'abc'), ('b', 2), ('e', 'ba'), ('f', 'a')]

2.2.2 字典比较

  Python3中，不支持字典与字典的直接比较，只能比较字典的键(keys)、值(values)以及键值对(items).

 因为dict.keys()返回的是dict_keys( [ key1, key2 … ] )， 而dict.values()返回的是dict_values( [ value1, value2] )。比较字典的键或者字典的值的大小，和比较列表大小一样。 比较的准则是，从前到后逐项比较，根据ASCII码以及Unicode进行比较，如果正在比较的值不等，则返回结果，如果相等，继续比较下一项。

 字典的键值对dict.items()返回dict_items( [ (key1 , value1) , (key2, value2) ] )，但是它也不能直接比较，否则返回的都是False。它需要使用sorted() 函数后再进行比较，也就是sorted(dict1.items() ) < sorted(dict2.items() )。 其比较的准则依照列表和元组，列表和元组的比较准则相同。

下面以列表的比较为例说明一下：

>>> l1 = ['abc',123]
>>> l2 =['abc',1234]
>>> l3 = ['abc']
>>> l4 = ['bcd']
>>> l1>l2
False
>>> l1>l3
True
>>> l1>l4
False