Contagem Python: Padrões modernos, armadilhas e exemplos práticos

Contar coisas parece meio bobo até que os resultados pareçam um pouco — ou muito — errados. Já vi verificações de frequência feitas com chamadas repetidas de list.count() ou métodos pandas mal utilizados que ignoram silenciosamente valores ausentes. O resultado: código lento e números errados. A solução é usar a ferramenta certa para o trabalho: collections.Counter para mapas de frequência, count() integrado para consultas rápidas de valor único e value_counts() do pandas quando você estiver em um DataFrame.

O que é o Counter e como funciona

collections.Counter é uma subclasse do dicionário para contar objetos hashable (um multiconjunto). Você pode criar um objeto " Counter " a partir de um iterável ou um mapeamento. As chaves ausentes são padronizadas como 0; as contagens podem ser incrementadas ou decrementadas; e vários métodos convenientes tornam as tarefas comuns mais simples.

from collections import Counter

# From an iterable (one pass over the data)
nyc_eatery_types = [
    "Mobile Food Truck", "Food Cart", "Snack Bar", "Restaurant", "Food Cart",
    "Restaurant", "Mobile Food Truck", "Snack Bar", "Mobile Food Truck"
]
eatery_type_counts = Counter(nyc_eatery_types)
print(eatery_type_counts)  # dict-like view
print(eatery_type_counts["Restaurant"])  # missing keys return 0 instead of KeyError
print(eatery_type_counts["Kiosk"])

Counter({'Mobile Food Truck': 3, 'Food Cart': 2, 'Snack Bar': 2, 'Restaurant': 2})
2
0

Não confie na ordem de iteração de um ` Counter`. Quando você precisar de uma visualização classificada, use most_common().

Descubra os valores mais comuns com most_common()

Counter.most_common(n) retorna uma lista de pares de valores e chaves ( (item, count) ) em ordem decrescente de contagem. Use n para limitar o resultado ou deixe de fora para pegar todos os pares.

top_3 = eatery_type_counts.most_common(3)
print(top_3)

[('Mobile Food Truck', 3), ('Food Cart', 2), ('Snack Bar', 2)]

Use isso quando precisar de análises de frequência, tabelas de classificação ou verificações rápidas de sanidade em dados categóricos.

Faça mais com o Counter

atualizar e subtrair contagens

Os dados comerciais mudam. update() aumenta as contagens, enquanto subtract() as reduz. Ambos aceitam iteráveis ou mapeamentos.

new_permits = ["Restaurant", "Food Cart", "Restaurant"]
eatery_type_counts.update(new_permits)  # add 1 for each occurrence
print(eatery_type_counts)

closures = {"Snack Bar": 1}
eatery_type_counts.subtract(closures)   # reduce counts (can go negative)
print(eatery_type_counts)

Counter({'Mobile Food Truck': 3, 'Restaurant': 4, 'Food Cart': 3, 'Snack Bar': 2})
Counter({'Restaurant': 4, 'Mobile Food Truck': 3, 'Food Cart': 3, 'Snack Bar': 1})

Se uma contagem cair para 0 ou menos, métodos como elements() e most_common() vão ignorá-la. Para remover uma chave completamente, use del counter[key].

calcular totais e top-N

A partir do Python 3.10, Counter.total() mostra a soma de todas as contagens. Isso é útil quando você precisa de proporções ou divisões.

total_permits = eatery_type_counts.total()
for eatery, count in eatery_type_counts.most_common(3):
    share = count / total_permits
    print(f"{eatery}: {count} ({share:.1%})")

reconstrua sequências com elements()

elements() retorna cada elemento tantas vezes quanto sua contagem. A ordem é meio aleatória.

expanded = list(eatery_type_counts.elements())
print(len(expanded), "items reconstructed from counts")

use operações matemáticas e de conjuntos

Você pode juntar contadores com operações aritméticas e do tipo mínimo/máximo. Os resultados não incluem contagens zero e negativas.

from collections import Counter

a = Counter({"Food Cart": 5, "Restaurant": 2})
b = Counter({"Food Cart": 3, "Snack Bar": 4})

print(a + b)   # add counts
print(a - b)   # subtract (keeps positives only)
print(a & b)   # intersection: min of counts
print(a | b)   # union: max of counts

Counter({'Food Cart': 8, 'Snack Bar': 4, 'Restaurant': 2})
Counter({'Food Cart': 2, 'Restaurant': 2})
Counter({'Food Cart': 3})
Counter({'Food Cart': 5, 'Snack Bar': 4, 'Restaurant': 2})

Quando usar list.count(), Counter ou pandas

Escolha a ferramenta mais simples que atenda às suas necessidades e restrições de desempenho.

verificações de valor único com count()

Use o método integrado ` count() ` quando você só precisa saber quantas vezes um valor aparece numa sequência ou contar quantas subcadeias não sobrepostas existem numa string.

numbers = [1, 2, 2, 3, 2]
print(numbers.count(2))  # 3

word = "banana"
print(word.count("a"))   # 3

text = "aaa"
print(text.count("aa"))  # 1: non-overlapping matches only
print("cat".count(""))   # 4: empty string counts len(s)+1 positions

Cuidado com booleanos e inteiros: True == 1 e False == 0. Isso pode aumentar as contagens se você misturar tipos.

mixed = [1, True, 0, False, True]
print(mixed.count(1))  # 3 (counts 1 and True)
print(mixed.count(0))  # 2 (counts 0 and False)

Evite chamar repetidamente o método ` count() ` dentro de loops em grandes volumes de dados; cada chamada verifica toda a sequência.

# Inefficient: O(n^2) for large lists
# freq = {x: numbers.count(x) for x in numbers}

# Efficient: one pass
from collections import Counter
freq = Counter(numbers)

várias frequências com contador

Quando você precisar de contagens para muitos valores únicos, crie uma tabela de contagem ( Counter ) uma vez e consulte-a conforme necessário. É claro, rápido e feito pra esse tipo de situação.

dados tabulares com pandas

Nos pandas, DataFrame.count() e Series.count() calculam contagens sem faltas. Para obter uma tabela de frequência de valores, use Series.value_counts().

import pandas as pd
df = pd.DataFrame({
    "line": ["A", "A", "B", None, "B", "B"],
    "ridership": [100, None, 120, 130, None, 150],
})

print(df["line"].count())         # 5 (non-missing)
print(df["line"].value_counts())  # value frequencies

# For full row count, use len(df), not df.count()
print(len(df))                    # 6

Valide e limpe os dados com o Counter

Antes da análise, eu verifico a consistência categórica, valores inesperados e duplicatas. O Counter torna essas verificações rápidas e repetíveis.

from collections import Counter

# Example: validate allowed categories
allowed_types = {"Mobile Food Truck", "Food Cart", "Snack Bar", "Restaurant"}
type_counts = Counter(nyc_eatery_types)

unexpected = {t: c for t, c in type_counts.items() if t not in allowed_types}
if unexpected:
    print("Unexpected categories found:", unexpected)

# Example: flag duplicates (e.g., station IDs appearing more than once)
station_ids = ["ST-001", "ST-002", "ST-003", "ST-002", "ST-004", "ST-002"]
dup_counts = Counter(station_ids)
duplicates = [sid for sid, c in dup_counts.items() if c > 1]
print("Duplicate station IDs:", duplicates)

Dicas práticas e erros comuns

Esses detalhes economizam tempo e evitam erros sutis.

• Counter é tipo um dicionário: chaves que não existem devolvem 0; use del counter[key] para remover entradas. Evite guardar zeros, a menos que você precise deles temporariamente.

• Não confie na ordem de iteração. Use most_common() para obter resultados classificados.

• str.count() conta correspondências que não se sobrepõem. Para contagens de subcadeias sobrepostas, use re.finditer().

• Evite chamar várias vezes o método ` list.count() ` na mesma sequência grande. Em vez disso, crie um Counter.

• No pandas, .count() é pra contagens sem faltas; usa .value_counts() pra frequências de valores.

Padrões mínimos nos quais confio

Esses são os trechos que eu uso mais na produção e no ensino.

• Mapa de frequência de uma passagem: Counter(iterable)

• Categorias Top-N: Counter(data).most_common(n)

• Atualizações incrementais: counter.update(batch) ou counter.subtract(batch)

• Verificação de valor único: sequence.count(x) (evite em loops)

• Frequências tabulares: df["col"].value_counts() (não df.count())

Conclusão

collections.Counter é a ferramenta certa para contar vários valores de forma rápida e clara. Use o count() integrado para verificações pontuais, o C ounter para mapas de frequência e análise top-N, e o Series.value_counts() quando estiver trabalhando com pandas. Fique de olho nos casos extremos de contagem de strings, equivalência booleana-inteira e a diferença entre contagens sem ausências e frequências de valores. Com esses padrões, suas contagens serão rápidas e corretas.