# Python Counter: cómo contar elementos con esta subclase

La clase `Counter` de Python se utiliza para contar elementos en un contenedor. Es una subclase de Dictionary que tiene numerosos usos en combinación con diferentes métodos.

## ¿Qué es Python `Counter`?

`Counter` de Python es una herramienta útil que puede contar varios elementos en una lista y muestra **con qué frecuencia se producen estos elementos**. Es una subclase de [Dictionary](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/python-dictionary/). Aunque esta tarea se puede realizar fácil y manualmente para una secuencia corta de valores, es mucho más complicado para conjuntos de datos largos. El propio `Counter` es una variable entera que tiene el valor inicial “0”. Un único contador indica la frecuencia de un objeto. Si quieres tener en cuenta varios objetos diferentes, utiliza un contador distinto para cada uno de ellos.

La clase `Counter` puede aplicarse a listas, [tuplas de Python](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/python-tuples/), Dictionaries y [cadenas de Python](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/python-string/). Su sintaxis es la siguiente:

```python
Counter(list)
```

En los siguientes apartados te mostraremos cómo puede utilizarse `Counter` en la práctica con algunos ejemplos sencillos.

## `Counter` con una lista

En el primer ejemplo, creamos una lista simple con diferentes valores. El aspecto es el siguiente:

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

La lista tiene tres elementos diferentes: `a`, `b` y `c`. Para averiguar la frecuencia con la que aparece cada uno de estos elementos, utilizamos `Counter`. El resultado sería el siguiente:

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

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

El resultado sería el siguiente:

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

## Así funciona la clase `Counter` con una tupla

En el segundo ejemplo procedemos 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 agrupació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:

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

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

## Utilización en la clase `Dictionary`

En un Dictionary, los elementos se almacenan como **pares clave-valor** y se colocan entre llaves. Si utilizas el contador para el Dictionary, éste se convierte en un objeto hashtable. Los elementos se convierten en claves y sus valores en el número del diccionario original. Para nuestro ejemplo anterior, se vería así:

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

El resultado sería el siguiente:

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

Consejo Alcanza tu objetivo en solo tres pasos: con [Deploy Now](https://www.ionos.es/alojamiento/deploy-now "Deploy Now de IONOS") de IONOS, solo tienes que conectar tu repositorio, realizar la compilación automáticamente y acceder a una infraestructura fiable. Benefíciate de las mejores tarifas y el asesoramiento de expertos.

## `Counter` de Python en combinació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 caracteres** marcados por comillas. También se tienen en cuenta los espacios. Elegimos la siguiente cadena para nuestro ejemplo:

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

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

## Extensiones 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:

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

Nuestro resultado es el siguiente:

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

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

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

Esto nos da un resultado actualizado:

```python
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 variaciones y las correspondientes salidas. Aquí, las “letters” actúan como claves (keys) y los “counts” como valores (values).

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

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

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

Este es un ejemplo con `.values()`:

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

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

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

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

El resultado será el siguiente:

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

## Determinar la mayor acumulación con `most_common(n)`

Con `most_common(n)` para `Counter` puedes averiguar qué elementos son más y menos comunes. Consideremos un ejemplo en el que un producto aparece en diferentes colores. Junto a los colores se indica la frecuencia con la que el producto sigue en stock en la variante correspondiente. Un valor negativo significa que ya no existe el artículo correspondiente en el almacén, pero que, sin embargo, esta variante ha sido objeto de un pedido anticipado. Si ahora queremos comprobar qué variante tiene todavía más artículos en stock, podemos utilizar este código:

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

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

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

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

```python
[('gris' : -1)]
```

## Cálculos aritméticos con `Counter`

Con `Counter` también puedes llevar a cabo **cálculos aritméticos**. Sin embargo, es importante tener en cuenta que solo se obtienen valores positivos. En el siguiente código probamos algunos tipos de cálculo:

Una suma simple:

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

Así sería la resta:

```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 el valor de “c” ahora sería negativo, no se incluye en el resultado.

## Ordenar tipos de datos por frecuencia

Otra opción que ofrece la clase es una **enumeración de tipos de datos** en una carpeta. Como ejemplo, imaginemos una carpeta llamada “Imágenes” que contiene numerosos archivos diferentes con distintos tipos de datos. Utilizamos el siguiente código para una lista:

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

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

El resultado sería el siguiente:

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

Consejo En nuestra Digital Guide encontrarás otros muchos artículos sobre este popular lenguaje de programación. Te explicamos, por ejemplo, qué [operadores Python](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/python-operators/) existen, te guiamos a través de la [instalación de Python](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/instalar-python/) y te mostramos los [conceptos básicos para utilizar Python](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/tutorial-de-python/).


This is a markdown version of: [https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/python-counter/](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/python-counter/) for AI/LLM consumption.