数据结构的扩展库——collections

这个模块实现了特定目标的容器,以提供Python标准内建容器 dict , list , set , 和 tuple 的替代选择。

方法名说明
namedtuple()提供了一种类似字典的命名元组结构
deque类似列表(list)的容器,实现了在两端快速添加(append)和弹出(pop)
ChainMap可用于多字典查找键值或是设置查找优先级
Counter字典的子类,提供了可哈希对象的计数功能
OrderedDict有序字典,python3.7后由于dict已实现有序,故此类已用处不大
defaultdict字典的子类,可以为字典的键设置默认值

ChainMap

一个 ChainMap 类是为了将多个映射快速的链接到一起,这样它们就可以作为一个单元处理。它通常比创建一个新字典和多次调用 update() 要快很多。
这个类可以用于模拟嵌套作用域,并且在模版化的时候比较有用。
此方法可用于从多个可映射对象中查找某个键值对的时候使用,需要注意的是,对于同名的键,返回先出现的键值对。

class collections.ChainMap(*maps)
  • maps: 一个可以更新的映射列表。这个列表是按照第一次搜索到最后一次搜索的顺序组织的。它是仅有的存储状态,可以被修改。列表最少包含一个映射。

  • new_child(m=None): d.new_child() 调用等价于 ChainMap({}, *d.maps) 。这个方法用于创建子上下文,不改变任何父映射的值。

  • parents: d.parents 的引用等价于 ChainMap(*d.maps[1:]) 。

>>> baseline = {'music': 'bach', 'art': 'rembrandt'}
>>> adjustments = {'art': 'van gogh', 'opera': 'carmen'}
>>> list(ChainMap(adjustments, baseline))
['music', 'art', 'opera']

# 等价于
>>> combined = baseline.copy()
>>> combined.update(adjustments)
>>> list(combined)
['music', 'art', 'opera']
ChainMap的扩展用例
  • 模拟Python内部lookup链的例子
import builtins
pylookup = ChainMap(locals(), globals(), vars(builtins))
  • 让用户指定的命令行参数优先于环境变量,优先于默认值的例子
import os, argparse

defaults = {'color': 'red', 'user': 'guest'}

parser = argparse.ArgumentParser()
parser.add_argument('-u', '--user')
parser.add_argument('-c', '--color')
namespace = parser.parse_args()
command_line_args = {k: v for k, v in vars(namespace).items() if v is not None}

combined = ChainMap(command_line_args, os.environ, defaults)
print(combined['color'])
print(combined['user'])
  • 用 ChainMap 类模拟嵌套上下文的例子
c = ChainMap()        # Create root context
d = c.new_child()     # Create nested child context
e = c.new_child()     # Child of c, independent from d
e.maps[0]             # Current context dictionary -- like Python's locals()
e.maps[-1]            # Root context -- like Python's globals()
e.parents             # Enclosing context chain -- like Python's nonlocals

d['x'] = 1            # Set value in current context
d['x']                # Get first key in the chain of contexts
del d['x']            # Delete from current context
list(d)               # All nested values
k in d                # Check all nested values
len(d)                # Number of nested values
d.items()             # All nested items
dict(d)               # Flatten into a regular dictionary
  • ChainMap 类只更新链中的第一个映射,但lookup会搜索整个链。 然而,如果需要深度写和删除,也可以很容易的通过定义一个子类来实现它
class DeepChainMap(ChainMap):
    'Variant of ChainMap that allows direct updates to inner scopes'

    def __setitem__(self, key, value):
        for mapping in self.maps:
            if key in mapping:
                mapping[key] = value
                return
        self.maps[0][key] = value

    def __delitem__(self, key):
        for mapping in self.maps:
            if key in mapping:
                del mapping[key]
                return
        raise KeyError(key)

>>> d = DeepChainMap({'zebra': 'black'}, {'elephant': 'blue'}, {'lion': 'yellow'})
>>> d['lion'] = 'orange'         # update an existing key two levels down
>>> d['snake'] = 'red'           # new keys get added to the topmost dict
>>> del d['elephant']            # remove an existing key one level down
>>> d                            # display result
DeepChainMap({'zebra': 'black', 'snake': 'red'}, {}, {'lion': 'orange'})

Counter

一个计数器工具提供快速和方便的计数。比如

>>> # Tally occurrences of words in a list
>>> cnt = Counter()
>>> for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:
...     cnt[word] += 1
>>> cnt
Counter({'blue': 3, 'red': 2, 'green': 1})
>>> # Find the ten most common words in Hamlet
>>> import re
>>> words = re.findall(r'\w+', open('hamlet.txt').read().lower())
>>> Counter(words).most_common(10)
[('the', 1143), ('and', 966), ('to', 762), ('of', 669), ('i', 631),
('you', 554),  ('a', 546), ('my', 514), ('hamlet', 471), ('in', 451)]
class collections.Counter([iterable-or-mapping])

Counter 是dict 的子类,用于计数可哈希对象。它把元素作为键,把计数存储为值。计数可以是任何整数值,包括0和负数。 Counter 类有点像其他语言中的 bags或multisets。

Counter初始化:

>>> c = Counter()                           # a new, empty counter
>>> c = Counter('gallahad')                 # a new counter from an iterable
>>> c = Counter({'red': 4, 'blue': 2})      # a new counter from a mapping
>>> c = Counter(cats=4, dogs=8)             # a new counter from keyword args

Counter对象可以像dict一样调用,如果引用的键不存在,就返回一个0,而不是弹出一个 KeyError :

>>> c = Counter(['eggs', 'ham'])
>>> c['bacon']                              # count of a missing element is zero
0

把一个元素的值设为0不会从计数器中移去这个元素。要使用 del 来删除它:

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry

计数器对象除了字典方法以外,还提供了三个其他的方法:

  • elements(): 返回一个迭代器,其中每个元素将重复出现计数值所指定次。 元素会按首次出现的顺序返回。 如果一个元素的计数值小于1,elements() 将会忽略它。
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> sorted(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
  • most_common([n]):返回前n个出现次数最多的元素及其计数,按计数值由高到低排序。 如果 n 被省略或为 None,most_common() 将返回计数器中的 所有元素。 计数值相等的元素按首次出现的顺序排序:
>>> Counter('abracadabra').most_common(3)
[('a', 5), ('b', 2), ('r', 2)]
  • subtract([iterable-or-mapping]):从 迭代对象 或 映射对象 减去元素。类似dict.update() ,但是是减去,而不是替换。输入和输出都可以是0或者负数。
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> d = Counter(a=1, b=2, c=3, d=4)
>>> c.subtract(d)
>>> c
Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

除了下述两个方法外,Counter拥有与dict一样的方法。

  • fromkeys(iterable): 这个类方法没有在 Counter 中实现。

  • update([iterable-or-mapping]): 从 迭代对象 计数元素或者 从另一个 映射对象 (或计数器) 添加。 像 dict.update() 但是是加上,而不是替换。另外,迭代对象 应该是序列元素,而不是一个 (key, value) 对。

Counter 的扩展用例
sum(c.values())                 # 求和全部的计数值
c.clear()                       # reset all counts
list(c)                         # list unique elements
set(c)                          # convert to a set
dict(c)                         # convert to a regular dictionary
c.items()                       # convert to a list of (elem, cnt) pairs
Counter(dict(list_of_pairs))    # convert from a list of (elem, cnt) pairs
c.most_common()[:-n-1:-1]       # 取前n个计数最小的元素
+c                              # 移除计数小于1的元素

支持几个数学操作,每种操作都可以接受带符号的计数,但是输出会忽略掉计数为零或者小于零的元素。

>>> c = Counter(a=3, b=1)
>>> d = Counter(a=1, b=2)
>>> c + d                       # add two counters together:  c[x] + d[x]
Counter({'a': 4, 'b': 3})
>>> c - d                       # subtract (keeping only positive counts)
Counter({'a': 2})
>>> c & d                       # intersection:  min(c[x], d[x]) 
Counter({'a': 1, 'b': 1})
>>> c | d                       # union:  max(c[x], d[x])
Counter({'a': 3, 'b': 2})

单个加和减(一元操作符)意味着从空计数器加或者减去。

>>> c = Counter(a=2, b=-4)
>>> +c
Counter({'a': 2})
>>> -c
Counter({'b': 4})

注解: Counter主要是为了表达元素的引用次数而设计;但是,也不用刻意排除使用了负数或其他值的用例。为了兼容这些用例,本小节规定了取值范围与类型。

  • 因为Counter 类是字典的一个子类,所以它的值不仅可以是整数,也可以是其他类型的值。
  • most_common() 方法仅在值需要排序的时候使用。
  • 赋值运算如 c[key] += 1 ,值的类型仅要求支持加法和减法。 所以值的类型可以是分数,小数,或者其他十进制数字,甚至负值也可以支持。这两个方法 update() 和 subtract() 的输入和输出也一样支持负数和0。
  • 多集方法虽然可以接受负数或者0,但只输出计数为正的值。输入的值没有类型限制,但值类型需要支持加,减和比较操作。(我没搞懂multiset methods是指这一类方法还是multiset方法,以后搞懂了再来修正)
  • elements() 方法要求正整数计数。忽略0和负数计数。

deque

class collections.deque([iterable[, maxlen]])

Deque是“double-ended queue”的简称,意为双向队列。若iterable没有指定,则返回队列为空。
Deque 可以从两端进行pop和append的操作,且时间复杂度均为O(1)。
如果 maxlen 没有指定或者是 None ,deques 可以增长到任意长度。否则,deque就限定到指定最大长度。一旦限定长度的deque满了,当新项加入时,同样数量的项就从另一端弹出。

双向队列(deque)对象支持以下方法:

  • append(x):添加 x 到右端。

  • appendleft(x):添加 x 到左端。

  • clear():移除所有元素,使其长度为0.

  • copy():创建一份浅拷贝。

  • count(x):计算 deque 中元素等于 x 的个数。

  • extend(iterable):扩展deque的右侧,通过添加iterable参数中的元素。

  • extendleft(iterable):扩展deque的左侧,通过添加iterable参数中的元素。注意,左添加时,在结果中iterable参数中的顺序将被反过来添加。

  • index(x[, start[, stop]]):返回 x 在 deque 中的位置(在索引 start 之后,索引 stop 之前)。 返回第一个匹配项,如果未找到则引发 ValueError。

  • insert(i, x):在位置 i 插入 x 。如果插入会导致deque 超出长度 maxlen 的话,就引发一个 IndexError。

  • pop():移去并且返回一个元素,deque 最右侧的那一个。 如果没有元素的话,就引发一个 IndexError。

  • popleft():移去并且返回一个元素,deque 最左侧的那一个。 如果没有元素的话,就引发 IndexError。

  • remove(value):移除找到的第一个 value。 如果没有的话就引发 ValueError。

  • reverse():将deque逆序排列。返回 None 。

  • rotate(n=1):向右循环移动 n 步。 如果 n 是负数,就向左循环。如果deque不是空的,向右循环移动一步就等价于 d.appendleft(d.pop()) , 向左循环一步就等价于 d.append(d.popleft()) 。

Deque对象同样提供了一个只读属性:

  • maxlen:Deque的最大尺寸,如果没有限定的话就是 None 。

除了以上操作,deque 还支持迭代、封存、len(d)、reversed(d)、copy.copy(d)、copy.deepcopy(d)、成员检测运算符 in 以及下标引用例如通过 d[0] 访问首个元素等。 索引访问在两端的复杂度均为 O(1) 但在中间则会低至 O(n)。 如需快速随机访问,请改用List。

示例:

>>> from collections import deque
>>> d = deque('ghi')                 # make a new deque with three items
>>> for elem in d:                   # iterate over the deque's elements
...     print(elem.upper())
G
H
I

>>> d.append('j')                    # add a new entry to the right side
>>> d.appendleft('f')                # add a new entry to the left side
>>> d                                # show the representation of the deque
deque(['f', 'g', 'h', 'i', 'j'])

>>> d.pop()                          # return and remove the rightmost item
'j'
>>> d.popleft()                      # return and remove the leftmost item
'f'
>>> list(d)                          # list the contents of the deque
['g', 'h', 'i']
>>> d[0]                             # peek at leftmost item
'g'
>>> d[-1]                            # peek at rightmost item
'i'

>>> list(reversed(d))                # list the contents of a deque in reverse
['i', 'h', 'g']
>>> 'h' in d                         # search the deque
True
>>> d.extend('jkl')                  # add multiple elements at once
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> d.rotate(1)                      # right rotation
>>> d
deque(['l', 'g', 'h', 'i', 'j', 'k'])
>>> d.rotate(-1)                     # left rotation
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])

>>> deque(reversed(d))               # make a new deque in reverse order
deque(['l', 'k', 'j', 'i', 'h', 'g'])
>>> d.clear()                        # empty the deque
>>> d.pop()                          # cannot pop from an empty deque
Traceback (most recent call last):
    File "<pyshell#6>", line 1, in -toplevel-
        d.pop()
IndexError: pop from an empty deque

>>> d.extendleft('abc')              # extendleft() reverses the input order
>>> d
deque(['c', 'b', 'a'])
deque 的扩展用例

限长deque提供了类似Unix tail 过滤功能

def tail(filename, n=10):
    'Return the last n lines of a file'
    with open(filename) as f:
        return deque(f, n)

另一个用法是维护一个近期添加元素的序列,通过从右边添加和从左边弹出

def moving_average(iterable, n=3):
    # moving_average([40, 30, 50, 46, 39, 44]) --> 40.0 42.0 45.0 43.0
    # http://en.wikipedia.org/wiki/Moving_average
    it = iter(iterable)
    d = deque(itertools.islice(it, n-1))
    d.appendleft(0)
    s = sum(d)
    for elem in it:
        s += elem - d.popleft()
        d.append(elem)
        yield s / n

一个 轮询调度器 可以通过在 deque 中放入迭代器来实现。值从当前迭代器的位置0被取出并暂存(yield)。 如果这个迭代器消耗完毕,就用 popleft() 将其从对列中移去;否则,就通过 rotate() 将它移到队列的末尾

def roundrobin(*iterables):
    "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
    iterators = deque(map(iter, iterables))
    while iterators:
        try:
            while True:
                yield next(iterators[0])
                iterators.rotate(-1)
        except StopIteration:
            # Remove an exhausted iterator.
            iterators.popleft()

rotate() 方法提供了一种方式来实现 deque 切片和删除。 例如, 一个纯的Python del d[n] 实现依赖于 rotate() 来定位要弹出的元素

def delete_nth(d, n):
    d.rotate(-n)
    d.popleft()
    d.rotate(n)

要实现 deque 切片, 使用一个类似的方法,应用 rotate() 将目标元素放到左边。通过 popleft() 移去老的条目(entries),通过 extend() 添加新的条目, 然后反向 rotate。这个方法可以最小代价实现命令式的栈操作,诸如 dup, drop, swap, over, pick, rot, 和 roll 。

defaultdict

class collections.defaultdict([default_factory[, …]])

返回一个新的类字典对象。defaultdict是dict的子类,增加了一个可选变量。其余的功能与dict类相同。

第一个参数default_factory的默认值为None。其余参数都像传递给dict一样处理。

除了标准的dict操作外,defaultdict对象还支持以下方法作为扩展:

  • __missing__(key):
    如果 default_factory 为 None,则调用本方法会抛出 KeyError 异常,附带参数 key。
    如果default_factory不是None,则会调用default_factory()来为 key 提供一个默认值,这个值和 key 作为一对键值对被插入到字典中,并作为本方法的返回值返回。(这里要理解function和function()的区别。)
    如果调用default_factory()时抛出了异常,这个异常会原封不动地向外层传递。
    在无法找到所需键值时,本方法会被 dict 中的 __getitem__() 方法调用。无论本方法返回了值还是抛出了异常,都会被 __getitem__() 传递。
    注意,__missing__() 不会被 __getitem__() 以外的其他方法调用。意味着 get() 会像正常的 dict 那样返回 None,而不是使用 default_factory。

defaultdict对象支持以下实例变量:

  • default_factory:本属性由 __missing__() 方法来调用。如果构造对象时提供了第一个参数,则本属性会被初始化成那个参数,如果未提供第一个参数,则本属性为 None。
defaultdict 扩展用例

把default_factory设置为list,很容易将键-值对序列分组到list字典中:

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> for k, v in s:
...     d[k].append(v)

>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

每当添加一个新的键时,便会调用设置的默工厂函数,返回一个空的列表。然后,通过list.append()操作将值添加到对应的列表里。当再次遇到相同的键时,list.append()操作将向该键对应的列表添加另一个值。这种方法比使用dict.setdefault()更简单和更快:

>>> d = {}
>>> for k, v in s:
...     d.setdefault(k, []).append(v)

>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

将default_factory设置为int可以使defaultdict用于计数(类似其他语言中的bag或multiset):

>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> for k in s:
...     d[k] += 1

>>> sorted(d.items())
[('i', 4), ('m', 1), ('p', 2), ('s', 4)]

始终返回0的int()函数只是常量函数的一种特殊情况。创建常量函数的一个更快更灵活的方法是使用lambda函数,它可以提供任何常量值(不仅仅是零):

>>> def constant_factory(value):
...     return lambda: value
>>> d = defaultdict(constant_factory('<missing>'))
>>> d.update(name='John', action='ran')
>>> '%(name)s %(action)s to %(object)s' % d
'John ran to <missing>'

将default_factory设置为set使得defaultdict在构建集合字典时非常有用:

>>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
>>> d = defaultdict(set)
>>> for k, v in s:
...     d[k].add(v)

>>> sorted(d.items())
[('blue', {2, 4}), ('red', {1, 3})]

namedtuple()

命名元组赋予每个位置一个含义,提供可读性和自文档性。它们可以用于任何普通元组,并添加了通过名字获取值的能力,通过索引值也是可以的。

collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)

返回一个新的名为 typename的元组子类 。这个新的子类用于创建类似元组的对象,它不仅可以通过索引和迭代获取值,也可以通过字段名来获取属性值。

field_names 可以是一个像 [‘x’, ‘y’] 一样的字符串列表。另外 field_names 也可以是一个纯字符串,用空白或逗号分隔开元素名,比如 ‘x y’ 或者 ‘x, y’ 。

任何有效的Python 标识符都可以作为字段名,除了下划线开头的那些。有效标识符由字母,数字,下划线组成,但首字母不能是数字或下划线,另外不能是关键词 keyword 比如 class, for, return, global, pass, 或 raise 。

如果 rename 为True, 无效的字段名会自动转换成以位置命名。比如 [‘abc’, ‘def’, ‘ghi’, ‘abc’] 转换成 [‘abc’, ‘_1’, ‘ghi’, ‘_3’] , 移除了关键词 def 和重复字段名 abc 。

defaults 可以是 None ,也可以是一个可迭代对象 。如果defaults的长度小于命名域的长度,defaults 就被赋予到最右边的参数。比如如果域名 [‘x’, ‘y’, ‘z’] 和默认值 (1, 2) ,那么 x 就必须指定一个参数值 ,y 默认值 为1 , z 默认值为 2 。

如果 module 值有定义,命名元组的 module 属性值就被覆盖。

命名元组实例比起字典实例要更轻量,并且占用更小内存。

>>> # Basic example
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(11, y=22)     # instantiate with positional or keyword arguments
>>> p[0] + p[1]             # indexable like the plain tuple (11, 22)
33
>>> x, y = p                # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y               # fields also accessible by name
33
>>> p                       # readable __repr__ with a name=value style
Point(x=11, y=22)

命名元组在给csv sqlite3 模块返回的元组赋值的时候尤其有用。

EmployeeRecord = namedtuple('EmployeeRecord', 'name, age, title, department, paygrade')

import csv
for emp in map(EmployeeRecord._make, csv.reader(open("employees.csv", "rb"))):
    print(emp.name, emp.title)

import sqlite3
conn = sqlite3.connect('/companydata')
cursor = conn.cursor()
cursor.execute('SELECT name, age, title, department, paygrade FROM employees')
for emp in map(EmployeeRecord._make, cursor.fetchall()):
    print(emp.name, emp.title)

除了继承元组的方法,命名元组还支持三个额外的方法和两个属性。为了防止字段名冲突,方法和属性以下划线开始。

  • classmethod somenamedtuple._make(iterable)
    类方法从存在的序列或迭代实例创建一个新实例。
>>> t = [11, 22]
>>> Point._make(t)
Point(x=11, y=22)
  • somenamedtuple._asdict()
    返回一个新的 dict ,它将字段名称映射到它们对应的值:
>>> p = Point(x=11, y=22)
>>> p._asdict()
{'x': 11, 'y': 22}
  • somenamedtuple._replace(**kwargs)
    返回一个新的命名元组实例,并将指定域替换为新的值
>>>
>>> p = Point(x=11, y=22)
>>> p._replace(x=33)
Point(x=33, y=22)

>>> for partnum, record in inventory.items():
...     inventory[partnum] = record._replace(price=newprices[partnum], timestamp=time.now())
  • somenamedtuple._fields
    字符串元组列出了字段名。用于提醒和从现有元组创建一个新的命名元组类型。
>>> p._fields            # view the field names
('x', 'y')

>>> Color = namedtuple('Color', 'red green blue')
>>> Pixel = namedtuple('Pixel', Point._fields + Color._fields)
>>> Pixel(11, 22, 128, 255, 0)
Pixel(x=11, y=22, red=128, green=255, blue=0)
  • somenamedtuple._field_defaults
    字典将字段名称映射到默认值。
>>> Account = namedtuple('Account', ['type', 'balance'], defaults=[0])
>>> Account._field_defaults
{'balance': 0}
>>> Account('premium')
Account(type='premium', balance=0)

要获取这个名字域的值,使用 getattr() 函数 :

>>> getattr(p, 'x')
11

转换一个字典到命名元组,使用 ** 两星操作符 (所述如 解包参数列表):

>>>
d = {'x': 11, 'y': 22}
Point(**d)
Point(x=11, y=22)

因为一个命名元组是一个正常的Python类,它可以很容易的通过子类更改功能。这里是如何添加一个计算域和定宽输出打印格式:

>>> class Point(namedtuple('Point', ['x', 'y'])):
...     __slots__ = ()
...     @property
...     def hypot(self):
...         return (self.x ** 2 + self.y ** 2) ** 0.5
...     def __str__(self):
...         return 'Point: x=%6.3f  y=%6.3f  hypot=%6.3f' % (self.x, self.y, self.hypot)

>>> for p in Point(3, 4), Point(14, 5/7):
...     print(p)
Point: x= 3.000  y= 4.000  hypot= 5.000
Point: x=14.000  y= 0.714  hypot=14.018

上面的子类设置 __slots__ 为一个空元组。通过阻止创建实例字典保持了较低的内存开销。

子类化对于添加和存储新的名字域是无效的。应当通过 _fields 创建一个新的命名元组来实现它:

Point3D = namedtuple('Point3D', Point._fields + ('z',))

文档字符串可以自定义,通过直接赋值给 __doc__ 属性:

Book = namedtuple('Book', ['id', 'title', 'authors'])
Book.__doc__ += ': Hardcover book in active collection'
Book.id.__doc__ = '13-digit ISBN'
Book.title.__doc__ = 'Title of first printing'
Book.authors.__doc__ = 'List of authors sorted by last name'

OrderedDict

有序词典就像常规词典一样,但有一些与排序操作相关的额外功能。由于内置的 dict 类获得了记住插入顺序的能力(在 Python 3.7 中保证了这种新行为),它们变得不那么重要了。

class collections.OrderedDict([items])

返回一个 dict 子类的实例,它具有专门用于重新排列字典顺序的方法。

  • popitem(last=True):有序字典的 popitem() 方法移除并返回一个 (key, value) 键值对。 如果 last 值为真,则按 LIFO 后进先出的顺序返回键值对,否则就按 FIFO 先进先出的顺序返回键值对。

  • move_to_end(key, last=True):将现有 key 移动到有序字典的任一端。 如果 last 为真值(默认)则将元素移至末尾;如果 last 为假值则将元素移至开头。如果 key 不存在则会触发 KeyError:

>>> d = OrderedDict.fromkeys('abcde')
>>> d.move_to_end('b')
>>> ''.join(d.keys())
'acdeb'
>>> d.move_to_end('b', last=False)
>>> ''.join(d.keys())
'bacde'

相对于通常的映射方法,有序字典还另外提供了逆序迭代的支持,通过 reversed() 。

OrderedDict 之间的相等测试是顺序敏感的,实现为 list(od1.items())==list(od2.items()) 。 OrderedDict 对象和其他的 Mapping 的相等测试,是顺序敏感的字典测试。这允许 OrderedDict 替换为任何字典可以使用的场所。

OrderedDict 的扩展用例

创建记住键值 最后 插入顺序的有序字典变体很简单。 如果新条目覆盖现有条目,则原始插入位置将更改并移至末尾:

class LastUpdatedOrderedDict(OrderedDict):
    # 'Store items in the order the keys were last added'

    def __setitem__(self, key, value):
        super().__setitem__(key, value)
        self.move_to_end(key)

一个 OrderedDict 对于实现 functools.lru_cache() 的变体也很有用:

class LRU(OrderedDict):
    # 'Limit size, evicting the least recently looked-up key when full'

    def __init__(self, maxsize=128, /, *args, **kwds):
        self.maxsize = maxsize
        super().__init__(*args, **kwds)

    def __getitem__(self, key):
        value = super().__getitem__(key)
        self.move_to_end(key)
        return value

    def __setitem__(self, key, value):
        if key in self:
            self.move_to_end(key)
        super().__setitem__(key, value)
        if len(self) > self.maxsize:
            oldest = next(iter(self))
            del self[oldest]
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值