Python Counter: cómo contar elementos con esta subclase

La clase Counter de Python se utiliza para contar elementos en un co­n­te­ne­dor. Es una subclase de Di­c­tio­na­ry que tiene numerosos usos en co­m­bi­na­ción con di­fe­re­n­tes métodos.

¿Qué es Python Counter?

Counter de Python es una he­rra­mie­n­ta útil que puede contar varios elementos en una lista y muestra con qué fre­cue­n­cia se producen estos elementos. Es una subclase de Di­c­tio­na­ry. Aunque esta tarea se puede realizar fácil y ma­nua­l­me­n­te para una secuencia corta de valores, es mucho más co­m­pli­ca­do para conjuntos de datos largos. El propio Counter es una variable entera que tiene el valor inicial “0”. Un único contador indica la fre­cue­n­cia de un objeto. Si quieres tener en cuenta varios objetos di­fe­re­n­tes, utiliza un contador distinto para cada uno de ellos.

La clase Counter puede aplicarse a listas, tuplas de Python, Di­c­tio­na­ries y cadenas de Python. Su sintaxis es la siguiente:

Counter(list)

En los si­guie­n­tes apartados te mo­s­tra­re­mos cómo puede uti­li­zar­se Counter en la práctica con algunos ejemplos sencillos.

Counter con una lista

En el primer ejemplo, creamos una lista simple con di­fe­re­n­tes valores. El aspecto es el siguiente:

Lista = ['a', 'a', 'b', 'a', 'c', 'b', 'b', 'c', 'a', 'c', 'b', 'c', 'c']

La lista tiene tres elementos di­fe­re­n­tes: a, b y c. Para averiguar la fre­cue­n­cia con la que aparece cada uno de estos elementos, uti­li­za­mos Counter. El resultado sería el siguiente:

Counter({'c' : 5, 'a' : 4, 'b' : 4})

Para utilizar Counter, primero hay que importar la clase. El resultado se muestra con print. El código completo para este ejemplo sería el siguiente:

from collections import Counter 
Lista = ['a', 'a', 'b', 'a', 'c', 'b', 'b', 'c', 'a', 'c', 'b', 'c', 'c'] 
counter_lista = Counter(Lista) 
print(Counter(Lista))

El resultado sería el siguiente:

Counter({'c' : 5, 'a' : 4, 'b' : 4})

Así funciona la clase Counter con una tupla

En el segundo ejemplo pro­ce­de­mos de forma muy similar. Esta vez el contador se va a aplicar a una tupla. Las tuplas se utilizan en Python para almacenar varios valores en una variable. Como se trata de una agru­pa­ción ordenada de objetos, se tiene en cuenta el orden. Los objetos se colocan entre corchetes y se separan por comas. El código tendría la siguiente forma:

from collections import Counter 
Tupla = ('a', 'a', 'b', 'a', 'c', 'b', 'b', 'c', 'a', 'c', 'b', 'c', 'c') 
print(Counter(Tupla))

El resultado sería el siguiente:

Counter({'c' : 5, 'a' : 4, 'b' : 4})

Uti­li­za­ción en la clase Dictionary

En un Di­c­tio­na­ry, los elementos se almacenan como pares clave-valor y se colocan entre llaves. Si utilizas el contador para el Di­c­tio­na­ry, éste se convierte en un objeto hashtable. Los elementos se co­n­vie­r­ten en claves y sus valores en el número del di­c­cio­na­rio original. Para nuestro ejemplo anterior, se vería así:

from collections import Counter 
Dictionary = {'a' : 4, 'b' : 4, 'c' : 5} 
counter_dictionary = Counter(Dictionary) 
print(Counter(Dictionary))

El resultado sería el siguiente:

Counter({'c' : 5, 'a' : 4, 'b' : 4})

Counter de Python en co­m­bi­na­ción con una cadena simple

Puedes hacerte una idea del ahorro de tiempo y la facilidad de trabajo que puede ofrecer Counter aplicando la clase a una cadena. Una cadena es una secuencia de ca­ra­c­te­res marcados por comillas. También se tienen en cuenta los espacios. Elegimos la siguiente cadena para nuestro ejemplo:

from collections import Counter 
Cadena = "Esto es un ejemplo." 
counter_string = Counter(Cadena) 
print(Counter(Cadena))

Ahora cada carácter se cuenta como una subcadena. Por lo tanto, el resultado podría ser el siguiente:

Counter({'e': 4, ' ': 3, 's': 2, 't': 2, 'o': 2, 'u': 1, 'n': 1, 'j': 1, 'm': 1, 'p': 1, 'l': 1, '.': 1})

Ex­te­n­sio­nes con .update()

Las opciones que ofrece Counter son diversas. Por ejemplo, también es posible ampliar un contador existente. Para ello, utiliza .update() y conecta esta extensión al contador. Primero creamos un código simple según el principio anterior, por el que no marcamos la cadena para un cambio:

from collections import Counter 
Counter("rojo") 
print(Counter(Cadena))

Nuestro resultado es el siguiente:

Counter({'r' : 1, 'o' : 2, 'j' : 1})

Si ahora aplicamos .update(), el código queda así:

from collections import Counter 
colores = Counter({'r' : 1, 'o' : 2, 'j' : 1}) 
colores.update("marrón") 
print(colores)

Esto nos da un resultado ac­tua­li­za­do:

Counter({'o' : 3, 'r' : 3, 'a' : 1, 'j' : 1, 'n' : 1})

Acceder a los valores Counter

Tienes la opción de acceder a los valores de Counter, ya que esta clase funciona de forma similar a Dictionary. En el siguiente ejemplo de código te mostramos algunas va­ria­cio­nes y las co­rre­s­po­n­die­n­tes salidas. Aquí, las “letters” actúan como claves (keys) y los “counts” como valores (values).

from collections import Counter 
letters = Counter("banana") 
letters["a"] 
3 
letters["n"] 
2

for letter in letters: 
print(letter, letters[letter]) 
b 1
a 3
n 2

Este es el aspecto que tendría un ejemplo con el método .keys():

for letter in letters.keys(): 
print(letter, letters[letter]) 
b 1
a 3
n 2

Este es un ejemplo con .values():

for count in letters.values(): 
print(count) 
1
3
2

Así sería con el método .items():

for letter, count in letters.items(): 
print(letter, count) 
b 1 
a 3
n 2

Eliminar elementos de la clase

Si quieres borrar un elemento de Counter, del es la opción adecuada para ello:

from collections import Counter 
ejemplo = {'r' : 1, 'o' : 2, 'j' : 1} 
del ejemplo["r"] 
print(Counter(ejemplo))

El resultado será el siguiente:

Counter({'o' : 2, 'j' : 1})

De­te­r­mi­nar la mayor acu­mu­la­ción con most_common(n)

Con most_common(n) para Counter puedes averiguar qué elementos son más y menos comunes. Co­n­si­de­re­mos un ejemplo en el que un producto aparece en di­fe­re­n­tes colores. Junto a los colores se indica la fre­cue­n­cia con la que el producto sigue en stock en la variante co­rre­s­po­n­die­n­te. Un valor negativo significa que ya no existe el artículo co­rre­s­po­n­die­n­te en el almacén, pero que, sin embargo, esta variante ha sido objeto de un pedido an­ti­ci­pa­do. Si ahora queremos comprobar qué variante tiene todavía más artículos en stock, podemos utilizar este código:

from collections import Counter 
variante_color = Counter({'azul' : 2, 'gris' : -1, 'negro' : 0}) 
artículos = variante_color.most_common(1) 
print(artículos)

El resultado es el siguiente:

[('azul' : 2)]

También podemos mostrar el menor número de artículos. Para ello, cambiamos el código de la siguiente manera:

from collections import Counter 
variante_color = Counter({'azul' : 2, 'gris : -1, 'negro' : 0}) 
menos_artículos = variante_color.most_common()[:-2:-1] 
print(menos_artículos)

El resultado sería:

[('gris' : -1)]

Cálculos ari­t­mé­ti­cos con Counter

Con Counter también puedes llevar a cabo cálculos ari­t­mé­ti­cos. Sin embargo, es im­po­r­ta­n­te tener en cuenta que solo se obtienen valores positivos. En el siguiente código probamos algunos tipos de cálculo:

Una suma simple:

from collections import Counter 
x = Counter(a=4, b=2, c=1) 
y = Counter(a=2, b=1, c=2) 
z = x + y 
print(z)

Counter({'a' : 6, 'b' : 3, 'c' : 3})

Así sería la resta:

from collections import Counter 
x = Counter(a=4, b=2, c=1) 
y = Counter(a=2, b=1, c=2) 
z = x - y 
print(z)

Counter({'a' : 2, 'b' : 1})

Como el valor de “c” ahora sería negativo, no se incluye en el resultado.

Ordenar tipos de datos por fre­cue­n­cia

Otra opción que ofrece la clase es una enu­me­ra­ción de tipos de datos en una carpeta. Como ejemplo, ima­gi­ne­mos una carpeta llamada “Imágenes” que contiene numerosos archivos di­fe­re­n­tes con distintos tipos de datos. Uti­li­za­mos el siguiente código para una lista:

import pathlib 
from collections import Counter 
ruta_carpeta = pathlib.Path("Imagenes/") 
extensions = [entry.suffix for entry in ruta_carpeta.iterdir() if entry.is_file()] 
extension_counter = Counter(extensions) 
print(extension_counter)

Excluir valores negativos y cero

Para eliminar valores cero o negativos con Counter, utiliza este código:

from collections import Counter 
valores = Counter(a=6, b=0, c=1, d=-4) 
valores = +valores 
print(valores)

El resultado sería el siguiente:

Counter({'a' : 6, 'c' : 1})