# `collections` — Tipos de dados de contêineres

Código-fonte: Lib/collections/__init__.py

Este módulo implementa tipos de dados de contêineres especializados que fornecem alternativas aos contêineres embutidos do Python, `dict`, `list`, `set` e `tuple`.

`namedtuple()` | função fábrica (factory function) para criar subclasses de tuplas com campos nomeados
`deque` | contêiner lista ou similar com acréscimos e retiradas rápidas nas duas extremidades
`ChainMap` | classe dict ou similar para criar uma visão única de vários mapeamentos
`Counter` | subclasse de dict para contar objetos hasheáveis
`OrderedDict` | subclasse de dict que lembra a ordem que as entradas foram adicionadas
`defaultdict` | subclasse de dict que chama uma função fábrica para fornecer valores não encontrados
`UserDict` | invólucro em torno de objetos dicionário para facilitar fazer subclasse de dict
`UserList` | invólucro em torno de objetos lista para facilitar criação de subclasse de lista
`UserString` | invólucro em torno de objetos string para uma facilitar criação de subclasse de string

## Objetos `ChainMap`

Novo na versão 3.3.

Uma classe `ChainMap` é fornecida para ligar rapidamente uma série de mapeamentos de forma que possam ser tratados como um só. O que é frequentemente mais rápido do que criar um novo dicionário e executar múltiplas chamadas de `update()`.

A classe pode ser usada para simular escopos aninhados e é útil em modelos.

class `collections.``ChainMap`(*maps)

  `ChainMap` agrupa múltiplos dicts ou outros mapeamentos para criar uma única vista atualizável. Se nenhum maps for especificado, um dicionário vazio será fornecido para que uma nova cadeia tenha sempre pelo menos um mapeamento.

  Os mapeamentos subjacentes são armazenados em uma lista. Essa lista é pública e pode ser acessada ou atualizada usando o atributo maps. Não existe outro estado.

  Faz uma busca nos mapeamentos subjacentes sucessivamente até que uma chave seja encontrada. Em contraste, escrita, atualizações e remoções operam apenas no primeiro mapeamento.

  Uma `ChainMap` incorpora os mapeamentos subjacentes por referência. Então, se um dos mapeamentos subjacentes for atualizado, essas alterações serão refletidas na `ChainMap`.

  Todos os métodos usuais do dicionário são suportados. Além disso, existe um atributo maps, um método para criar novos subcontextos e uma propriedade para acessar todos, exceto o primeiro mapeamento:

  `maps`

    Uma lista de mapeamentos atualizáveis pelo usuário. A lista é ordenada desde o primeiro pesquisado até a última pesquisado. É o único estado armazenado e pode ser modificado para alterar quais mapeamentos são pesquisados. A lista deve sempre conter pelo menos um mapeamento.

  `new_child`(m=None, **kwargs)

    Retorna uma nova `ChainMap` contendo um novo mapa seguido de todos os mapas na instância atual. Se `m` for especificado, torna-se o novo mapa na frente da lista de mapeamentos; Se não especificado, é usado um dicionário vazio, de modo que chamar `d.new_child()` é equivalente a: `ChainMap({}, *d.maps)`. Se algum argumento nomeado for especificado, ele atualizará o mapa passado ou o novo dicionário vazio. Esse método é usado para criar subcontextos que podem ser atualizados sem alterar valores em nenhum dos mapeamentos pai.

    Alterado na versão 3.4: O parâmetro opcional `m` foi adicionado.

    Alterado na versão 3.10: Suporte a argumentos nomeados foi adicionado.

  `parents`

    Propriedade que retorna um novo `ChainMap` contendo todos os mapas da instância atual, exceto o primeiro. Isso é útil para pular o primeiro mapa da pesquisa. Os casos de uso são semelhantes aos do argumento nomeado `nonlocal` usada em escopos aninhados. Os casos de uso também são paralelos aos da função embutida `super()`. Uma referência a `d.parents` é equivalente a: `ChainMap(*d.maps[1:])`.

  Observe, a ordem de iteração de um `ChainMap()` é determinada pela varredura dos mapeamentos do último ao primeiro:

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

  Isso dá a mesma ordem de uma série de chamadas de `dict.update()` começando com o último mapeamento:

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

  Alterado na versão 3.9: Adicionado suporte para os operadores `|` e `|=`, especificados na PEP 584.

Ver também

- A classe MultiContext no pacote CodeTools de Enthought tem opções para oferecer suporte à escrita em qualquer mapeamento na cadeia.

- A classe Context do Django para modelos é uma cadeia de mapeamentos somente leitura. Ela também oferece o recurso de push e pop (inserir e retirar) contextos semelhantes ao método `new_child()` e a propriedade `parents`.

- A receita de Contextos Aninhados possui opções para controlar se escritas e outras mutações se aplicam a apenas o primeiro mapeamento ou para qualquer mapeamento na cadeia.

- Uma versão muito simplificada somente leitura do Chainmap.

### Exemplos e Receitas de `ChainMap`

Esta seção mostra várias abordagens para trabalhar com mapas encadeados.

Exemplo de simulação da cadeia de busca interna do Python:

    import builtins
    pylookup = ChainMap(locals(), globals(), vars(builtins))

Exemplo de como permitir que os argumentos de linha de comando especificados pelo usuário tenham precedência sobre as variáveis de ambiente que, por sua vez, têm precedência sobre os valores padrão:

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

Padrões de exemplo para utilização da classe `ChainMap` para simular contextos aninhados:

    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

A classe `ChainMap` só faz atualizações (escritas e remoções) no primeiro mapeamento na cadeia, enquanto as pesquisas irão buscar em toda a cadeia. Contudo, se há o desejo de escritas e remoções profundas, é fácil fazer uma subclasse que atualiza chaves encontradas mais a fundo na cadeia:

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

## Objetos `Counter`

Uma ferramenta de contagem é fornecida para apoiar contas rápidas e convenientes. Por exemplo:

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

  Um `Counter` é uma subclasse de `dict` subclass para contagem de objetos hasheáveis. É uma coleção na qual elementos são armazenados como chaves de dicionário e suas contagens são armazenadas como valores de dicionário. Contagens podem ser qualquer valor inteiro incluindo zero e contagens negativas. A classe `Counter` é similar a sacos ou multiconjuntos em outras linguagens.

  Os elementos são contados a partir de um iterável iterable ou inicializado a partir de um outro mapeamento mapping (ou contador):

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

  Objetos Counter tem uma interface de dicionário, com a diferença que devolvem uma contagem zero para itens que não estão presentes em vez de levantar a exceção `KeyError`:

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

  Definir uma contagem como zero não remove um elemento do contador. Use `del` para o remover completamente.

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

  Novo na versão 3.1.

  Alterado na versão 3.7: Como uma subclasse de `dict`, `Counter` herda a capacidade de lembrar a ordem de inserção. Operações matemáticas em objetos Counter também preservam ordem. Os resultados são ordenados de acordo com o momento que um elemento é encontrado pela primeira vez no operando da esquerda e, em seguida, pela ordem encontrada no operando da direita.

  Objetos Counter têm suporte a métodos adicionais além daqueles que já estão disponíveis para todos os dicionários:

  `elements`()

    Retorna um iterador sobre os elementos, repetindo cada um tantas vezes quanto sua contagem. Os elementos são retornados na ordem em que foram encontrados pela primeira vez. Se a contagem de um elemento é menor que um, ele será ignorado por `elements()` .

        >>> c = Counter(a=4, b=2, c=0, d=-2)
        >>> sorted(c.elements())
        ['a', 'a', 'a', 'a', 'b', 'b']

  `most_common`([n])

    Retorna uma lista dos n elementos mais comuns e suas contagens, do mais comum para o menos comum. Se n for omitido ou igual a `None`, `most_common()` retorna todos os elementos no contador. Elementos com contagens iguais são ordenados na ordem em que foram encontrados pela primeira vez:

        >>> Counter('abracadabra').most_common(3)
        [('a', 5), ('b', 2), ('r', 2)]

  `subtract`([iterable-or-mapping])

    Os elementos são subtraídos de um iterável iterable ou de outro mapeamento mapping (ou contador). Funciona como `dict.update()`, mas subtraindo contagens ao invés de substituí-las. Tanto as entradas quanto as saídas podem ser zero ou negativas.

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

    Novo na versão 3.2.

  `total`()

    Calcula a soma das contagens.

        >>> c = Counter(a=10, b=5, c=0)
        >>> c.total()
        15

    Novo na versão 3.10.

  Os métodos usuais de dicionário estão disponíveis para objetos `Counter`, exceto por dois que funcionam de forma diferente para contadores.

  `fromkeys`(iterable)

    Este método de classe não está implementado para objetos `Counter`.

  `update`([iterable-or-mapping])

    Elementos são contados a partir de um iterável iterable ou adicionados de outro mapeamento mapping (ou contador). Funciona como `dict.update()`, mas adiciona contagens em vez de substituí-las. Além disso, é esperado que o iterable seja uma sequência de elementos, e não uma sequência de pares `(key, value)`.

Os contadores oferecem suporte a operadores de comparação rica para relacionamentos de igualdade, subconjunto e superconjunto: `==`, `!=`, `<`, `<=`, `>`, `>=`. Todos esses testes tratam os elementos ausentes como tendo contagens zero para que `Counter(a=1) == Counter(a=1, b=0)` retorne verdadeiro.

Novo na versão 3.10: Foram adicionadas operações de rica comparação.

Alterado na versão 3.10: Em testes de igualdade, os elementos ausentes são tratados como tendo contagens zero. Anteriormente, `Counter(a=3)` e `Counter(a=3, b=0)` eram considerados distintos.

Padrões comuns para trabalhar com objetos `Counter`:

    c.total()                       # 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

Diversas operações matemáticas são fornecidas combinando objetos do tipo `Counter` afim de se produzir multiconjuntos (Counters que possuem contagens maiores que 0). Adição e subtração combinam contadores adicionando ou subtraindo o contagem do elemento correspondente. Intersecção ou união retorna o mínimo e máximo da contagem correspondente. Igualdade e inclusão compara as contagens correspondentes. Cada operação aceita entradas com contagens assinadas, mas a saída vai excluir resultados com contagens de zero ou menos.

    >>> 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 == d                      # equality:  c[x] == d[x]
    False
    >>> c <= d                      # inclusion:  c[x] <= d[x]
    False

A adição e subtração unárias são atalhos para adicionar um contador vazio ou subtrair de um contador vazio.

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

Novo na versão 3.3: Adicionado suporte para operador unário mais, unário menos e operações in-place em multiconjuntos.

Nota

Os contadores foram projetados principalmente para funcionar com números inteiros positivos para representar contagens contínuas; no entanto, foi tomado cuidado para não impedir desnecessariamente os casos de uso que precisassem de outros tipos ou valores negativos. Para ajudar nesses casos de uso, esta seção documenta o intervalo mínimo e as restrições de tipo.

- A própria classe `Counter` é uma subclasse de dicionário sem restrições em suas chaves e valores. Os valores pretendem ser números que representam contagens, mas você pode armazenar qualquer coisa no campo de valor.

- O método `most_common()` requer apenas que os valores sejam ordenáveis.

- Para operações in-place, como `c[key] += 1`, o tipo de valor precisa oferecer suporte a apenas adição e subtração. Portanto, frações, números de ponto flutuante e decimais funcionariam e os valores negativos são suportados. O mesmo também é verdadeiro para `update()` e `subtract()` que permitem valores negativos e zero para entradas e saídas.

- Os métodos de multiconjuntos são projetados apenas para casos de uso com valores positivos. As entradas podem ser negativas ou zero, mas apenas saídas com valores positivos são criadas. Não há restrições de tipo, mas o tipo de valor precisa suportar adição, subtração e comparação.

- O método `elements()` requer contagens de inteiros. Ele ignora contagens zero e negativas.

Ver também

- Classe Bag do Smalltalk.

- Entrada da Wikipédia para Multiconjuntos.

- Tutorial com exemplos de multiconjuntos no C++.

- Para operações matemáticas em multiconjuntos e seus casos de uso, consulte Knuth, Donald. The Art of Computer Programming Volume II, Seção 4.6.3, Exercício 19.

- Para enumerar todos os multiconjuntos distintos de um determinado tamanho em um determinado conjunto de elementos, consulte `itertools.combinations_with_replacement()`:

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

## Objetos `deque`

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

  Retorna um novo objeto deque inicializado da esquerda para a direita (usando `append()`) com dados do iterável iterable. Se iterable não for especificado, o novo deque estará vazio.

  Deques são uma generalização de pilhas e filas (o nome é pronunciado “deck” e é abreviação de “double-ended queue”, e conhecida como “fila duplamente terminada” em português). O Deques oferece suporte para acréscimos e retiradas seguros para thread e eficientes em uso memória de ambos os lados do deque com aproximadamente o mesmo desempenho O(1) em qualquer direção.

  Embora os objetos `list` ofereçam suporte a operações semelhantes, eles são otimizados para operações rápidas de comprimento fixo e sujeitam em custos de movimentação de memória O(n) para as operações `pop(0)` e `insert(0, v)` que alteram o tamanho e a posição da representação de dados subjacente.

  Se maxlen não for especificado ou for `None`, deques podem crescer para um comprimento arbitrário. Caso contrário, o deque é limitado ao comprimento máximo especificado. Quando um deque de comprimento limitado está cheio, quando novos itens são adicionados, um número correspondente de itens é descartado da extremidade oposta. Deques de comprimento limitado fornecem funcionalidade semelhante ao filtro `tail` no Unix. Eles também são úteis para rastrear transações e outras pools de dados onde apenas a atividade mais recente é de interesse.

  Os objetos Deque oferecem suporte aos seguintes métodos:

  `append`(x)

    Adiciona x ao lado direito do deque.

  `appendleft`(x)

    Adiciona x ao lado esquerdo do deque

  `clear`()

    Remove todos os elementos do deque deixando-o com comprimento 0.

  `copy`()

    Cria uma cópia rasa do deque.

    Novo na versão 3.5.

  `count`(x)

    Conta o número de elementos deque igual a x.

    Novo na versão 3.2.

  `extend`(iterable)

    Estende o lado direito do deque anexando elementos do argumento iterável.

  `extendleft`(iterable)

    Estende o lado esquerdo do deque anexando elementos de iterable. Observe que a série de acréscimos à esquerda resulta na reversão da ordem dos elementos no argumento iterável.

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

    Retorna a posição de x no deque (no ou após o índice start e antes do índice stop). Retorna a primeira correspondência ou levanta `ValueError` se não for encontrado.

    Novo na versão 3.5.

  `insert`(i, x)

    Insere x no deque na posição i.

    Se a inserção fizer com que um deque limitado cresça além de maxlen, uma `IndexError` é levantada.

    Novo na versão 3.5.

  `pop`()

    Remove e devolve um elemento do lado direito do deque. Se nenhum elemento estiver presente, levanta um `IndexError`.

  `popleft`()

    Remove e devolve um elemento do lado esquerdo do deque. Se nenhum elemento estiver presente, levanta um `IndexError`.

  `remove`(value)

    Remove a primeira ocorrência de value. Se não for encontrado, levanta um `ValueError`.

  `reverse`()

    Inverte os elementos do deque no local e, em seguida, retorna `None`.

    Novo na versão 3.2.

  `rotate`(n=1)

    Gira o deque n passos para a direita. Se n for negativo, gire para a esquerda.

    Quando o deque não está vazio, girar um passo para a direita é equivalente a `d.appendleft(d.pop())` e girar um passo para a esquerda é equivalente a `d.append(d.popleft())`.

  Os objetos Deque também fornecem um atributo somente leitura:

  `maxlen`

    Tamanho máximo de um deque ou `None` se ilimitado.

    Novo na versão 3.1.

Além do acima, deques oferece suporte a iteração, serialização com pickle, `len(d)`, `reversed(d)`, `copy.copy(d)`, `copy.deepcopy(d)` e teste de associação com o operador `in` e referências subscritas, como `d[0]` para acessar o primeiro elemento. O acesso indexado é O(1) em ambas as extremidades, mas diminui para O(n) no meio. Para acesso aleatório rápido, use listas.

A partir da versão 3.5, deques oferecem suporte a `__add__()`,``__mul__()`` e `__imul__()`.

Exemplo:

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

### Receitas de `deque`

Esta seção mostra várias abordagens para trabalhar com deques.

Deques de comprimento limitado fornecem funcionalidade semelhante ao filtro `tail` em Unix:

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

Outra abordagem para usar deques é manter uma sequência de elementos adicionados recentemente, acrescentando à direita e clicando à esquerda:

    def moving_average(iterable, n=3):
        # moving_average([40, 30, 50, 46, 39, 44]) --> 40.0 42.0 45.0 43.0
        # https://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

Um escalonador round robin pode ser implementado com iteradores de entrada armazenados em um `deque`. Os valores são produzidos a partir do iterador ativo na posição zero. Se esse iterador estiver esgotado, ele pode ser removido com `popleft()`; caso contrário, ele pode voltar ao fim com o método `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()

O método `rotate()` fornece uma maneira de implementar o fatiamento e exclusão `deque`. Por exemplo, uma implementação Python pura de `del d[n]` depende do método `rotate()` para posicionar os elementos a serem retirados:

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

Para implementar o fatiamento de `deque`, use uma abordagem semelhante aplicando `rotate()` para trazer um elemento alvo para o lado esquerdo do deque. Remova as entradas antigas com `popleft()`, adicione novas entradas com `extend()`, e, então, inverta a rotação. Com pequenas variações dessa abordagem, é fácil implementar manipulações de pilha de estilo Forth, como `dup`, `drop`, `swap`, `over`, `pick`, `rot` e `roll`.

## Objetos `defaultdict`

class `collections.``defaultdict`(default_factory=None, /[, ...])

  Retorna um novo objeto dicionário ou similar. `defaultdict` é uma subclasse da classe embutida `dict`. Ele substitui um método e adiciona uma variável de instância gravável. A funcionalidade restante é a mesma da classe `dict` e não está documentada aqui.

  O primeiro argumento fornece o valor inicial para o atributo `default_factory`; o padrão é `None`. Todos os argumentos restantes são tratados da mesma forma como se fossem passados para o construtor `dict`, incluindo argumentos nomeados.

  Os objetos `defaultdict` oferecem suporta ao seguinte método além das operações padrão `dict`:

  `__missing__`(key)

    Se o atributo `default_factory` for `None`, isso levanta uma exceção `KeyError` com key como argumento.

    Se `default_factory` não for `None`, ele é chamado sem argumentos para fornecer um valor padrão para a chave key fornecida, este valor é inserido no dicionário para key e retornado.

    Se chamar `default_factory` levanta uma exceção, esta exceção é propagada inalterada.

    Este método é chamado pelo método `__getitem__()` da classe `dict` quando a chave solicitada não é encontrada; tudo o que ele retorna ou levanta é então retornado ou levantado por `__getitem__()`.

    Note that `__missing__()` is not called for any operations besides `__getitem__()`. This means that `get()` will, like normal dictionaries, return `None` as a default rather than using `default_factory`.

  Objetos `defaultdict` permitem a seguinte variável de instância:

  `default_factory`

    Este atributo é usado pelo método `__missing__()`; ele é inicializado a partir do primeiro argumento para o construtor, se presente, ou para `None`, se ausente.

  Alterado na versão 3.9: Adicionado operadores de mesclagem (`|`) e de atualização (`|=`), especificados na PEP 584.

### Exemplos de `defaultdict`

Usando `list` como `default_factory`, se for fácil agrupar a sequencia dos pares chave-valores num dicionário de listas

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

Quando cada chave é encontrada pela primeira vez, ela ainda não está no mapeamento; então uma entrada é criada automaticamente usando a função `default_factory` que retorna uma `list` vazia. A operação `list.append()` então anexa o valor à nova lista. Quando as chaves são encontradas novamente, a pesquisa prossegue normalmente (retornando a lista daquela chave) e a operação `list.append()` adiciona outro valor à lista. Esta técnica é mais simples e rápida que uma técnica equivalente usando `dict.setdefault()`:

    >>> d = {}
    >>> for k, v in s:
    ...     d.setdefault(k, []).append(v)
    ...
    >>> sorted(d.items())
    [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

Definir `default_factory` como `int` torna `defaultdict` útil para contagem (como um multiconjunto em outras linguagens):

    >>> s = 'mississippi'
    >>> d = defaultdict(int)
    >>> for k in s:
    ...     d[k] += 1
    ...
    >>> sorted(d.items())
    [('i', 4), ('m', 1), ('p', 2), ('s', 4)]

Quando uma letra é encontrada pela primeira vez, ela está ausente no mapeamento, então a função `default_factory` chama `int()` para fornecer uma contagem padrão de zero. A operação de incremento então cria a contagem para cada letra.

A função `int()` que sempre retorna zero é apenas um caso especial de funções constantes. Uma maneira mais rápida e flexível de criar funções constantes é usar uma função lambda que pode fornecer qualquer valor constante (não apenas zero):

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

Definir `default_factory` como `set` torna `defaultdict` útil para construir um dicionário de conjuntos:

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

## Função de fábrica para tuplas com campos nomeados `namedtuple()`

Tuplas nomeadas determinam o significado de cada posição numa tupla e permitem um código mais legível e autodocumentado. Podem ser usadas sempre que tuplas regulares forem utilizadas, e adicionam a possibilidade de acessar campos pelo nome ao invés da posição do índice.

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

  Retorna uma nova subclasse de tupla chamada typename. A nova subclasse é usada para criar objetos semelhantes a tuplas que possuem campos acessíveis por pesquisa de atributos, além de serem indexáveis e iteráveis. As instâncias da subclasse também possuem uma docstring útil (com typename e field_names) e um método útil `__repr__()` que lista o conteúdo da tupla em um formato `nome=valor`.

  field_names são uma sequência de strings como `['x', 'y']`. Alternativamente, field_names pode ser uma única string com cada nome de campo separado por espaços em branco e/ou vírgulas como, por exemplo, `'x y'` ou `'x, y'`.

  Qualquer identificador Python válido pode ser usado para um nome de campo, exceto para nomes que começam com um sublinhado. Identificadores válidos consistem em letras, dígitos e sublinhados, mas não começam com um dígito ou sublinhado e não podem ser uma `keyword` como class, for, return, global, pass ou raise.

  Se rename for verdadeiro, nomes de campos inválidos serão automaticamente substituídos por nomes posicionais. Por exemplo, `['abc', 'def', 'ghi', 'abc']` é convertido para `['abc', '_1', 'ghi', '_3']`, eliminando a palavra reservada `def` e o nome de campo duplicado `abc`.

  defaults pode ser `None` ou um iterável de valores padrão. Como os campos com valor padrão devem vir depois de qualquer campo sem padrão, os padrões são aplicados aos parâmetros mais à direita. Por exemplo, se os nomes dos campos forem `['x', 'y', 'z']` e os padrões forem `(1, 2)`, então `x` será um argumento obrigatório, `y` será o padrão `1`, e `z` será o padrão `2`.

  Se module for definido, o atributo `__module__` da tupla nomeada será definido com esse valor.

  As instâncias de tuplas nomeadas não possuem dicionários por instância, portanto são leves e não requerem mais memória do que as tuplas normais.

  Para prover suporte para a serialização com pickle, a classe de tupla nomeada deve ser atribuída a uma variável que corresponda a typename.

  Alterado na versão 3.1: Adicionado suporte a rename.

  Alterado na versão 3.6: Os parâmetros verbose e rename tornaram-se argumentos somente-nomeados.

  Alterado na versão 3.6: Adicionado o parâmetro module.

  Alterado na versão 3.7: Removido o parâmetro verbose e o atributo `_source`

  Alterado na versão 3.7: Adicionado o parâmetro defaults e o atributo `_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)

Tuplas nomeadas são especialmente úteis para atribuir nomes de campos a tuplas de resultados retornadas pelos módulos `csv` ou `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)

Além dos métodos herdados das tuplas, as tuplas nomeadas oferecem suporte a três métodos adicionais e dois atributos. Para evitar conflitos com nomes de campos, os nomes de métodos e atributos começam com um sublinhado.

classmethod `somenamedtuple.``_make`(iterable)

  Método de classe que cria uma nova instância a partir de uma sequência existente ou iterável.

      >>> t = [11, 22]
      >>> Point._make(t)
      Point(x=11, y=22)

`somenamedtuple.``_asdict`()

  Retorna um novo `dict` que mapeia nomes de campo para seus respectivos valores:

      >>> p = Point(x=11, y=22)
      >>> p._asdict()
      {'x': 11, 'y': 22}

  Alterado na versão 3.1: Retorna um `OrderedDict` em vez de um `dict` normal.

  Alterado na versão 3.8: Retorna um `dict` regular em vez de um `OrderedDict`. A partir do Python 3.7, é garantido que os dicionários regulares sejam ordenados. Se os recursos extras de `OrderedDict` forem necessários, a correção sugerida é converter o resultado para o tipo desejado: `OrderedDict(nt._asdict())`.

`somenamedtuple.``_replace`(**kwargs)

  Retorna uma nova instância da tupla nomeada substituindo os campos especificados por novos valores:

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

  Tupla de strings listando os nomes dos campos. Útil para introspecção e para criar novos tipos de tuplas nomeadas a partir de tuplas nomeadas existentes.

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

  Dicionário mapeando nomes de campos para valores padrão.

      >>> Account = namedtuple('Account', ['type', 'balance'], defaults=[0])
      >>> Account._field_defaults
      {'balance': 0}
      >>> Account('premium')
      Account(type='premium', balance=0)

Para recuperar um campo cujo nome está armazenado em uma string, use a função `getattr()`:

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

Para converter um dicionário em uma tupla nomeada, use o operador estrela dupla (conforme descrito em Desempacotando listas de argumentos):

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

Como uma tupla nomeada é uma classe regular do Python, é fácil adicionar ou alterar funcionalidades com uma subclasse. Veja como adicionar um campo calculado e um formato de impressão de largura fixa:

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

A subclasse mostrada acima define `__slots__` como uma tupla vazia. Isso ajuda a manter baixos os requisitos de memória, evitando a criação de dicionários de instância.

A criação de subclasse não é útil para adicionar novos campos armazenados. Em vez disso, simplesmente crie um novo tipo de tupla nomeado a partir do atributo `_fields`:

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

Docstrings podem ser personalizados fazendo atribuições diretas aos campos `__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'

Alterado na versão 3.5: Os docstrings de propriedade tornaram-se graváveis.

Ver também

- Veja `typing.NamedTuple` para uma maneira de adicionar dicas de tipo para tuplas nomeadas. Ele também fornece uma notação elegante usando a palavra reservada `class`:

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

- Veja `types.SimpleNamespace()` para um espaço de nomes mutável baseado em um dicionário subjacente em vez de uma tupla.

- O módulo `dataclasses` fornece um decorador e funções para adicionar automaticamente métodos especiais gerados a classes definidas pelo usuário.

## Objetos `OrderedDict`

Os dicionários ordenados são como os dicionários normais, mas possuem alguns recursos extras relacionados às operações de pedido. Eles se tornaram menos importantes agora que a classe embutida `dict` ganhou a capacidade de lembrar a ordem de inserção (esse novo comportamento foi garantido no Python 3.7).

Algumas diferenças de `dict` ainda permanecem:

- O `dict` regular foi projetado para ser muito bom em operações de mapeamento. O rastreamento do pedido de inserção era secundário.

- O `OrderedDict` foi projetado para ser bom em operações de reordenação. A eficiência de espaço, a velocidade de iteração e o desempenho das operações de atualização eram secundários.

- O algoritmo `OrderedDict` pode lidar com operações de reordenação frequentes melhor do que `dict`. Conforme mostrado nas receitas abaixo, isso o torna adequado para implementar vários tipos de caches LRU.

- A operação de igualdade para `OrderedDict` verifica a ordem correspondente.

  Um `dict` regular pode emular o teste de igualdade sensível à ordem com `p == q and all(k1 == k2 for k1, k2 in zip(p, q))`.

- O método `popitem()` de `OrderedDict` tem uma assinatura diferente. Ele aceita um argumento opcional para especificar qual item será exibido.

  Um `dict` normal pode emular o `od.popitem(last=True)` do OrderedDict com `d.popitem()` que é garantido para exibir o (último) item mais à direita.

  Um `dict` normal pode emular o `od.popitem(last=False)` do OrderedDict com `(k := next(iter(d)), d.pop(k))` que retornará e remova o item mais à esquerda (primeiro), se existir.

- `OrderedDict` possui um método `move_to_end()` para reposicionar eficientemente um elemento em um endpoint.

  Um `dict` normal pode emular o `od.move_to_end(k, last=True)` do OrderedDict com `d[k] = d.pop(k)` que moverá a chave e seu valor associado para a posição mais à direita (última).

  Um `dict` regular não tem um equivalente eficiente para o `od.move_to_end(k, last=False)` do OrderedDict, que move a chave e seu valor associado para a posição mais à esquerda (primeira).

- Até o Python 3.8, `dict` não tinha um método `__reversed__()`.

class `collections.``OrderedDict`([items])

  Retorna uma instância de uma subclasse `dict` que possui métodos especializados para reorganizar a ordem do dicionário.

  Novo na versão 3.1.

  `popitem`(last=True)

    O método `popitem()` para dicionários ordenados retorna e remove um par (chave, valor). Os pares são retornados na ordem LIFO se last for verdadeiro ou na ordem FIFO se for falso.

  `move_to_end`(key, last=True)

    Move uma chave key existente para qualquer extremidade de um dicionário ordenado. O item é movido para a extremidade direita se last for verdadeiro (o padrão) ou para o início se último for falso. Levanta `KeyError` se a key não existir:

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

    Novo na versão 3.2.

Além dos métodos usuais de mapeamento, dicionários ordenados também oferecem suporte a iteração reversa usando a função `reversed()`.

Testes de igualdade entre objetos `OrderedDict` são sensíveis à ordem e são implementados como `list(od1.items())==list(od2.items())`. Testes de igualdade entre objetos `OrderedDict` e outros objetos `Mapping` são insensíveis à ordem como dicionários regulares. Isso permite que objetos `OrderedDict` sejam substituídos em qualquer lugar que um dicionário regular seja usado.

Alterado na versão 3.5: Os itens, chaves e valores de visões de `OrderedDict` agora oferecem suporte a iteração reversa usando `reversed()`.

Alterado na versão 3.6: Com a aceitação da PEP 468, a ordem é mantida para argumentos nomeados passados para o construtor `OrderedDict` e seu método `update()`.

Alterado na versão 3.9: Adicionado operadores de mesclagem (`|`) e de atualização (`|=`), especificados na PEP 584.

### Exemplos e receitas de `OrderedDict`

É simples criar uma variante de dicionário ordenado que lembre a ordem em que as chaves foram inseridas pela última vez. Se uma nova entrada substituir uma entrada existente, a posição de inserção original será alterada e movida para o final:

    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)

Um `OrderedDict` também seria útil para implementar variantes de `functools.lru_cache()`:

    from time import time

    class TimeBoundedLRU:
        "LRU Cache that invalidates and refreshes old entries."

        def __init__(self, func, maxsize=128, maxage=30):
            self.cache = OrderedDict()      # { args : (timestamp, result)}
            self.func = func
            self.maxsize = maxsize
            self.maxage = maxage

        def __call__(self, *args):
            if args in self.cache:
                self.cache.move_to_end(args)
                timestamp, result = self.cache[args]
                if time() - timestamp <= self.maxage:
                    return result
            result = self.func(*args)
            self.cache[args] = time(), result
            if len(self.cache) > self.maxsize:
                self.cache.popitem(0)
            return result

    class MultiHitLRUCache:
        """ LRU cache that defers caching a result until
            it has been requested multiple times.

            To avoid flushing the LRU cache with one-time requests,
            we don't cache until a request has been made more than once.

        """

        def __init__(self, func, maxsize=128, maxrequests=4096, cache_after=1):
            self.requests = OrderedDict()   # { uncached_key : request_count }
            self.cache = OrderedDict()      # { cached_key : function_result }
            self.func = func
            self.maxrequests = maxrequests  # max number of uncached requests
            self.maxsize = maxsize          # max number of stored return values
            self.cache_after = cache_after

        def __call__(self, *args):
            if args in self.cache:
                self.cache.move_to_end(args)
                return self.cache[args]
            result = self.func(*args)
            self.requests[args] = self.requests.get(args, 0) + 1
            if self.requests[args] <= self.cache_after:
                self.requests.move_to_end(args)
                if len(self.requests) > self.maxrequests:
                    self.requests.popitem(0)
            else:
                self.requests.pop(args, None)
                self.cache[args] = result
                if len(self.cache) > self.maxsize:
                    self.cache.popitem(0)
            return result

## Objetos `UserDict`

A classe `UserDict` atua como um invólucro em torno de objetos dicionário. A necessidade desta classe foi parcialmente suplantada pela capacidade de criar subclasses diretamente de `dict`; entretanto, essa classe pode ser mais fácil de trabalhar porque o dicionário subjacente é acessível como um atributo.

class `collections.``UserDict`([initialdata])

  Classe que simula um dicionário. O conteúdo da instância é mantido em um dicionário regular, que é acessível através do atributo `data` das instâncias `UserDict`. Se initialdata for fornecido, `data` é inicializado com seu conteúdo; observe que a referência a initialdata não será mantida, permitindo sua utilização para outros fins.

  Além de prover suporte aos métodos e operações de mapeamentos, as instâncias `UserDict` fornecem o seguinte atributo:

  `data`

    Um dicionário real usado para armazenar o conteúdo da classe `UserDict`.

## Objetos `UserList`

Esta classe atua como um invólucro em torno de objetos de lista. É uma classe base útil para suas próprias classes semelhantes a listas, que podem herdar delas e substituir métodos existentes ou adicionar novos. Desta forma, é possível adicionar novos comportamentos às listas.

A necessidade desta classe foi parcialmente suplantada pela capacidade de criar subclasses diretamente de `list`; no entanto, pode ser mais fácil trabalhar com essa classe porque a lista subjacente pode ser acessada como um atributo.

class `collections.``UserList`([list])

  Classe que simula uma lista. O conteúdo da instância é mantido em uma lista regular, que é acessível através do atributo `data` das instâncias `UserList`. O conteúdo da instância é inicialmente definido como uma cópia de list, padronizando a lista vazia `[]`. list pode ser qualquer iterável, por exemplo, uma lista Python real ou um objeto `UserList`.

  Além de prover suporte aos métodos e operações de sequências mutáveis, as instâncias `UserList` fornecem o seguinte atributo:

  `data`

    Um objeto `list` real usado para armazenar o conteúdo da classe `UserList`.

Requisitos para criar subclasse: Espera-se que as subclasses de `UserList` ofereçam um construtor que pode ser chamado sem argumentos ou com um argumento. Listar operações que retornam uma nova sequência tenta criar uma instância da classe de implementação real. Para isso, presume que o construtor pode ser chamado com um único parâmetro, que é um objeto de sequência usado como fonte de dados.

Se uma classe derivada não desejar atender a este requisito, todos os métodos especiais suportados por esta classe precisarão ser substituídos; consulte as fontes para obter informações sobre os métodos que precisam ser fornecidos nesse caso.

## Objetos `UserString`

A classe `UserString` atua como um invólucro em torno de objetos string. A necessidade desta classe foi parcialmente suplantada pela capacidade de criar subclasses diretamente de `str`; entretanto, essa classe pode ser mais fácil de trabalhar porque a string subjacente é acessível como um atributo.

class `collections.``UserString`(seq)

  Classe que simula um objeto string. O conteúdo da instância é mantido em um objeto string regular, que é acessível através do atributo `data` das instâncias `UserString`. O conteúdo da instância é inicialmente definido como uma cópia de seq. O argumento seq pode ser qualquer objeto que possa ser convertido em uma string usando a função embutida `str()`.

  Além de prover suporte aos métodos e operações de strings, as instâncias `UserString` fornecem o seguinte atributo:

  `data`

    Um objeto `str` real usado para armazenar o conteúdo da classe `UserString`.

  Alterado na versão 3.5: Novos métodos `__getnewargs__`, `__rmod__`, `casefold`, `format_map`, `isprintable` e `maketrans`.