# 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 combinação com diferentes métodos, tem várias aplicações possíveis.

## O que é Python `Counter`?

O Python `Counter` é uma ferramenta útil que pode contar diferentes elementos em uma lista e mostrar **a frequência com que esses elementos aparecem**. Trata-se de uma subclasse do [dicionário Python](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-dictionary-dicionarios-python/ "Dicionário Python"). Embora essa tarefa possa ser feita manualmente 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ência de um objeto. Se você quiser considerar objetos diferentes, use um contador separado para cada um.

A classe `Counter` pode ser aplicada a listas, [tuplas em Python](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-tuples/ "Tuplas em Python"), dicionários e [strings em Python](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-string/ "Strings em Python"). A sintaxe do `Counter` é a seguinte:

```python
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 diferentes valores:

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

A lista possui três elementos diferentes: ‘a’, ‘b’ e ‘c’. Para descobrir a frequência de cada um desses elementos, aplicamos o Python `Counter`. A saída será:

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

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

```python
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 resultante será:

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

## Python `Counter` com tupla

No segundo exemplo, procedemos de forma muito semelhante. 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 parênteses e separados por vírgulas. Assim, o código é da seguinte forma:

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

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

## Python `Counter` na classe `Dictionary`

Em um dicionário Python, os elementos são definidos como **pares chave-valor** e colocados entre chaves `{}`. Quando você aplica o Python `Counter` a um dicionário, ele considera as chaves como elementos e seus valores como contagens. As chaves do dicionário representam os elementos, enquanto os valores indicam suas quantidades no dicionário original. Para o nosso exemplo anterior, isso poderia ser assim:

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

A saída será novamente:

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

Dica Em apenas três etapas, com o [Deploy Now](https://www.ionos.com/hosting/deploy-now "Deploy Now — IONOS") da IONOS, você conecta seu repositório, executa a construção automaticamente e acessa uma infraestrutura confiável. Aproveite os planos adequados e uma consultoria especializada!

## Python `Counter` em combinação com strings simples

Para ter uma ideia de como o Python `Counter` pode economizar tempo e facilitar o trabalho, aplique a classe a uma *string*. Uma *string* é uma **sequência de caracteres** delimitada por aspas. Espaços em branco também são considerados. Escolhemos a seguinte *string* para nosso exemplo:

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

Agora, cada caractere é contado individualmente como uma chave no `Counter`. A saída esperada será:

```python
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 funcionalidades oferecidas 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*:

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

Nossa saída será:

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

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

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

Isso resulta na saída:

```python
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 semelhante a um `dict`**. No exemplo de código a seguir, mostramos algumas variações e suas respectivas saídas. Aqui, `letters` representa as chaves (*keys*) e `counts`, os valores (*values*).

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

```python
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()`:

```python
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()`:

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

Este é o método `.items()`:

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

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

Sua nova saída será:

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

## Determinar a maior ocorrência com `most_common(n)`

Com `most_common(n)` para Python `Counter`, você pode identificar os elementos mais frequentes. Para isso, consideremos um exemplo em que um produto está disponível em várias cores. Além das cores, o número de itens disponíveis em estoque também é indicado. Um valor negativo indica que a variante não está mais disponível em estoque, mas foi pré-encomendada. Se quisermos verificar qual variante tem a maior quantidade de itens, usamos o seguinte código:

```python
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á:

```python
[('azul', 2)]
```

Também podemos exibir a menor quantidade de itens. Para isso, modificamos o código da seguinte forma:

```python
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 correspondente será:

```python
[('cinza', -1)]
```

## Operações aritméticas com Python `Counter`

O Python `Counter` também permite **operações aritméticas**. No entanto, é importante observar que apenas valores positivos são exibidos. No código a seguir, testamos algumas operações matemáticas.

Uma simples adição:

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

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

A subtração:

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

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

Como o valor de `c` agora seria negativo, ele não é exibido.

## Ordenar tipos de dados por frequência com Python `Counter`

Outra funcionalidade 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 diferentes com vários tipos de dados. Para listar, usamos o seguinte código:

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

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

A saída correspondente será:

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

Dica Nosso Digital Guide tem muitos outros artigos sobre a linguagem de programação Python. Neste explicamos quais [operadores Python](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/operadores-python/) existem, guiamos você pela instalação do Python e [ensinamos a usar Python](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/aprender-python/ "Aprender Python").


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-counter/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-counter/) for AI/LLM consumption.