Recuento de Python: Patrones modernos, dificultades y ejemplos prácticos

Contar cosas parece trivial hasta que los resultados difieren un poco, o mucho. He visto comprobaciones de frecuencia realizadas con llamadas repetidas a list.count() o métodos pandas mal utilizados que omiten silenciosamente los valores que faltan. El resultado: código lento y números incorrectos. La solución es utilizar la herramienta adecuada para cada tarea: collections.Counter para mapas de frecuencia, count() integrado para consultas rápidas de un solo valor y value_counts() de pandas cuando estés en un DataFrame.

¿Qué es el contador y cómo funciona?

collections.Counter Es una subclase de diccionario para contabilizar objetos hashables (un multiconjunto). Puedes crear un objeto « Counter » a partir de un iterable o un mapeo. Las claves que faltan se establecen por defecto en 0; los recuentos se pueden incrementar o disminuir; y varios métodos prácticos facilitan las tareas comunes.

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

No confíes en el orden de iteración de un Counter. Cuando necesites una vista clasificada, utiliza most_common().

Encuentra los valores más comunes con most_common()

Counter.most_common(n) devuelve una lista de pares e (item, count) es en orden descendente según su recuento. Proporciona n para limitar el resultado u omítelo para obtener todos los pares.

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

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

Utiliza esto cuando necesites análisis de frecuencia, tablas de clasificación o comprobaciones rápidas de validez en datos categóricos.

Haz más con Counter

actualizar y restar recuentos

Los datos comerciales cambian. update() aumenta los recuentos, mientras que subtract() los reduce. Ambos aceptan iterables o mapeos.

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

Si un recuento cae a 0 o menos, métodos como elements() y most_common() lo ignoran. Para eliminar una clave por completo, utiliza del counter[key].

calcular totales y top-N

A partir de Python 3.10, Counter.total() devuelve la suma de todos los recuentos. Esto resulta útil cuando necesitas proporciones o participaciones.

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

reconstruir secuencias con elementos()

elements() devuelve cada elemento tantas veces como indique su recuento. La orden es arbitraria.

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

utilizar operaciones matemáticas y de conjunto

Puedes combinar contadores con operaciones aritméticas y de tipo mínimo/máximo. Los resultados descartan los recuentos cero y negativos.

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

Cuándo utilizar list.count(), Counter o pandas

Elige la herramienta más sencilla que satisfaga tus necesidades y limitaciones de rendimiento.

Comprobaciones de valor único con count()

Utiliza la función integrada ` count() ` cuando solo necesites saber cuántas veces aparece un valor en una secuencia o el recuento de subcadenas no superpuestas en una cadena.

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

Ten cuidado con los valores booleanos y los enteros: True == 1 y False == 0. Esto puede inflar los recuentos si mezclas 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)

Evita llamar repetidamente a count() dentro de bucles con datos de gran tamaño; cada llamada escanea toda la secuencia.

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

múltiples frecuencias con contador

Cuando necesites recuentos para muchos valores únicos, crea una tabla de valores ( Counter ) una vez y consúltala según sea necesario. Es claro, rápido y está diseñado para este caso de uso.

datos tabulares con pandas

En pandas, DataFrame.count() y Series.count() calculan recuentos sin faltas. Para obtener una tabla de valores de frecuencia, utiliza 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

Validar y limpiar datos con Counter

Antes del análisis, compruebo la coherencia categórica, los valores inesperados y los duplicados. Counter permite realizar estas comprobaciones de forma rápida y repetible.

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)

Notas prácticas y errores comunes

Estos detalles ahorran tiempo y evitan errores sutiles.

• Counter Es similar a un diccionario: las claves que faltan devuelven 0; utiliza del counter[key] para eliminar entradas. Evita almacenar ceros a menos que los necesites temporalmente.

• No confíes en el orden de iteración. Utiliza most_common() para obtener resultados clasificados.

• str.count() cuenta las coincidencias que no se superponen. Para el recuento de subcadenas superpuestas, utiliza re.finditer().

• Evita llamadas repetidas a list.count() en la misma secuencia grande. En su lugar, crea un Counter.

• En pandas, .count() se utiliza para recuentos sin valores perdidos; utiliza .value_counts() para frecuencias de valores.

Patrones mínimos en los que confío

Estos son los fragmentos que utilizo con más frecuencia en la producción y la enseñanza.

• Mapa de frecuencia de una sola pasada: Counter(iterable)

• Categorías principales: Counter(data).most_common(n)

• Actualizaciones incrementales: counter.update(batch) o counter.subtract(batch)

• Comprobación de un solo valor: sequence.count(x) (evitar en bucles)

• Frecuencias tabulares: df["col"].value_counts() (no df.count())

Conclusión

collections.Counter es la herramienta adecuada para contar múltiples valores de forma rápida y clara. Utiliza la función integrada count() para comprobaciones puntuales, Counter para mapas de frecuencia y análisis top-N, y Series.value_counts() cuando trabajes con pandas. Presta atención a los casos extremos de recuento de cadenas, la equivalencia entre booleanos e enteros, y la diferencia entre recuentos sin faltas y frecuencias de valores. Con estos patrones, tus recuentos serán rápidos y correctos.