1.Counters como un contenedor, se puede seguir el mismo valor aumentó muchas veces. Esta clase se puede utilizar para implementar otros idiomas comúnmente paquete (bolsa) o conjunto (conjunto múltiple) la estructura de datos algoritmos implementados.
inicialización
Apoyo de recuento en forma de 3 inicialización. Una secuencia de elementos se puede proporcionar al llamar al constructor de contador o una llave que comprende diccionario y contando, también se puede utilizar para asignar un nombre de cadena de palabras clave de parámetros de recuento.
colecciones de importación
imprimir (collections.Counter ([ 'a', 'b', 'c', 'a', 'b', 'c']))
imprimir (collections.Counter ({ 'a': 2, 'b': 3, 'c': 1}))
de impresión (collections.Counter (a = 2, b = 3, c = 1))
Si no se proporciona ningún parámetro, se puede construir un nulo Contador, y el método por el llenado de actualización ().
colecciones de importación
c = collections.Counter ()
print ( 'Intervalo:', c)
c.update ( 'abcdaab')
print ( 'Secuencia', c)
c.update ({ 'a': 1, 'd': 5 })
El nuevo aumento de valor de recuento de datos, no reemplazo de cambio de datos de recuento.
Intervalo: Counter ()
contador de secuencia ({ 'a': 3 'b': 2, 'c': 1, 'd': 1})
Dict: Counter ({ 'd': 6 'a': 4 , 'b': 2, 'c': 1})
recuento de acceso
Una vez llenado el contador, puede utilizar la API de diccionario para obtener su valor.
c = collections.Counter ( 'abcdaab')
para la letra en 'abcde':
print ( '% s:% d' % (carta, c [carta]))
De elementos desconocidos, sin contador KeyError. Si no se encuentra un valor (e como en este ejemplo) de la entrada, se cuenta como 0.
a: 3 b: 2 c: 1 d: 1 e: 0
elementos () devuelve el método un iterador que genera todos los elementos conocidos de contador.
c = collections.Counter ( 'extremadamente') c [ 'z'] = 0 de impresión (c) impresión (lista (c.elements ()))
No garantiza el orden de los mismos elementos, los elementos más contador es menor que o igual a 0 no está incluido.
Contador ({ 'e': 3 'x': 1, 't': 1, 'r': 1, 'm': 1, 'l': 1, 'y': 1, 'z': 0 })
[ 'e', 'e', 'e', 'x', 't', 'r', 'm', 'l', 'y']
Uso most_common () puede generar una secuencia de valores de entrada N, que comprende los más frecuentes y el recuento correspondiente.
c = collections.Counter ()
con ( 'words.text', 'rt') abierto como f:
para la línea en f:
(. line.rstrip () inferior a ()) c.update
print ( 'más comunes:')
de la carta, el recuento de c.most_common (3):
print ( '% s:% 7d' % (carta, recuento))
Todas las letras de esta palabra parece ser un ejemplo de sistema estadístico para generar una distribución de frecuencias, y luego imprimir el tres letras más común. Si no hay parámetro a most_common (), para generar una lista de todos los elementos que constituyen. Dispuestos en frecuencia.
Más común: o: 15 j: 12 d: 10
operación aritmética
Ejemplos contador de espacio de soportes operaciones aritméticas para completar y agregación de los resultados.
c1 = collections.Counter ([ 'a', 'b', 'c', 'a', 'b', 'b'])
c2 = collections.Counter ( 'alfabeto')
print ( 'C1:', c1 )
print ( 'C2:', c2)
print ( '\ conteos nCombined:')
(C1 + C2) de impresión
de impresión ( '\ nSubtraction:')
print (C1 - C2)
print ( '\ nIntersection (teniendo mínimos positivos): ')
de impresión (c1 y c2)
print (' \ nunion (teniendo máximos): ')
print (c1 | c2)
Cada vez que un nuevo contador generada por una operación, el recuento es 0 o suprimir elementos negativos. La misma cuenta en un c1 y c2, de manera que después de la sustracción de su recuento de 0.
C1: Counter ({ 'b': 3 'a': 2, 'c': 1})
C2: Counter ({ 'a': 2, 'l': 1, 'p': 1, 'h' : 1, 'b': 1, 'e': 1, 't': 1})
combinado recuentos:
contador ({ 'a': 4 'b': 4, 'c': 1, 'l': 1, 'p': 1 'h': 1, 'e': 1, 't': 1})
Sustracción:
Contador ({ 'b': 2, 'c': 1})
Intersección (teniendo mínimos positivos ):
Contador ({ 'a': 2, 'b': 1})
Unión (teniendo máximos):
Contador ({ 'b': 3 'a': 2, 'c': 1, 'l': 1 , 'p': 1 'h': 1, 'e': 1, 't': 1})
2.defaultdict. diccionario estándar incluye un setdefault () para obtener un valor, si el valor no existe, crear un valor predeterminado. Por el contrario, el contenedor defaultdict inicialización es dejar que la persona que llama especificar un valor predeterminado de antemano.
def default_factory) (:
retorno 'default valor'
d = collections.defaultdict (default_factory, foo = 'bar')
print ( 'd', d)
print ( 'foo =>', d [ 'foo'])
print (' bar =>', d [ 'bar'])
Mientras todas las teclas tienen el mismo valor por defecto no es apropiada. Puede utilizar este método. Si el valor predeterminado para el tipo de valor agregado o acumulativa, tales como: lista, conjunto o incluso int, este método es especialmente útil.
d defaultdict (<función default_factory en 0x00000000024F9DC8>, { 'foo': 'bar'})
foo => bar
bar => valor predeterminado
3.deque. (Cola de composición doble) Añadir soporte y los elementos de eliminación de cualquier período. El más común dos estructuras, es decir, pilas y colas, es forma degradada deque, en la entrada y el período límite de salida.
d = collections.deque ( 'abcdefg') print ( 'Deque:', d) impresión ( 'Longitud:', len (d)) (extremo izquierdo: ', d [0]) de impresión de impresión (extremo derecho: ', d [-1]) d.remove ( 'c') print ( 'remove (c):', d)
Dado que algunas operaciones es un contenedor deque secuencia, la lista también soporta, como con el __getitem __ () compruebe el contenido, la longitud, y elementos eliminar de la secuencia intermedia por hora a juego.
Deque: deque ([ 'a', 'b', 'c', 'd', 'e', 'f', 'g']) Longitud: 7 extremo izquierdo: un extremo derecho: g remove (c): deque ([ 'a', 'b', 'd', 'e', 'f', 'g'])
relleno
deque se puede rellenar desde cualquier extremo, que puede ser llenado con el relleno de la izquierda y la derecha.
#ADD a la derecha d1 = collections.deque () d1.extend ( 'abcdefg') print ( 'extender:', d1) d1.append ( 'h') print ( 'append:', d1) #ADD a la izquierda d2 = collections.deque () d2.extendleft (rango (6)) print ( 'extendleft:', d2) d2.appendleft (6) print ( 'appendleft:', d2)
extendleft () la función de su entrada de un proceso iterativo, el mismo proceso para cada elemento de la realización y appendleft (). El resultado final es un deque contiene el orden inverso de la secuencia de entrada.
extender: deque ([ 'a', 'b', 'c', 'd', 'e', 'f', 'g']) append: deque ([ 'a', 'b', 'c' , 'd', 'e', 'f', 'g', 'h']) extendleft: deque ([5, 4, 3, 2, 1, 0]) appendleft: deque ([6, 5, 4 , 3, 2, 1, 0])
uso
Del mismo modo, el uso de elementos de la deque cualquier extremo o en ambos extremos, en función del algoritmo aplicado.
imprimir ( 'Desde la derecha:')
d = collections.deque ( 'abcdefg')
while True:
try:
impresión (d.pop ())
, excepto IndexError:
ruptura
: print ( '\ nde la izquierda')
colecciones d =. deque (rango (6))
while True:
try:
impresión (d.popleft ())
, excepto IndexError:
ruptura
Uso pop (0 puede eliminar un elemento desde el extremo derecho de la deque usando popleft () puede eliminar un elemento del extremo izquierdo de la deque.
Desde la derecha: g f e d c b a partir de la izquierda: 0 1 2 3 4 5
Dado que el deque es seguro hilo, incluso es posible simultáneamente desde ambos extremos utilizando los contenidos de la cola en diferentes hilos.