1.6 字典中的键映射多个值

问题

实现一个字典结构,一个键可以对应多个值

解决方案

1.列表和集合

1.>>> d
2.{‘b‘: [4, 5], ‘a‘: [1, 2, 3]}
3.>>> d[‘b‘]
4.[4, 5]
5.>>> e={‘a‘:{1,2,2,3},‘b‘:{2,3,4,4}}
6.>>> e
7.{‘b‘: {2, 3, 4}, ‘a‘: {1, 2, 3}}
8.>>> d[‘b‘][1]
9.5

2.使用defaultdict

1.>>> from collections import defaultdict
2.>>> d = defaultdict(list)
3.>>> d
4.defaultdict(<class ‘list‘>, {})
5.>>> d[‘a‘].append(1)
6.>>> d[‘a‘].append(2)
7.>>> d[‘a‘].append(5)
8.>>> d
9.defaultdict(<class ‘list‘>, {‘a‘: [1, 2, 5]})
10.>>> d2 = defaultdict(set)
11.>>> d2[‘a‘].add(1)
12.>>> d2[‘a‘].add(1)
13.>>> d2[‘a‘].add(2)
14.>>> d2
15.defaultdict(<class ‘set‘>, {‘a‘: {1, 2}})

知识补充

set,集合

1. python的set与数学概念上的集合是高度匹配的. 代表一个无序,无重复的元素集.数学集合上的概念在python的set数据类型中都有体现. 比如,支持合集,交集,差集.对称差集等

2. 集合支持x in set,len(set),for x in set等操作. 由于集合不记录位置信息,所以索引,切片等类序列的操作.

3. 集合有两种类型,常规的set和frozenset.set类型是可变的,可以通过add()和remove()进行增删,因此,常规类型的set并没有办法计算hash值,所以它不可以做字典的键.而frozenset是不可变的,可以计算hash.可以用于做字典的键.

4. 构建一个集合:{‘jack‘,‘tim‘}或者s=set([‘jack‘,‘tim‘])

   1.class set([iterable]) :
   2.
   3.class frozenset([iterable]): 
   4.
   5.
   6.#Return a new set or frozenset object whose elements are taken from iterable. The elements of a set must be hashable. To represent sets of sets, the inner sets must be frozenset objects. If iterable is not specified, a new empty set is returned.
   7.
   

5. Instances of set and frozenset provide the following operations:
   
   • len(s) 返回set长度
   • x in s/x not in s 成员操作符
   • isdisjoint(other) 两个集合是否不相交. 不相交返回True,相交返回False
   • s1<=s2,s1是s2的子集
   • s1<s2,s1是s2的真子集
   • issubset(other)
   • issuperset(other)
   • union(other, …) Return a new set with elements from the set and all others.
     
     • set | other | …
   • intersection(other, …) Return a new set with elements common to the set and all others.
     
     • set & other & …
   • difference(other, …) Return a new set with elements in the set that are not in the others.
     
     • set - other - …
   • symmetric_difference(other) Return a new set with elements in either the set or other but not both.
     
     • set ^ other
   • copy() Return a new set with a shallow copy of s.
6. 一个set和一个frozenset做union的时候,会返回一个frozenset
7. 只适用于set不使用于frozenset的方法:

1.update(other, ...) 
2.set |= other | ... 
3.#Update the set, adding elements from all others.
4.intersection_update(other, ...) 
5.set &= other & ... 
6.#Update the set, keeping only elements found in it and all others.
7.difference_update(other, ...) 
8.set -= other | ... 
9.#Update the set, removing elements found in others.
10.symmetric_difference_update(other) 
11.set ^= other 
12.#Update the set, keeping only elements found in either set, but not in both.
13.add(elem) 
14.#Add element elem to the set.
15.remove(elem) 
16.#Remove element elem from the set. Raises KeyError if elem is not contained in the set.
17.discard(elem) 
18.#Remove element elem from the set if it is present.
19.pop() 
20.#Remove and return an arbitrary element from the set. Raises KeyError if the set is empty.
21.clear() 
22.#Remove all elements from the set.

defaultdict
正常的字典,如果访问不存在的键,就会报KeyError,但是很多时候,我们需要字典中的每个键都存在默认值.

1.strings = (‘puppy‘, ‘kitten‘, ‘puppy‘, ‘puppy‘,‘weasel‘, ‘puppy‘, ‘kitten‘, ‘puppy‘)
2.counts = {}
3.for kw in strings:
4.    counts[kw] += 1

这是一段统计字符出现次数的代码,但是在python中这段代码是不可以运行的,会报KeyError.所以可以做一个改进

1.strings = (‘puppy‘, ‘kitten‘, ‘puppy‘, ‘puppy‘,‘weasel‘, ‘puppy‘, ‘kitten‘, ‘puppy‘)
2.counts = {}
3.for kw in strings:
4.    if kw not in counts:
5.        counts[kw] = 1
6.    else:
7.        counts[kw] += 1

或者可以使用default dict:

1.strings = (‘puppy‘, ‘kitten‘, ‘puppy‘, ‘puppy‘,‘weasel‘, ‘puppy‘, ‘kitten‘, ‘puppy‘)
2.counts = {}
3.for kw in strings:
4.    counts.setdefault(kw, 0)
5.    counts[kw] += 1

setdefault()接受两个参数,一个键的名称,一个默认值. 还有一种比较好的表达方式,但是不容易理解

1.strings = (‘puppy‘, ‘kitten‘, ‘puppy‘, ‘puppy‘,‘weasel‘, ‘puppy‘, ‘kitten‘, ‘puppy‘)
2.counts = {}
3.for kw in strings:
4.    counts[kw] = counts.setdefault(kw, 0) + 1

python提供了一个专门的类来处理defaultdict: collections.defaultdict

1. 初始化,defaultdict()接受一个类型作为初始化参数.

1.>>> from collections import defaultdict
2.>>> dd=defaultdict(list)
3.>>> dd
4.defaultdict(<class ‘list‘>, {})

1. 当访问的键不存在的时候,会自动初始化一个默认值.

1.>>> dd[‘tim‘]
2.[]
3.>>> dd[‘jerry‘]=26
4.>>> dd
5.defaultdict(<class ‘list‘>, {‘jerry‘: 26, ‘tim‘: []})
6.>>> dd[‘jerry‘]=27
7.>>> dd
8.defaultdict(<class ‘list‘>, {‘jerry‘: 27, ‘tim‘: []})
9.>>> dd[‘tim‘].append(22)
10.>>> dd
11.defaultdict(<class ‘list‘>, {‘jerry‘: 27, ‘tim‘: [22]})
12.>>> 

这种形式的默认值只有在通过dict[key]或者dict.getitem(key)访问的时候才有效

1. defaultdict除了接受类型作为参数外,也可以以不带参数的可调用函数作为参数.

1.>>> from collections import defaultdict
2.>>> def zero():
3....     return 0
4....
5.>>> dd = defaultdict(zero)
6.>>> dd
7.defaultdict(<function zero at 0xb7ed2684>, {})
8.>>> dd[‘foo‘]
9.0
10.>>> dd
11.defaultdict(<function zero at 0xb7ed2684>, {‘foo‘: 0})

来解决最初的单词统计问题

1.from collections import defaultdict
2.strings = (‘puppy‘, ‘kitten‘, ‘puppy‘, ‘puppy‘,‘weasel‘, ‘puppy‘, ‘kitten‘, ‘puppy‘)
3.counts = defaultdict(lambda: 0)  # 使用lambda来定义简单的函数
4.for s in strings:
5.    counts[s] += 1

1. defaultdict类是如何实现的?
   关键在__missing__()方法,当是用__getitem__()方法获取不到值的时候,会调用__missing__()方法获取默认值.并将该键添加到字典中.

在dict的派生子类中,如果访问的键不存在时,d[key]会调用__missing__()方法来获取默认值. 但是在dict中,并未实现这一方法.

1.>>> class Missing(dict):
2.    def __missing__(self,key):
3.        return ‘missing‘    
4.>>> d=Missing()
5.>>> d[‘1‘]
6.‘missing‘

通过上面这个例子就可以看出来.__missing__()函数确实生效了.
另外,还可以进一步修改以达到defaultdict的效果:

1.>>> class Defaulting(dict):
2.    def __missing__(self,key):
3.        self[key]=‘default‘
4.        return ‘default‘
5.>>> dd=Defaulting()
6.>>> dd[‘1‘]
7.‘default‘
8.>>> dd
9.{‘1‘: ‘default‘}