Como contar elementos com Python Counter

A classe Python Counter é usada para contar elementos em um contêiner. Ela é uma subclasse de dict que, em com­bi­na­ção com di­fe­ren­tes métodos, tem várias apli­ca­ções possíveis.

O que é Python Counter?

O Python Counter é uma fer­ra­menta útil que pode contar di­fe­ren­tes elementos em uma lista e mostrar a frequên­cia com que esses elementos aparecem. Trata-se de uma subclasse do di­ci­o­ná­rio Python. Embora essa tarefa possa ser feita ma­nu­al­mente e de forma simples para uma pequena sequência de valores, torna-se muito mais complexa para conjuntos de dados extensos. O Python Counter é, por si só, uma estrutura que inicia com o valor “zero”. Um único Counter armazena a frequên­cia de um objeto. Se você quiser con­si­de­rar objetos di­fe­ren­tes, use um contador separado para cada um.

A classe Counter pode ser aplicada a listas, tuplas em Python, di­ci­o­ná­rios e strings em Python. A sintaxe do Counter é a seguinte:

Counter(list)

Nas seções a seguir, você vai aprender com alguns exemplos simples como usar o Python Counter na prática.

Python Counter com lista

No primeiro exemplo, criamos uma lista simples com di­fe­ren­tes valores:

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

A lista possui três elementos di­fe­ren­tes: ‘a’, ‘b’ e ‘c’. Para descobrir a frequên­cia de cada um desses elementos, aplicamos o Python Counter. A saída será:

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

Para usar o Python Counter, primeiro é ne­ces­sá­rio importar a classe. O resultado é exibido com print. O código completo para este exemplo é:

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

A saída re­sul­tante será:

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

Python Counter com tupla

No segundo exemplo, pro­ce­de­mos de forma muito se­me­lhante. Desta vez, o Python Counter será aplicado a uma tupla. Tuplas são usadas em Python para armazenar múltiplos valores em uma variável. Como se trata de uma coleção ordenada de objetos, a ordem é levada em conta. Os objetos são colocados entre pa­rên­te­ses e separados por vírgulas. Assim, o código é da seguinte forma:

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

A saída será a mesma do exemplo anterior:

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

Python Counter na classe Dictionary

Em um di­ci­o­ná­rio Python, os elementos são definidos como pares chave-valor e colocados entre chaves {}. Quando você aplica o Python Counter a um di­ci­o­ná­rio, ele considera as chaves como elementos e seus valores como contagens. As chaves do di­ci­o­ná­rio re­pre­sen­tam os elementos, enquanto os valores indicam suas quan­ti­da­des no di­ci­o­ná­rio original. Para o nosso exemplo anterior, isso poderia ser assim:

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

A saída será novamente:

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

Python Counter em com­bi­na­ção com strings simples

Para ter uma ideia de como o Python Counter pode eco­no­mi­zar tempo e facilitar o trabalho, aplique a classe a uma string. Uma string é uma sequência de ca­rac­te­res de­li­mi­tada por aspas. Espaços em branco também são con­si­de­ra­dos. Es­co­lhe­mos a seguinte string para nosso exemplo:

from collections import Counter
string_exemplo = "Isso é um exemplo."
counter_string = Counter(string_exemplo)
print(Counter(string_exemplo))

Agora, cada caractere é contado in­di­vi­du­al­mente como uma chave no Counter. A saída esperada será:

Counter({'i': 4, 'e': 3, 's': 3, ' ': 3, 't': 2, 'D': 1, 'n': 1, 'B': 1, 'j': 1, 'p': 1, 'l': 1, '.': 1})

Expansões de Python Counter com .update()

As fun­ci­o­na­li­da­des ofe­re­ci­das pelo Python Counter são diversas. Por exemplo, é possível expandir uma contagem existente. Para isso, você usa .update() para expandir a contagem de um Counter. Primeiro, criamos um código simples para ilustrar o conceito acima sem destacar a string:

from collections import Counter 
string = "azul" 
print(Counter(string))

Nossa saída será:

Counter({'a': 1, 'z': 1, 'u': 1, 'l': 1})

Agora, aplicamos .update() para modificar a contagem:

from collections import Counter
cores = Counter({'b': 1, 'l': 1, 'a': 1, 'u': 1})
cores.update("cinza")
print(cores)

Isso resulta na saída:

Counter({'a': 2, 'b': 1, 'l': 1, 'u': 1, 'c': 1, 'i': 1, 'n': 1, 'z': 1})

Acessar valores de Python Counter

Você pode acessar os valores de um Python Counter, pois essa classe funciona de forma se­me­lhante a um dict. No exemplo de código a seguir, mostramos algumas variações e suas res­pec­ti­vas saídas. Aqui, letters re­pre­senta as chaves (keys) e counts, os valores (values).

from collections import Counter
letters = Counter("flachdach")
print(letters["a"])
2
print(letters["h"])
2

for letter in letters:
    print(letter, letters[letter])
f 1
l 1
a 2
c 2
h 2
d 1

Aqui está um exemplo com o método .keys():

for letter in letters.keys():
    print(letter, letters[letter])
 
f 1
l 1
a 2
c 2
h 2
d 1

Este é um exemplo com .values():

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

Este é o método .items():

for letter, count in letters.items():
    print(letter, count)
 
f 1
l 1
a 2
c 2
h 2
d 1

Excluir elementos da Python Counter

Se você deseja excluir um elemento do Python Counter, del é a escolha certa:

from collections import Counter
exemplo = {'b': 1, 'l': 1, 'a': 1, 'u': 1}
del exemplo["b"]
print(Counter(exemplo))

Sua nova saída será:

Counter({'l': 1, 'a': 1, 'u': 1})

De­ter­mi­nar a maior ocor­rên­cia com most_common(n)

Com most_common(n) para Python Counter, você pode iden­ti­fi­car os elementos mais fre­quen­tes. Para isso, con­si­de­re­mos um exemplo em que um produto está dis­po­ní­vel em várias cores. Além das cores, o número de itens dis­po­ní­veis em estoque também é indicado. Um valor negativo indica que a variante não está mais dis­po­ní­vel em estoque, mas foi pré-en­co­men­dada. Se quisermos verificar qual variante tem a maior quan­ti­dade de itens, usamos o seguinte código:

from collections import Counter
 estoque = Counter({'azul': 2, 'cinza': -1, 'preto': 0})
mais_vendido = estoque.most_common(1)
print(mais_vendido)

A saída esperada será:

[('azul', 2)]

Também podemos exibir a menor quan­ti­dade de itens. Para isso, mo­di­fi­ca­mos o código da seguinte forma:

from collections import Counter
estoque = Counter({'azul': 2, 'cinza': -1, 'preto': 0})
menos_vendido = estoque.most_common()[:-2:-1]
print(menos_vendido)

A saída cor­res­pon­dente será:

[('cinza', -1)]

Operações arit­mé­ti­cas com Python Counter

O Python Counter também permite operações arit­mé­ti­cas. No entanto, é im­por­tante observar que apenas valores positivos são exibidos. No código a seguir, testamos algumas operações ma­te­má­ti­cas.

Uma simples adição:

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

A subtração:

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 o valor de c agora seria negativo, ele não é exibido.

Ordenar tipos de dados por frequên­cia com Python Counter

Outra fun­ci­o­na­li­dade que a classe oferece é a contagem das extensões de arquivos em uma pasta. Por exemplo, uma pasta chamada “Imagens” que contém vários arquivos di­fe­ren­tes com vários tipos de dados. Para listar, usamos o seguinte código:

import pathlib
from collections import Counter
caminho_da_pasta = pathlib.Path("Imagens/")
extensoes = [entry.suffix for entry in caminho_da_pasta.iterdir() if entry.is_file()]
contador_de_extensoes = Counter(extensoes)
print(contador_de_extensoes)

Excluir valores negativos e nulos com Python Counter

Para remover valores nulos ou negativos com Python Counter, use o seguinte código:

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

A saída cor­res­pon­dente será:

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