引言
python为我们提供了5种基本的数据结构：list, tuple, dict, set，字符串；
有时候我们需要维护一个有序的dict。所以这个时候我们就要用到Python标准库为我们提供的collections包了，它提供了多个有用的集合类，熟练掌握这些集合类，不仅可以让我们让写出的代码更加pythonic，也可以提高我们程序的运行效率。
defaultdict：
defaultdict(default_factory)在普通的dict(字典)之上添加了default_factory，使得key(键)不存在时会自动生成相应类型的value(值)，default_factory参数可以指定成list, set, int等各种合法类型。
|
1
2
|
>>>
from
collections
import
defaultdict
>>> s
=
[(
'red'
,
1
), (
'blue'
,
2
), (
'red'
,
3
), (
'blue'
,
4
), (
'red'
,
1
), (
'blue'
,
4
)]
|
例1：将default_factory设置为list
我们现在有上面这样一组list(列表)，虽然我们有6组数据，但是仔细观察后发现其实我们只有两种color(颜色)，但是每一个color对应多个值。现在我们想要将这个list转换成一个dict(字典)，这个dict的key(键)对应一种color，dict的value(值)设置为一个list存放color对应的多个值。我们可以使用defaultdict(list)来解决这个问题。
|
1
2
3
4
5
6
7
|
# d可以看作一个dict(字典)，dict的value是一个list(列表)
>>> d
=
defaultdict(
list
)
>>>
for
k,v
in
s:
... d[k].append(v)
...
>>> d
defaultdict(<
class
'list'
>, {
'blue'
: [
2
,
4
,
4
],
'red'
: [
1
,
3
,
1
]})
|
例2：将default_factory设置为set
上面这个例子中有一些不完美的地方，比如说{‘blue’: [2, 4, 4], ‘red’: [1, 3, 1]}这个defaultdict中blue颜色中包含两个4，red颜色中包含两个1，但是我们不希望含有重复的元素，这个时候可以考虑使用defaultdict(set)来解决这个问题。set(集合)相比list(列表)的不同之处在于set中不允许存在相同的元素。
|
1
2
3
4
5
6
|
>>> d
=
defaultdict(
set
)
>>>
for
k,v
in
s:
... d[k].add(v)
...
>>> d
defaultdict(<
class
'set'
>, {
'blue'
: {
2
,
4
},
'red'
: {
1
,
3
}})
|
例3：将default_factory设置为int
通过使用defaultdict(int)的形式我们来统计一个字符串中每个字符出现的个数。
|
1
2
3
4
5
6
7
|
>>> s
=
'hello world'
>>> d
=
defaultdict(
int
)
>>>
for
k
in
s:
... d[k]
+
=
1
...
>>> d
defaultdict(<
class
'int'
>, {
'o'
:
2
,
'h'
:
1
,
'w'
:
1
,
'l'
:
3
,
' '
:
1
,
'd'
:
1
,
'e'
:
1
,
'r'
:
1
})
|
OrderedDict:
我们知道默认的dict(字典)是无序的，但是在某些情形我们需要保持dict的有序性，这个时候可以使用OrderedDict，它是dict的一个subclass(子类)，但是在dict的基础上保持了dict的有序型，下面我们来看一下使用方法。
|
1
2
3
|
>>>
from
collections
import
OrderedDict
# 无序的dict
>>> d
=
{
'banana'
:
3
,
'apple'
:
4
,
'pear'
:
1
,
'orange'
:
2
}
|
例1：这是一个无序的dict(字典)，现在我们可以使用OrderedDict来让这个dict变得有序。
|
1
2
3
4
5
6
7
8
9
|
# 将d按照key来排序
>>> OrderedDict(
sorted
(d.items(), key
=
lambda
t: t[
0
]))
OrderedDict([(
'apple'
,
4
), (
'banana'
,
3
), (
'orange'
,
2
), (
'pear'
,
1
)])
# 将d按照value来排序
>>> OrderedDict(
sorted
(d.items(), key
=
lambda
t: t[
1
]))
OrderedDict([(
'pear'
,
1
), (
'orange'
,
2
), (
'banana'
,
3
), (
'apple'
,
4
)])
# 将d按照key的长度来排序
>>> OrderedDict(
sorted
(d.items(), key
=
lambda
t:
len
(t[
0
])))
OrderedDict([(
'pear'
,
1
), (
'apple'
,
4
), (
'orange'
,
2
), (
'banana'
,
3
)])
|
例2：使用popitem(last=True)方法可以让我们按照LIFO(先进后出)的顺序删除dict中的key-value，即删除最后一个插入的键值对，如果last=False就按照FIFO(先进先出)删除dict中key-value。
|
1
2
3
4
5
6
7
8
9
10
11
|
>>> d
=
{
'banana'
:
3
,
'apple'
:
4
,
'pear'
:
1
,
'orange'
:
2
}
# 将d按照key来排序
>>> d
=
OrderedDict(
sorted
(d.items(), key
=
lambda
t: t[
0
]))
>>> d
OrderedDict([(
'apple'
,
4
), (
'banana'
,
3
), (
'orange'
,
2
), (
'pear'
,
1
)])
# 使用popitem()方法来移除最后一个key-value对
>>> d.popitem()
(
'pear'
,
1
)
# 使用popitem(last=False)来移除第一个key-value对
>>> d.popitem(last
=
False
)
(
'apple'
,
4
)
|
例3：使用move_to_end(key, last=True)来改变有序的OrderedDict对象的key-value顺序，通过这个方法我们可以将排序好的OrderedDict对象中的任意一个key-value插入到字典的开头或者结尾。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
>>> d
=
OrderedDict.fromkeys(
'abcde'
)
>>> d
OrderedDict([(
'a'
,
None
), (
'b'
,
None
), (
'c'
,
None
), (
'd'
,
None
), (
'e'
,
None
)])
# 将key为b的key-value对移动到dict的最后
>>> d.move_to_end(
'b'
)
>>> d
OrderedDict([(
'a'
,
None
), (
'c'
,
None
), (
'd'
,
None
), (
'e'
,
None
), (
'b'
,
None
)])
>>> ''.join(d.keys())
'acdeb'
# 将key为b的key-value对移动到dict的最前面
>>> d.move_to_end(
'b'
, last
=
False
)
>>> ''.join(d.keys())
'bacde'
|
Counter：
例1：Counter也是dict的一个subclass，它是一个无序容器，可以看做一个计数器，用来统计相关元素出现的个数。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
>>>
from
collections
import
Counter
>>> cnt
=
Counter()
# 统计列表中元素出现的个数
>>>
for
word
in
[
'red'
,
'blue'
,
'red'
,
'green'
,
'blue'
,
'blue'
]:
... cnt[word]
+
=
1
...
>>> cnt
Counter({
'blue'
:
3
,
'red'
:
2
,
'green'
:
1
})
# 统计字符串中元素出现的个数
>>> cnt
=
Counter()
>>>
for
ch
in
'hello'
:
... cnt[ch]
=
cnt[ch]
+
1
...
>>> cnt
Counter({
'l'
:
2
,
'o'
:
1
,
'h'
:
1
,
'e'
:
1
})
|
例2：使用elements()方法按照元素的出现次数返回一个iterator(迭代器)，元素以任意的顺序返回，如果元素的计数小于1，将忽略它。
|
1
2
3
4
5
6
7
8
9
10
|
>>> c
=
Counter(a
=
4
, b
=
2
, c
=
0
, d
=
-
2
)
>>> c
Counter({
'a'
:
4
,
'b'
:
2
,
'c'
:
0
,
'd'
:
-
2
})
>>> c.elements()
<itertools.chain
object
at
0x7fb0a069ccf8
>
>>>
next
(c)
'a'
# 排序
>>>
sorted
(c.elements())
[
'a'
,
'a'
,
'a'
,
'a'
,
'b'
,
'b'
]
|
例3：使用most_common(n)返回一个list, list中包含Counter对象中出现最多前n个元素。
|
1
2
3
4
5
|
>>> c
=
Counter(
'abracadabra'
)
>>> c
Counter({
'a'
:
5
,
'b'
:
2
,
'r'
:
2
,
'd'
:
1
,
'c'
:
1
})
>>> c.most_common(
3
)
[(
'a'
,
5
), (
'b'
,
2
), (
'r'
,
2
)]
|
namedtuple:
使用namedtuple(typename, field_names)命名tuple中的元素来使程序更具可读性。
|
1
2
3
4
5
6
7
8
9
|
>>>
from
collections
import
namedtuple
>>> Point
=
namedtuple(
'PointExtension'
, [
'x'
,
'y'
])
>>> p
=
Point(
1
,
2
)
>>> p.__class__.__name__
'PointExtension'
>>> p.x
1
>>> p.y
2
|
