1.

collections是Python內建的一個集合模組，提供了許多有用的集合類。

namedtuple是一個函式，它用來建立一個自定義的tuple物件，並且規定了tuple元素的個數，並可以用屬性而不是索引來引用tuple的某個元素。

這樣一來，我們用namedtuple可以很方便地定義一種資料型別，它具備tuple的不變性，又可以根據屬性來引用，使用十分方便。

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
print(Point)
p = Point(1, 2)
print('
 
P:\n{}\nP.x:\n{}\nP.y:\n{}'.format(p, p.x, p.y))

/Users/cloud/.conda/envs/auto/bin/python /Users/cloud/PycharmProjects/ModuleProject/collections_module/1_collections.py
<class '__main__.Point'>
P:
Point(x=1, y=2)
P.x:
1
P.y:
2

Process finished with exit code 0

這個模組實現了特定目標的容器，以提供Python標準內建容器dict,list,set

Deprecated since version 3.3, will be removed in version 3.10:已將容器抽象基類移至collections.abc模組。 為了保持向下相容性，它們在 Python 3.9 版的這個模組中仍然存在。

ChainMap物件

3.3 新版功能.

一個ChainMap類是為了將多個對映快速的連結到一起，這樣它們就可以作為一個單元處理。它通常比建立一個新字典和多次呼叫update()要快很多。

這個類可以用於模擬巢狀作用域，並且在模版化的時候比較有用。

classcollections.ChainMap(*maps)

一個ChainMap將多個字典或者其他對映組合在一起，建立一個單獨的可更新的檢視。 如果沒有maps被指定，就提供一個預設的空字典，這樣一個新鏈至少有一個對映。

底層對映被儲存在一個列表中。這個列表是公開的，可以通過maps屬性存取和更新。沒有其他的狀態。

搜尋查詢底層對映，直到一個鍵被找到。不同的是，寫，更新和刪除只操作第一個對映。

一個ChainMap通過引用合併底層對映。 所以，如果一個底層對映更新了，這些更改會反映到ChainMap。

支援所有常用字典方法。另外還有一個maps屬性(attribute)，一個建立子上下文的方法(method)， 一個存取它們首個對映的屬性(property):

maps

一個可以更新的對映列表。這個列表是按照第一次搜尋到最後一次搜尋的順序組織的。它是僅有的儲存狀態，可以被修改。列表最少包含一個對映。

new_child(m=None)

返回一個新的ChainMap類，包含了一個新對映(map)，後面跟隨當前例項的全部對映(map)。如果m被指定，它就成為不同新的例項，就是在所有對映前加上 m，如果沒有指定，就加上一個空字典，這樣的話一個d.new_child()呼叫等價於ChainMap({},*d.maps)。這個方法用於建立子上下文，不改變任何父對映的值。

在 3.4 版更改:添加了m可選引數。

parents

屬性返回一個新的ChainMap包含所有的當前例項的對映，除了第一個。這樣可以在搜尋的時候跳過第一個對映。 使用的場景類似在nested scopes巢狀作用域中使用nonlocal關鍵詞。用例也可以類比內建函式super()。一個d.parents的引用等價於ChainMap(*d.maps[1:])。

注意，一個ChainMap()的迭代順序是通過掃描最後的對映來確定的:

>>>

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

這給出了與dict.update()呼叫序列相同的順序，從最後一個對映開始:

>>>

>>> combined = baseline.copy()
>>> combined.update(adjustments)
>>> list(combined)
['music', 'art', 'opera']

在 3.9 版更改:增加了對|和|=運算子的支援，相關說明見PEP 584。

參見

• MultiContext class在 EnthoughtCodeTools package有支援寫對映的選項。

• Django 的Context class模版是隻讀對映。它的上下文的push和pop特性也類似於new_child()方法parents屬性。

• Nested Contexts recipe提供了是否對第一個對映或其他對映進行寫和其他修改的選項。

• 一個極簡的只讀版 Chainmap.

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

classcollections.Counter([iterable-or-mapping])

一個Counter是一個dict的子類，用於計數可雜湊物件。它是一個集合，元素像字典鍵(key)一樣儲存，它們的計數儲存為值。計數可以是任何整數值，包括0和負數。Counter類有點像其他語言中的 bags或multisets。

元素從一個iterable被計數或從其他的mapping(or 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物件有一個字典介面，如果引用的鍵沒有任何記錄，就返回一個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

3.1 新版功能.

在 3.7 版更改:作為dict的子類，Counter繼承了記住插入順序的功能。Counter物件進行數學運算時同樣會保持順序。 結果會先按每個元素在運算子左邊的出現時間排序，然後再按其在運算子右邊的出現時間排序。

計數器物件除了字典方法以外，還提供了三個其他的方法：

elements()

返回一個迭代器，其中每個元素將重複出現計數值所指定次。 元素會按首次出現的順序返回。 如果一個元素的計數值小於一，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})

3.2 新版功能.

通常字典方法都可用於Counter物件，除了有兩個方法工作方式與字典並不相同。

fromkeys(iterable)

這個類方法沒有在Counter中實現。

update([iterable-or-mapping])

從迭代物件計數元素或者 從另一個對映物件(或計數器) 新增。 像dict.update()但是是加上，而不是替換。另外，迭代物件應該是序列元素，而不是一個(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物件，以生產 multisets (計數器中大於0的元素）。 加和減，結合計數器，通過加上或者減去元素的相應計數。交集和並集返回相應計數的最小或最大值。每種操作都可以接受帶符號的計數，但是輸出會忽略掉結果為零或者小於零的計數。

>>> 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類是一個字典的子類，不限制鍵和值。值用於表示計數，但你實際上可以儲存任何其他值。

• most_common()方法在值需要排序的時候用。

• 原地操作比如c[key]+=1， 值型別只需要支援加和減。 所以分數，小數，和十進位制都可以用，負值也可以支援。這兩個方法update()和subtract()的輸入和輸出也一樣支援負數和0。

• Multiset多集合方法只為正值的使用情況設計。輸入可以是負數或者0，但只輸出計數為正的值。沒有型別限制，但值型別需要支援加，減和比較操作。

• elements()方法要求正整數計數。忽略0和負數計數。

參見

• Bag class在 Smalltalk。

• Wikipedia 連結Multisets.

• C++ multisets教程和例子。

• 數學操作和多集合用例，參考Knuth, Donald. The Art of Computer Programming Volume II, Section 4.6.3, Exercise 19。

• 在給定數量和集合元素列舉所有不同的多集合，參考itertools.combinations_with_replacement()

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

deque物件

classcollections.deque([iterable[,maxlen]])

返回一個新的雙向佇列物件，從左到右初始化(用方法append()) ，從iterable（迭代物件) 資料建立。如果iterable沒有指定，新佇列為空。

Deque佇列是由棧或者queue佇列生成的（發音是 “deck”，”double-ended queue”的簡稱）。Deque 支援執行緒安全，記憶體高效新增(append)和彈出(pop)，從兩端都可以，兩個方向的大概開銷都是 O(1) 複雜度。

雖然list物件也支援類似操作，不過這裡優化了定長操作和pop(0)和insert(0,v)的開銷。它們引起 O(n) 記憶體移動的操作，改變底層資料表達的大小和位置。

如果maxlen沒有指定或者是None，deques 可以增長到任意長度。否則，deque就限定到指定最大長度。一旦限定長度的deque滿了，當新項加入時，同樣數量的項就從另一端彈出。限定長度deque提供類似Unix filtertail的功能。它們同樣可以用與追蹤最近的交換和其他資料池活動。

雙向佇列(deque)物件支援以下方法：

append(x)

新增x到右端。

appendleft(x)

新增x到左端。

clear()

移除所有元素，使其長度為0.

copy()

建立一份淺拷貝。

3.5 新版功能.

count(x)

計算 deque 中元素等於x的個數。

3.2 新版功能.

extend(iterable)

擴充套件deque的右側，通過新增iterable引數中的元素。

extendleft(iterable)

擴充套件deque的左側，通過新增iterable引數中的元素。注意，左新增時，在結果中iterable引數中的順序將被反過來新增。

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

返回x在 deque 中的位置（在索引start之後，索引stop之前）。 返回第一個匹配項，如果未找到則引發ValueError。

3.5 新版功能.

insert(i,x)

在位置i插入x。

如果插入會導致一個限長 deque 超出長度maxlen的話，就引發一個IndexError。

3.5 新版功能.

pop()

移去並且返回一個元素，deque 最右側的那一個。 如果沒有元素的話，就引發一個IndexError。

popleft()

移去並且返回一個元素，deque 最左側的那一個。 如果沒有元素的話，就引發IndexError。

remove(value)

移除找到的第一個value。 如果沒有的話就引發ValueError。

reverse()

將deque逆序排列。返回None。

3.2 新版功能.

rotate(n=1)

向右迴圈移動n步。 如果n是負數，就向左迴圈。

如果deque不是空的，向右迴圈移動一步就等價於d.appendleft(d.pop())， 向左迴圈一步就等價於d.append(d.popleft())。

Deque物件同樣提供了一個只讀屬性:

maxlen

Deque的最大尺寸，如果沒有限定的話就是None。

3.1 新版功能.

除了以上操作，deque 還支援迭代、封存、len(d)、reversed(d)、copy.copy(d)、copy.deepcopy(d)、成員檢測運算子in以及下標引用例如通過d[0]訪問首個元素等。 索引訪問在兩端的複雜度均為 O(1) 但在中間則會低至 O(n)。 如需快速隨機訪問，請改用列表。

Deque從版本3.5開始支援__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'])

deque用法

這一節展示了deque的多種用法。

限長deque提供了類似Unixtail過濾功能

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切片和刪除。 例如， 一個純的Pythondeld[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物件

classcollections.defaultdict([default_factory[,...]])

返回一個新的類似字典的物件。defaultdict是內建dict類的子類。它過載了一個方法並添加了一個可寫的例項變數。其餘的功能與dict類相同，此處不再重複說明。

本物件包含一個名為default_factory的屬性，構造時，第一個引數用於為該屬性提供初始值，預設為None。所有其他引數（包括關鍵字引數）都相當於傳遞給dict的建構函式。

defaultdict物件除了支援標準dict的操作，還支援以下方法作為擴充套件：

__missing__(key)

如果default_factory屬性為None，則呼叫本方法會丟擲KeyError異常，附帶引數key。

如果default_factory不為None，則它會被（不帶引數地）呼叫來為key提供一個預設值，這個值和key作為一對鍵值對被插入到字典中，並作為本方法的返回值返回。

如果呼叫default_factory時丟擲了異常，這個異常會原封不動地向外層傳遞。

在無法找到所需鍵值時，本方法會被dict中的__getitem__()方法呼叫。無論本方法返回了值還是丟擲了異常，都會被__getitem__()傳遞。

注意，__missing__()不會被__getitem__()以外的其他方法呼叫。意味著get()會像正常的 dict 那樣返回None，而不是使用default_factory。

defaultdict物件支援以下例項變數：

default_factory

本屬性由__missing__()方法來呼叫。如果構造物件時提供了第一個引數，則本屬性會被初始化成那個引數，如果未提供第一個引數，則本屬性為None。

在 3.9 版更改:增加了合併 (|) 與更新 (|=) 運算子，相關說明見PEP 584。

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

當每個鍵第一次遇見時，它還沒有在字典裡面，所以自動建立該條目，即呼叫default_factory方法，返回一個空的list。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()來提供一個整數 0 作為預設值。後續的自增操作建立起對每個字母的計數。

函式int()總是返回 0，這是常數函式的特殊情況。一個更快和靈活的方法是使用 lambda 函式，可以提供任何常量值（不只是0）：

>>> 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用於構建 set 集合：

>>> 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。這個新的子類用於建立類元組的物件，可以通過欄位名來獲取屬性值，同樣也可以通過索引和迭代獲取值。子類例項同樣有文件字串（類名和欄位名）另外一個有用的__repr__()方法，以name=value格式列明瞭元組內容。

field_names是一個像[‘x’,‘y’]一樣的字串序列。另外field_names可以是一個純字串，用空白或逗號分隔開元素名，比如'xy'或者'x,y'。

任何有效的Python 識別符號都可以作為欄位名，除了下劃線開頭的那些。有效識別符號由字母，數字，下劃線組成，但首字母不能是數字或下劃線，另外不能是關鍵詞keyword比如class,for,return,global,pass, 或raise。

如果rename為真， 無效欄位名會自動轉換成位置名。比如['abc','def','ghi','abc']轉換成['abc','_1','ghi','_3']， 消除關鍵詞def和重複欄位名abc。

defaults可以為None或者是一個預設值的iterable。如果一個預設值域必須跟其他沒有預設值的域在一起出現，defaults就應用到最右邊的引數。比如如果域名['x','y','z']和預設值(1,2)，那麼x就必須指定一個引數值 ，y預設值1，z預設值2。

如果module值有定義，命名元組的__module__屬性值就被設定。

命名元組例項沒有字典，所以它們要更輕量，並且佔用更小記憶體。

在 3.1 版更改:添加了對rename的支援。

在 3.6 版更改:verbose和rename引數成為僅限關鍵字引數.

在 3.6 版更改:添加了module引數。

在 3.7 版更改:移除了verbose形參和_source屬性。

在 3.7 版更改:添加了defaults引數和_field_defaults屬性。

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

除了繼承元組的方法，命名元組還支援三個額外的方法和兩個屬性。為了防止欄位名衝突，方法和屬性以下劃線開始。

classmethodsomenamedtuple._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}

在 3.1 版更改:返回一個OrderedDict而不是dict。

在 3.8 版更改:返回一個常規dict而不是OrderedDict。 因為自 Python 3.7 起，常規字典已經保證有序。 如果需要OrderedDict的額外特性，推薦的解決方案是將結果轉換為需要的型別:OrderedDict(nt._asdict())。

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'

在 3.5 版更改:文件字串屬性變成可寫。

參見

• 請參閱typing.NamedTuple，以獲取為命名元組新增型別提示的方法。 它還使用class關鍵字提供了一種優雅的符號:

  class Component(NamedTuple):
      part_number: int
      weight: float
      description: Optional[str] = None
  

• 對於以字典為底層的可變域名， 參考types.SimpleNamespace()。

• dataclasses模組提供了一個裝飾器和一些函式，用於自動將生成的特殊方法新增到使用者定義的類中。

OrderedDict物件

有序詞典就像常規詞典一樣，但有一些與排序操作相關的額外功能。由於內建的dict類獲得了記住插入順序的能力（在 Python 3.7 中保證了這種新行為），它們變得不那麼重要了。

一些與dict的不同仍然存在：

• 常規的dict被設計為非常擅長對映操作。 跟蹤插入順序是次要的。

• OrderedDict旨在擅長重新排序操作。 空間效率、迭代速度和更新操作的效能是次要的。

• 演算法上，OrderedDict可以比dict更好地處理頻繁的重新排序操作。 這使其適用於跟蹤最近的訪問（例如在LRU cache中）。

• 對於OrderedDict，相等操作檢查匹配順序。

• OrderedDict類的popitem()方法有不同的簽名。它接受一個可選引數來指定彈出哪個元素。

• OrderedDict類有一個move_to_end()方法，可以有效地將元素移動到任一端。

• Python 3.8之前，dict缺少__reversed__()方法。

classcollections.OrderedDict([items])

返回一個dict子類的例項，它具有專門用於重新排列字典順序的方法。

3.1 新版功能.

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'

3.2 新版功能.

相對於通常的對映方法，有序字典還另外提供了逆序迭代的支援，通過reversed()。

OrderedDict之間的相等測試是順序敏感的，實現為list(od1.items())==list(od2.items())。OrderedDict物件和其他的Mapping的相等測試，是順序敏感的字典測試。這允許OrderedDict替換為任何字典可以使用的場所。

在 3.5 版更改:OrderedDict的項(item)，鍵(key)和值(value)檢視現在支援逆序迭代，通過reversed()。

在 3.6 版更改:PEP 468贊成將關鍵詞引數的順序保留， 通過傳遞給OrderedDict構造器和它的update()方法。

在 3.9 版更改:增加了合併 (|) 與更新 (|=) 運算子，相關說明見PEP 584。

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]

UserDict物件

UserDict類是用作字典物件的外包裝。對這個類的需求已部分由直接建立dict的子類的功能所替代；不過，這個類處理起來更容易，因為底層的字典可以作為屬性來訪問。

classcollections.UserDict([initialdata])

模擬一個字典類。這個例項的內容儲存為一個正常字典， 可以通過UserDict例項的data屬性存取。如果提供了initialdata值，data就被初始化為它的內容；注意一個initialdata的引用不會被保留作為其他用途。

UserDict例項提供了以下屬性作為擴充套件方法和操作的支援:

data

一個真實的字典，用於儲存UserDict類的內容。

UserList物件

這個類封裝了列表物件。它是一個有用的基礎類，對於你想自定義的類似列表的類，可以繼承和覆蓋現有的方法，也可以新增新的方法。這樣我們可以對列表新增新的行為。

對這個類的需求已部分由直接建立list的子類的功能所替代；不過，這個類處理起來更容易，因為底層的列表可以作為屬性來訪問。

classcollections.UserList([list])

模擬一個列表。這個例項的內容被儲存為一個正常列表，通過UserList的data屬性存取。例項內容被初始化為一個list的copy，預設為[]空列表。list可以是迭代物件，比如一個Python列表，或者一個UserList物件。

UserList提供了以下屬性作為可變序列的方法和操作的擴充套件:

data

一個list物件用於儲存UserList的內容。

子類化的要求:UserList的子類需要提供一個構造器，可以無引數呼叫，或者一個引數呼叫。返回一個新序列的列表操作需要建立一個實現類的例項。它假定了構造器可以以一個引數進行呼叫，這個引數是一個序列物件，作為資料來源。

如果一個分離的類不希望依照這個需求，所有的特殊方法就必須重寫；請參照原始碼進行修改。

UserString物件

UserString類是用作字串物件的外包裝。對這個類的需求已部分由直接建立str的子類的功能所替代；不過，這個類處理起來更容易，因為底層的字串可以作為屬性來訪問。

classcollections.UserString(seq)

模擬一個字串物件。這個例項物件的內容儲存為一個正常字串，通過UserString的data屬性存取。例項內容初始化設定為seq的copy。seq引數可以是任何可通過內建str()函式轉換為字串的物件。

UserString提供了以下屬性作為字串方法和操作的額外支援：

data

一個真正的str物件用來存放UserString類的內容。

在 3.5 版更改:新方法__getnewargs__,__rmod__,casefold,format_map,isprintable, 和maketrans。