Módulo de colecciones de Python (incluido Counter, defaultdict, OrderedDict, namedtuple, deque, contenedor ChainMap) explicación detallada

Parte I Introducción

La mayor parte del contenido de este artículo proviene de https://www.cnblogs.com/dianel/p/10787693.html , algunos de los cuales se han mejorado y ampliado.

Este módulo implementa contenedores específicos de destino para proporcionar una alternativa a Pythonlos contenedores integrados estándar , que incluyen lo siguiente:dict, list, set, tuple

envase	explicar
Counter	Una subclase de Dictionary que proporciona funcionalidad de conteo para objetos hashable
defaultdict	Una subclase de Diccionario que proporciona una función de fábrica que proporciona valores predeterminados para consultas de diccionario
OrderedDict	Una subclase de Dictionary que conserva el orden en que se agregaron
namedtuple	Función de fábrica para crear subclases de tupla con nombre
deque	Similar a un contenedor de lista, se da cuenta de agregar ( append) y abrir ( pop) rápidamente en ambos extremos
ChainMap	Una clase de contenedor similar a un diccionario que agrega múltiples asignaciones en una sola vista

Parte II Detalle

Debe llevarse a cabo antes del uso import, como el uso Counter, necesita:

from collections import Counter

Cap.I Contador

CounterEs una dictsubclase, utilizada principalmente para contar la frecuencia del objeto que visitas. Métodos comunes:

• elements(): Devuelve un iterador, el número de cálculos repetidos para cada elemento, si el recuento de un elemento es inferior a 1, se ignorará.
• most_common([n]): Devuelve una lista que proporciona los n elementos a los que se accede con más frecuencia y cuenta
• subtract([iterable-or-mapping]): resta elementos del objeto iterativo, la entrada y la salida pueden ser 0 o negativas
• update([iterable-or-mapping]): cuenta elementos de un objeto iterador o agrega elementos de otro objeto de mapa (o contador).

---

Estos son algunos ejemplos de operaciones:

# 统计字符出现的次数
>>> import collections
>>> collections.Counter('hello world')
Counter({
    
    'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})
# 统计单词数
>>> collections.Counter('hello world hello world hello nihao'.split())
Counter({
    
    'hello': 3, 'world': 2, 'nihao': 1})
# ---------------常用的操作-------------------
>>> c = collections.Counter('hello world hello world hello nihao'.split())
>>> c
Counter({
    
    'hello': 3, 'world': 2, 'nihao': 1})
# 获取指定对象的访问次数，也可以使用get()方法
>>> c['hello']
3
>>> c = collections.Counter('hello world hello world hello nihao'.split())
# 查看元素
>>> list(c.elements())
['hello', 'hello', 'hello', 'world', 'world', 'nihao']
# 追加对象，或者使用c.update(d)
>>> c = collections.Counter('hello world hello world hello nihao'.split())
>>> d = collections.Counter('hello world'.split())
>>> c
Counter({
    
    'hello': 3, 'world': 2, 'nihao': 1})
>>> d
Counter({
    
    'hello': 1, 'world': 1})
>>> c + d
Counter({
    
    'hello': 4, 'world': 3, 'nihao': 1})
# 减少对象，或者使用c.subtract(d)
>>> c - d
Counter({
    
    'hello': 2, 'world': 1, 'nihao': 1})
# 清除
>>> c.clear()
>>> c
Counter()

Cap.II defaultdict

collections.defaultdict(default_factory)keyProporcione un valor predeterminado para la ausencia del diccionario . El argumento debe ser una función que devuelva un valor predeterminado cuando se llame sin argumentos. Si no se pasa nada, el valor predeterminado es None.

>>> d = collections.defaultdict()
>>> d
defaultdict(None, {
    
    })
>>> e = collections.defaultdict(str)
>>> e
defaultdict(<class 'str'>, {
    
    })

defaultdictUn uso típico de es usar uno de los tipos incorporados (como str, int, listo dict) como la fábrica predeterminada (se puede entender como C++ vector<int>en int), porque estos tipos incorporados devuelven un tipo vacío cuando se les llama sin parámetros.

>>> d = collections.defaultdict(str)
>>> d
defaultdict(<class 'str'>, {
    
    })
>>> d['hello']
''
>>> d
defaultdict(<class 'str'>, {
    
    'hello': ''})
# 普通字典调用不存在的键时，将会抛异常
>>> e = {
    
    }
>>> e['hello']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'hello'

Ejemplo usando intcomo default_factory:

>>> from collections import defaultdict
>>> fruit = defaultdict(int)
>>> fruit['apple'] += 2 
>>> fruit
defaultdict(<class 'int'>, {
    
    'apple': 2})
>>> fruit
defaultdict(<class 'int'>, {
    
    'apple': 2})
>>> fruit['banana']  # 没有对象时，返回0
0
>>> fruit
defaultdict(<class 'int'>, {
    
    'apple': 2, 'banana': 0})

Ejemplo usando listcomo default_factory:

>>> s = [('NC', 'Raleigh'), ('VA', 'Richmond'), ('WA', 'Seattle'), ('NC', 'Asheville')]
>>> d = collections.defaultdict(list)
>>> for k,v in s:
...      d[k].append(v)
... 
>>> d
defaultdict(<class 'list'>, {
    
    'NC': ['Raleigh', 'Asheville'], 'VA': ['Richmond'], 'WA': ['Seattle']})

Capítulo III OrderedDict

El orden de las claves en un diccionario de Python es arbitrario: no están controlados por el orden en que se agregan. collections.OrderedDictLa clase proporciona objetos de diccionario que conservan el orden en que se agregaron.

>>> from collections import OrderedDict
>>> o = OrderedDict()
>>> o['key1'] = 'value1'
>>> o['key2'] = 'value2'
>>> o['key3'] = 'value3'
>>> o
OrderedDict([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])

keySi agrega un nuevo valor a uno existente , mantendrá la keyposición original y luego sobrescribirá valueel valor.

>>> o['key1'] = 'value5'
>>> o
OrderedDict([('key1', 'value5'), ('key2', 'value2'), ('key3', 'value3')])

Cap.IV tupla nombrada

Tres formas de definir una tupla con nombre : el primer parámetro es el constructor de la tupla con nombre (como sigue: Persona, Humano)

>>> from collections import namedtuple
>>> Person = namedtuple('Person', ['age', 'height', 'name'])
>>> Human = namedtuple('Human', 'age, height, name')
>>> Human2 = namedtuple('Human2', 'age height name')

instanciar tupla de comando

>>> tom = Person(30,178,'Tom')
>>> jack = Human(20,179,'Jack')
>>> tom
Person(age=30, height=178, name='Tom')
>>> jack
Human(age=20, height=179, name='Jack')
>>> tom.age #直接通过  实例名+.+属性 来调用
30
>>> jack.name
'Jack'

Capítulo V en consecuencia

collections.dequeDevuelve un nuevo objeto de cola doble, inicializado (con método append()) de izquierda a derecha, creado a partir de iterabledatos (objeto de iteración). Si iterableno se especifica, la nueva cola está vacía.

collections.dequeappendLas colas admiten seguridad de subprocesos, para agregar ( ) o extraer ( ) desde ambos extremos pop, complejidad O(1).

Aunque los objetos también admiten operaciones similares, listaquí se optimiza la sobrecarga de las operaciones de longitud fija ( pop(0), ) insert(0,v).

Si maxlenno se especifica o es None, dequespuede crecer a cualquier longitud. De lo contrario, dequelimite a la longitud máxima especificada. Una vez que la longitud limitada dequeestá completa, cuando se agregan nuevos elementos, se extrae la misma cantidad de elementos desde el otro extremo.

Métodos admitidos:

• append(x): agregar xal extremo derecho
• appendleft(x): agregado xal extremo izquierdo
• clear(): Borrar todos los elementos, la longitud se convierte en 0
• copy(): Crear una copia superficial
• count(x): Calcular el número de xelementos en la cola igual a
• extend(iterable): agregue iterablelos elementos en el lado derecho de la cola
• extendleft(iterable): agregue iterablelos elementos en el lado izquierdo de la cola, nota: al agregar en el lado izquierdo, iterableel orden de los parámetros se agregará a la inversa
• index(x[,start[,stop]]): Devuelve el xelemento ( startcontando desde, stopantes). Devuelve la primera coincidencia o , si no se encuentra Raise ValueError.
• insert(i,x)i: Insertar en la posición x. Nota: Si la inserción causa que un límite dequeexceda la longitud maxlen, entonces sí Raise IndexError.
• pop(): eliminar el elemento más a la derecha
• popleft(): eliminar el elemento más a la izquierda
• remove(value): Eliminar el primero que se encuentre value. no tiróValueError
• reverse(): dequeOrganizar en orden inverso. volver None_
• maxlen: La longitud máxima de la cola, si no está limitada None.

---

El siguiente es un ejemplo de funcionamiento:

>>> from collections import deque
>>> d = deque(maxlen=10)
>>> d
deque([], maxlen=10)
>>> d.extend('python')
>>> [i.upper() for i in d]
['P', 'Y', 'T', 'H', 'O', 'N']
>>> d.append('e')
>>> d.appendleft('f')
>>> d
deque(['f', 'p', 'y', 't', 'h', 'o', 'n', 'e'], maxlen=10)

Cap.VI ChainMap

Un ChainMapgrupo de varios diccionarios u otras asignaciones para crear una única vista actualizable. Si no se mapsespecifica, se proporciona un diccionario vacío predeterminado. ChainMapes una herramienta útil para administrar contextos anidados y anulaciones.

>>> from collections import ChainMap
>>> d1 = {
    
    'apple':1,'banana':2}
>>> d2 = {
    
    'orange':2,'apple':3,'pike':1}
>>> combined_d = ChainMap(d1,d2)
>>> reverse_combind_d = ChainMap(d2,d1)
>>> combined_d 
ChainMap({
    
    'apple': 1, 'banana': 2}, {
    
    'orange': 2, 'apple': 3, 'pike': 1})
>>> reverse_combind_d
ChainMap({
    
    'orange': 2, 'apple': 3, 'pike': 1}, {
    
    'apple': 1, 'banana': 2})
>>> for k,v in combined_d.items():
...      print(k,v)
... 
pike 1
apple 1
banana 2
orange 2
>>> for k,v in reverse_combind_d.items():
...      print(k,v)
... 
pike 1
apple 3
banana 2
orange 2