Skip to main content

8.3. collections —容器数据类型

源代码: Lib/collections/__init__.py


该模块实现专门的容器数据类型,提供Python通用内置容器(dictlistsettuple)的替代方案。

namedtuple()

工厂函数用于创建带有命名字段的元组子类

deque

列表式容器,在两端有快速附加和弹出

ChainMap

类似于类的类,用于创建多个映射的单个视图

Counter

dict子类用于计算hashable对象

OrderedDict

dict子类,记住已添加的订单条目

defaultdict

dict子类调用一个工厂函数提供缺失值

UserDict

包装字典对象,更容易dict子类化

UserList

包装列表对象以方便列表子类化

UserString

包装字符串对象,更容易字符串子类化

在 3.3 版更改: 集合抽象基类 移动到 collections.abc 模块。为了向后兼容,它们在该模块中仍然可见。

8.3.1. ChainMap 对象

3.3 新版功能.

ChainMap 类提供用于快速链接多个映射,使得它们可以被视为单个单元。它通常比创建新字典和运行多个 update() 调用要快得多。

该类可以用于模拟嵌套的范围,并且在模板中非常有用。

class collections.ChainMap(*maps)

ChainMap 将多个项目或其他映射组合在一起,以创建单个可更新的视图。如果没有指定 maps,则提供单个空字典,使得新链总是具有至少一个映射。

底层映射存储在列表中。该列表是公共的,可以使用 maps 属性访问或更新。没有其他状态。

查找顺序搜索基础映射,直到找到一个键。相比之下,写入,更新和删除只对第一映射操作。

ChainMap 通过引用合并了底层映射。因此,如果其中一个底层映射更新,那些更改将反映在 ChainMap 中。

支持所有常用的字典方法。此外,还有一个 maps 属性,用于创建新子上下文的方法,以及用于访问除第一个映射之外的所有其他映射的属性:

maps

用户可更新的映射列表。该列表从第一搜索到最后搜索排序。它是唯一存储的状态,可以修改以更改搜索哪些映射。该列表应始终包含至少一个映射。

new_child(m=None)

返回一个新的 ChainMap,其中包含一个新的地图,其后是当前实例中的所有地图。如果指定 m,它将成为映射列表前面的新映射;如果未指定,则使用空字符串,以便对 d.new_child() 的调用等效于:ChainMap({}, *d.maps)。此方法用于创建可在不更改任何父映射中的值的情况下更新的子上下文。

在 3.4 版更改: 添加了可选的 m 参数。

parents

属性返回一个新的 ChainMap 包含当前实例中除第一个之外的所有地图。这对于跳过搜索中的第一个地图很有用。用例与 嵌套作用域 中使用的 nonlocal 关键字类似。这些用例也与用于内置 super() 功能的用例类似。对 d.parents 的引用等价于:ChainMap(*d.maps[1:])

参见

8.3.1.1. ChainMap 示例和食谱

本节介绍了使用链接映射的各种方法。

模拟Python的内部查找链的示例:

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}

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']                # Get first key in the chain of contexts
d['x'] = 1            # Set value in current context
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 类仅对链中的第一个映射进行更新(写入和删除),而查找将搜索完整链。然而,如果需要深度写入和删除,则很容易做出更新在链中更深的密钥的子类:

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
DeepChainMap({'zebra': 'black', 'snake': 'red'}, {}, {'lion': 'orange'})

8.3.2. 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 是用于计算hashable对象的 dict 子类。它是一个无序的集合,其中元素存储为字典键,其计数存储为字典值。计数允许为包括零或负计数的任何整数值。 Counter 类与其他语言的行李或多股集合类似。

元素从 iterable 计数或从另一个 mapping (或计数器)初始化:

>>> 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

计数器对象有一个字典接口,除了它们返回一个零计数的缺失项目,而不是提高 KeyError

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

将计数设置为零不会从计数器中删除元素。使用 del 完全删除它:

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

3.1 新版功能.

计数器对象支持除了所有字典可用的方法之外的三种方法:

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 最常见的元素及其计数从最常见到最少的列表。如果省略 nNonemost_common() 在计数器中返回 all 个元素。具有相等计数的元素是任意排序的:

>>> Counter('abracadabra').most_common(3)  
[('a', 5), ('r', 2), ('b', 2)]
subtract([iterable-or-mapping])

iterable 或从另一 mapping (或计数器)中减去元素。像 dict.update(),但减去计数,而不是替换它们。输入和输出都可以为零或负。

>>> 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})

3.2 新版功能.

通常的字典方法可用于 Counter 对象,除了两个对计数器工作不同。

fromkeys(iterable)

此类方法未针对 Counter 对象实现。

update([iterable-or-mapping])

元素从 iterable 计数或从另一个 mapping (或计数器)添加。像 dict.update(),但增加了计数,而不是替换它们。此外,iterable 预期是元件的序列,而不是 (key, value) 对的序列。

使用 Counter 对象的常见模式:

sum(c.values())                 # total of all counts
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 least common elements
+c                              # remove zero and negative counts

提供了用于组合 Counter 对象以产生多重集(具有大于零的计数的计数器)的若干数学运算。加法和减法通过加或减相应元素的计数来组合计数器。交叉和联合返回对应计数的最小值和最大值。每个操作都可以接受带有有符号计数的输入,但输出将排除计数为零或更少的结果。

>>> 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})

3.3 新版功能: 增加了对一元加,一元减和在位多元集操作的支持。

注解

计数器主要设计为使用正整数表示运行计数;但是,应注意不要不必要地排除需要其他类型或负值的用例。为了帮助这些用例,本节记录最小范围和类型限制。

  • Counter 类本身是一个字典子类,对其键和值没有限制。这些值旨在表示计数的数字,但您 could 在值字段中存储任何内容。

  • most_common() 方法仅需要值是可排序的。

  • 对于诸如 c[key] += 1 的就地操作,值类型仅需要支持加法和减法。因此,分数,浮点数和小数将工作,负值支持。对于 update()subtract() 也是如此,其允许输入和输出的负值和零值。

  • 多重集方法仅用于具有正值的用例。输入可以是负或零,但是仅创建具有正值的输出。没有类型限制,但值类型需要支持加,减和比较。

  • elements() 方法需要整数计数。它忽略零和负数。

参见

  • 袋类 在Smalltalk。

  • 多重集 的维基百科条目。

  • C++多集 教程与示例。

  • 有关多重集的数学运算及其用例,请参阅 Knuth,唐纳德。计算机编程艺术II卷,第4.6.3节,练习19

  • 要枚举给定元素集合上给定大小的所有不同多重集,请参阅 itertools.combinations_with_replacement()

    map(Counter,combinations_with_replacement(’ABC’,2)) - > AA AB AC BB BC CC

8.3.3. deque 对象

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

返回从左到右初始化(使用 append())和 iterable 数据的新deque对象。如果未指定 iterable,则新deque为空。

Deques是栈和队列的泛化(名称发音为“deck”,是“double-ended queue”的缩写)。 Deques支持线程安全,内存高效的附加和从队列的任一边的弹出,在任一方向上具有大致相同的O(1)性能。

虽然 list 对象支持类似的操作,但它们被优化用于快速固定长度操作,并且对于改变基础数据表示的大小和位置的 pop(0)insert(0, v) 操作产生O(n)存储器移动成本。

如果 maxlen 没有指定或是 None,deques可以增长到任意长度。否则,deque限制为指定的最大长度。一旦有界长度deque充满,当添加新项目时,从相对端丢弃相应数量的项目。边界长度deques提供类似于Unix中的 tail 滤波器的功能。它们还可用于跟踪只有最近活动感兴趣的事务和其他数据池。

Deque对象支持以下方法:

append(x)

x 添加到deque的右侧。

appendleft(x)

x 添加到deque的左侧。

clear()

从deque中删除所有元素,留下长度为0。

copy()

创建一个浅拷贝的deque。

3.5 新版功能.

count(x)

计数等于 x 的deque元素的数量。

3.2 新版功能.

extend(iterable)

通过添加可迭代参数中的元素来扩展deque的右侧。

extendleft(iterable)

通过在 iterable 中添加元素来扩展deque的左侧。注意,左边的序列导致可逆参数中元素的顺序颠倒。

index(x[, start[, stop]])

返回在deque中的 x 的位置(在索引 start 或之后,索引 stop 之前)。如果找不到,返回第一个匹配或提高 ValueError

3.5 新版功能.

insert(i, x)

x 插入位置 i 处的Deque。

如果插入将导致有界的deque增长超过 maxlen,则产生 IndexError

3.5 新版功能.

pop()

从deque的右侧删除并返回一个元素。如果没有元素,则提出 IndexError

popleft()

从deque的左边删除并返回一个元素。如果没有元素,则提出 IndexError

remove(value)

删除 value 的第一次出现。如果没有找到,提出一个 ValueError

reverse()

反转deque的元素,然后返回 None

3.2 新版功能.

rotate(n)

将Deque n 步骤向右旋转。如果 n 为负,则向左旋转。向右旋转一步相当于:d.appendleft(d.pop())

Deque对象还提供一个只读属性:

maxlen

如果无界的最大尺寸的deque或 None

3.1 新版功能.

除了上述,deques支持迭代,酸洗,len(d)reversed(d)copy.copy(d)copy.deepcopy(d),使用 in 运算符的成员资格测试,以及下标引用如 d[-1]。索引访问在两端是O(1),但是在中间缓慢到O(n)。对于快速随机访问,请使用列表。

从版本3.5开始,deques支持 __add__()__mul__()__imul__()

例:

>>> 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'])

8.3.3.1. deque 食谱

本节介绍使用deques的各种方法。

边界长度deques提供类似于Unix中的 tail 过滤器的功能:

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

使用deques的另一种方法是通过附加到右边并弹出到左边来保持最近添加的元素的序列:

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

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

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

要实现 deque 切片,使用类似的方法应用 rotate() 将目标元素带到deque的左侧。用 popleft() 删除旧条目,用 extend() 添加新条目,然后反转旋转。通过该方法的微小变化,易于实现Forth样式堆栈操作,例如 dupdropswapoverpickrotroll

8.3.4. 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,则调用它时不带参数以为给定的 key 提供默认值,此值将插入到 key 的字典中,并返回。

如果调用 default_factory 引发异常,则该异常不会被传播。

当找不到请求的密钥时,该方法由 dict 类的 __getitem__() 方法调用;无论它返回还是提高,然后由 __getitem__() 返回或提高。

注意,__missing__() 是除了 __getitem__() 之外的任何操作的 not。这意味着 get() 像正常字典一样,返回 None 作为默认值,而不是使用 default_factory

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

default_factory

此属性由 __missing__() 方法使用;它从第一个参数初始化为构造函数(如果存在)或 None (如果不存在)。

8.3.4.1. defaultdict 示例

使用 list 作为 default_factory,很容易将键值对的序列分组到列表的字典:

>>> 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])]

当第一次遇到每个键时,它不在映射中;因此使用返回空 listdefault_factory 函数自动创建一个条目。然后,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)]

当首次遇到字母时,映射中缺少字母,因此 default_factory 函数调用 int() 以提供默认计数为零。增量操作然后建立每个字母的计数。

始终返回零的函数 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})]

8.3.5. 带有命名字段的元组的 namedtuple() 工厂函数

命名元组为元组中的每个位置分配含义,并允许更可读,自我文档化的代码。它们可以在使用常规元组的地方使用,并且它们添加了通过名称而不是位置索引访问字段的功能。

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

返回一个名为 typename 的新元组子类。新的子类用于创建元组样对象,其具有可通过属性查找访问的字段以及可索引和可迭代。子类的实例还有一个有用的docstring(带有typename和field_names)和一个有用的 __repr__() 方法,它以 name=value 格式列出元组内容。

field_names 是单个字符串,每个字段名称由空格和/或逗号分隔,例如 'x y''x, y'。或者,field_names 可以是诸如 ['x', 'y'] 的串的序列。

任何有效的Python标识符都可以用于字段名,除了以下划线开头的名称。有效标识符由字母,数字和下划线组成,但不以数字或下划线开头,不能为 keyword,例如 classforreturnglobalpassraise

如果 rename 为true,则无效字段名称将自动替换为位置名称。例如,['abc', 'def', 'ghi', 'abc'] 转换为 ['abc', '_1', 'ghi', '_3'],删除关键字 def 和重复字段名称 abc

如果 verbose 为true,类定义将在构建之后打印。此选项已过时;相反,打印 _source 属性更为简单。

如果定义了 module,则将命名的元组的 __module__ 属性设置为该值。

命名的元组实例没有每实例字典,因此它们是轻量级的,并且不需要比常规元组更多的内存。

在 3.1 版更改: 添加了对 rename 的支持。

在 3.6 版更改: verboserename 参数变为 仅关键字参数

在 3.6 版更改: 添加了 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)

命名元组对于将字段名称分配给 csvsqlite3 模块返回的结果元组尤其有用:

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()

返回一个新的 OrderedDict,它将字段名映射到相应的值:

>>> p = Point(x=11, y=22)
>>> p._asdict()
OrderedDict([('x', 11), ('y', 22)])

在 3.1 版更改: 返回 OrderedDict 而不是常规 dict

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._source

一个带有纯Python源代码的字符串,用于创建命名的tuple类。源使命名的元组自我记录。它可以打印,使用 exec() 执行,或保存到文件并导入。

3.3 新版功能.

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)

要检索名称存储在字符串中的字段,请使用 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__ 字段来定制Docstrings:

>>> 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'

在 3.5 版更改: 属性文档字符串变得可写。

可以通过使用 _replace() 定制原型实例来实现默认值:

>>> Account = namedtuple('Account', 'owner balance transaction_count')
>>> default_account = Account('<owner name>', 0.0, 0)
>>> johns_account = default_account._replace(owner='John')
>>> janes_account = default_account._replace(owner='Jane')

参见

8.3.6. OrderedDict 对象

有序字典与常规字典类似,但它们记住项目插入的顺序。在对有序字典进行迭代时,项目按它们的键首次添加的顺序返回。

class collections.OrderedDict([items])

返回一个dict子类的实例,支持通常的 dict 方法。 OrderedDict 是记住键首次插入顺序的dict。如果新条目覆盖现有条目,则原始插入位置保持不变。删除条目并重新插入会将其移动到结束。

3.1 新版功能.

popitem(last=True)

有序字典的 popitem() 方法返回并删除(键,值)对。如果 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'

3.2 新版功能.

除了通常的映射方法之外,有序字典还支持使用 reversed() 的反向迭代。

OrderedDict 对象之间的平等性测试是顺序敏感的,并且实现为 list(od1.items())==list(od2.items())OrderedDict 对象和其他 Mapping 对象之间的平等测试与常规字典一样是顺序不敏感的。这允许在使用常规字典的任何地方替换 OrderedDict 对象。

OrderedDict 构造函数和 update() 方法都接受关键字参数,但是它们的顺序丢失,因为Python的函数调用语义使用常规的无序字典传递关键字参数。

在 3.5 版更改: OrderedDict 的项,键和值 视图 现在支持使用 reversed() 的反向迭代。

8.3.6.1. OrderedDict 示例和食谱

由于有序字典会记住其插入顺序,因此可以与排序结合使用以创建排序字典:

>>> # regular unsorted dictionary
>>> d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}

>>> # dictionary sorted by key
>>> OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

>>> # dictionary sorted by value
>>> OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

>>> # dictionary sorted by length of the key string
>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])

当删除条目时,新的排序字典维护它们的排序顺序。但是,当添加新键时,键将附加到结尾,并且不保留排序。

创建有序字典变体也是直接的,它记住了键是 last 插入的顺序。如果新条目覆盖现有条目,则原始插入位置将更改并移动到结束:

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

    def __setitem__(self, key, value):
        if key in self:
            del self[key]
        OrderedDict.__setitem__(self, key, value)

有序字典可以与 Counter 类组合,使得计数器首先遇到顺序元素:

class OrderedCounter(Counter, OrderedDict):
    'Counter that remembers the order elements are first encountered'

    def __repr__(self):
        return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))

    def __reduce__(self):
        return self.__class__, (OrderedDict(self),)

8.3.7. UserDict 对象

类,UserDict 充当字典对象的包装器。对这个类的需求已经部分地被直接从 dict 子类化的能力所取代;但是,此类可以更容易使用,因为底层字典可作为属性访问。

class collections.UserDict([initialdata])

模拟字典的类。实例的内容保存在常规字典中,可通过 UserDict 实例的 data 属性访问。如果提供 initialdata,则用其内容初始化 data;注意,不会保留对 initialdata 的引用,允许将其用于其他目的。

除了支持映射的方法和操作,UserDict 实例提供以下属性:

data

一个真正的字典,用于存储 UserDict 类的内容。

8.3.8. UserList 对象

这个类充当列表对象的包装器。它是一个有用的基类,为你自己的类列表类,可以从它们继承并覆盖现有的方法或添加新的。这样,可以向列表中添加新的行为。

对这个类的需求已经部分地被直接从 list 子类化的能力所取代;但是,此类可以更容易使用,因为底层列表可作为属性访问。

class collections.UserList([list])

模拟列表的类。实例的内容保存在常规列表中,可以通过 UserList 实例的 data 属性访问。实例的内容最初设置为 list 的副本,默认为空列表 []list 可以是任何可迭代的,例如真正的Python列表或 UserList 对象。

除了支持可变序列的方法和操作,UserList 实例提供以下属性:

data

一个真正的 list 对象,用于存储 UserList 类的内容。

子类要求: UserList 的子类期望提供一个构造函数,可以使用无参数或一个参数进行调用。列表操作返回一个新序列,尝试创建实际实现类的实例。为此,假设可以使用单个参数调用构造函数,该参数是用作数据源的序列对象。

如果派生类不希望遵守这个要求,这个类支持的所有特殊方法都需要被覆盖;请查阅来源,了解有关在这种情况下需要提供的方法的信息。

8.3.9. UserString 对象

类,UserString 充当字符串对象的包装器。对这个类的需求已经部分地被直接从 str 子类化的能力所取代;但是,此类可以更容易使用,因为底层字符串可作为属性访问。

class collections.UserString([sequence])

模拟字符串或Unicode字符串对象的类。实例的内容保存在常规字符串对象中,可以通过 UserString 实例的 data 属性访问。实例的内容最初设置为 sequence 的副本。 sequence 可以是 bytesstrUserString (或子类)或可以使用内置的 str() 函数转换为字符串的任意序列的实例。

在 3.5 版更改: 新方法 __getnewargs____rmod__casefoldformat_mapisprintablemaketrans