Contar el número de apariciones de cada elemento en una lista con el contador de Python

Negocio

En Python, el número de todos los elementos de una lista o tupla se puede obtener utilizando la función incorporada len(), y el número de cada elemento (el número de ocurrencias de cada elemento) se puede obtener utilizando el método count().

Además, se puede utilizar la clase Counter de las colecciones de la biblioteca estándar de Python para obtener los elementos en orden del número de ocurrencias.

En esta sección, discutiremos lo siguiente

  • Cuenta el número total de elementos:len()
  • Cuenta el número de cada elemento (el número de ocurrencias de cada elemento):count()
  • Uso.collections.Counter
  • Los elementos se recuperan por orden de frecuencia de aparición:most_common()
  • Cuenta el número (tipo) de elementos no superpuestos (elementos únicos).
  • Cuenta el número de elementos que satisfacen la condición.

Además, como ejemplo concreto, se explica lo siguiente con un código de ejemplo.

  • Cuenta el número de apariciones de una palabra en una cadena.
  • Cuenta el número de ocurrencias de un carácter en una cadena.

El ejemplo es una lista, pero el mismo procesamiento puede hacerse con tuplas.

Cuenta el número total de elementos: len()

Para contar el número total de elementos de una lista o tupla, utilice la función incorporada len().

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

print(len(l))
# 7

Contar el número de cada elemento (el número de ocurrencias de cada elemento): método count()

Para contar el número de cada elemento (el número de ocurrencias de cada elemento), utilice el método count() para listas, tuplas, etc.

Si se pasa como argumento un valor que no existe como elemento, se devuelve 0.

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

print(l.count('a'))
# 4

print(l.count('b'))
# 1

print(l.count('c'))
# 2

print(l.count('d'))
# 0

Si desea obtener el número de apariciones de cada elemento a la vez, el siguiente collection.Counter es útil.

Cómo utilizar collections.Counter

Las colecciones de la biblioteca estándar de Python tienen una clase Counter.

Counter() es una subclase del tipo de diccionario dict, que tiene datos en forma de elementos como claves y ocurrencias como valores.

import collections

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

c = collections.Counter(l)
print(c)
# Counter({'a': 4, 'c': 2, 'b': 1})

print(type(c))
# <class 'collections.Counter'>

print(issubclass(type(c), dict))
# True

Si se especifica un elemento como clave, se puede obtener el número de elementos. Si se especifica un valor que no existe como elemento, se devuelve 0.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

También puede utilizar métodos de tipo diccionario como keys(), values(), items(), etc.

print(c.keys())
# dict_keys(['a', 'b', 'c'])

print(c.values())
# dict_values([4, 1, 2])

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

Estos métodos devuelven objetos de tipo dict_keys, etc. Se pueden utilizar tal cual si se quiere ejecutar una sentencia for. Si quiere convertirlo en una lista, utilice list().

Obtención de elementos por orden de frecuencia de aparición: método most_common()

Counter tiene el método most_common(), que devuelve una lista de tuplas de la forma (elemento, número de ocurrencias) ordenadas por el número de ocurrencias.

print(c.most_common())
# [('a', 4), ('c', 2), ('b', 1)]

El elemento con el mayor número de ocurrencias puede obtenerse especificando un índice, como [0] para el mayor número de ocurrencias y [-1] para el menor número de ocurrencias. Si se desea obtener sólo los elementos o sólo el número de ocurrencias, se puede especificar más el índice.

print(c.most_common()[0])
# ('a', 4)

print(c.most_common()[-1])
# ('b', 1)

print(c.most_common()[0][0])
# a

print(c.most_common()[0][1])
# 4

Si desea ordenarlas en orden de número decreciente de ocurrencias, utilice la rebanada con el incremento fijado en -1.

print(c.most_common()[::-1])
# [('b', 1), ('c', 2), ('a', 4)]

Si se especifica el argumento n para el método most_common(), sólo se devuelven los n elementos con el mayor número de ocurrencias. Si se omite, todos los elementos.

print(c.most_common(2))
# [('a', 4), ('c', 2)]

Si desea una lista separada de elementos-ocurrencias ordenada por el número de ocurrencias, en lugar de una tupla de (elemento, número de ocurrencias), puede descomponerla como sigue

values, counts = zip(*c.most_common())

print(values)
# ('a', 'c', 'b')

print(counts)
# (4, 2, 1)

La función incorporada zip() se utiliza para transponer una lista bidimensional (en este caso, una lista de tuplas), y luego desempaquetarla y extraerla.

Cuenta el número (tipo) de elementos no superpuestos (elementos únicos).

Para contar cuántos elementos no superpuestos (elementos únicos) hay en una lista o tupla (cuántos tipos hay), utilice Counter o set() como se ha descrito anteriormente.

El número de elementos del objeto Counter es igual al número de elementos no solapados de la lista original, que se puede obtener con len().

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(len(c))
# 3

También puede utilizar set(), el constructor para el tipo de conjunto set, que es más fácil si no necesita un objeto Counter.

El tipo set es un tipo de datos que no tiene elementos duplicados. Al pasar una lista a set() se ignoran los valores duplicados y se devuelve un objeto de tipo set con sólo valores únicos como elementos. El número de elementos de este tipo se obtiene mediante len().

print(set(l))
# {'a', 'c', 'b'}

print(len(set(l)))
# 3

Cuenta el número de elementos que satisfacen la condición.

Para contar el número de elementos de una lista o tupla que satisfacen una determinada condición, utilice la notación de comprensión de listas o las expresiones generadoras.

Como ejemplo, cuente el número de elementos con valores negativos para la siguiente lista de números

l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

Si se aplica una expresión condicional a cada elemento en notación de comprensión de listas, se obtiene una lista cuyos elementos son booles (verdadero, falso). El tipo booleano bool es una subclase del tipo entero int, donde verdadero se trata como 1 y falso como 0. Por lo tanto, el número de valores verdaderos (el número de elementos que satisfacen la condición) puede contarse calculando la suma mediante sum().

print([i < 0 for i in l])
# [True, True, True, True, True, False, False, False, False, False, False]

print(sum([i < 0 for i in l]))
# 5

Si sustituimos [] en la notación de comprensión de la lista por (), obtendremos una expresión generadora. La notación de comprensión de lista genera una lista de todos los elementos procesados, mientras que la expresión generadora procesa los elementos secuencialmente y, por tanto, es más eficiente en cuanto a la memoria.

Cuando la expresión del generador es el único argumento, se puede omitir (), por lo que se puede escribir como en el último caso.

print(sum((i < 0 for i in l)))
# 5

print(sum(i < 0 for i in l))
# 5

Si quiere contar el número de valores falsos (el número de elementos que no satisfacen la condición), utilice not. Tenga en cuenta que > tiene mayor precedencia que not (se calcula primero), por lo que los paréntesis () en (i < 0) en el siguiente ejemplo no son necesarios.

print([not (i < 0) for i in l])
# [False, False, False, False, False, True, True, True, True, True, True]

print(sum(not (i < 0) for i in l))
# 6

Por supuesto, las propias condiciones pueden cambiarse.

print(sum(i >= 0 for i in l))
# 6

A continuación se muestran otros ejemplos.

Ejemplo de obtención del número de elementos impares de una lista de números.

print([i % 2 == 1 for i in l])
# [True, False, True, False, True, False, True, False, True, False, True]

print(sum(i % 2 == 1 for i in l))
# 6

Ejemplo de condición para una lista de cadenas.

l = ['apple', 'orange', 'banana']

print([s.endswith('e') for s in l])
# [True, True, False]

print(sum(s.endswith('e') for s in l))
# 2

El contador se utiliza para contar basándose en el número de ocurrencias. items() recupera una tupla de (elemento, número de ocurrencias), y el número de ocurrencias especifica la condición.

A continuación se muestra un ejemplo de extracción de elementos con dos o más apariciones y de recuento del número total de apariciones. En este ejemplo, hay cuatro a y dos c, para un total de seis.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

print([i for i in l if c[i] >= 2])
# ['a', 'a', 'a', 'a', 'c', 'c']

print([i[1] for i in c.items() if i[1] >= 2])
# [4, 2]

print(sum(i[1] for i in c.items() if i[1] >= 2))
# 6

A continuación se muestra un ejemplo de extracción de los tipos de elementos con dos o más ocurrencias y el recuento del número de ocurrencias. En este ejemplo, hay dos tipos, a y c.

print([i[0] for i in c.items() if i[1] >= 2])
# ['a', 'c']

print([i[1] >= 2 for i in c.items()])
# [True, False, True]

print(sum(i[1] >= 2 for i in c.items()))
# 2

Cuenta el número de apariciones de una palabra en una cadena.

Como ejemplo concreto, contemos el número de apariciones de una palabra en una cadena.

Primero, sustituye las comas y los puntos innecesarios por una cadena vacía utilizando el método replace(), y luego elimínalos. A continuación, utilice el método split() para crear una lista separada por espacios.

s = 'government of the people, by the people, for the people.'

s_remove = s.replace(',', '').replace('.', '')

print(s_remove)
# government of the people by the people for the people

word_list = s_remove.split()

print(word_list)
# ['government', 'of', 'the', 'people', 'by', 'the', 'people', 'for', 'the', 'people']

Si puedes hacer una lista, puedes obtener el número de veces que aparece cada palabra, los tipos de palabras que aparecen y la función most_common() de collections.Counter para obtener la palabra que aparece más veces.

print(word_list.count('people'))
# 3

print(len(set(word_list)))
# 6

c = collections.Counter(word_list)

print(c)
# Counter({'the': 3, 'people': 3, 'government': 1, 'of': 1, 'by': 1, 'for': 1})

print(c.most_common()[0][0])
# the

Lo anterior es un proceso muy simple, por lo que es mejor utilizar bibliotecas como NLTK para un procesamiento del lenguaje natural más complejo.

Además, en el caso del texto japonés, no se puede utilizar split() para dividir el texto porque no hay una separación clara de palabras. Por ejemplo, puede utilizar la biblioteca Janome para conseguirlo.

Cuenta el número de ocurrencias de un carácter en una cadena.

Dado que las cadenas también son un tipo de secuencia, pueden utilizarse con el método count() o pasarse como argumento al constructor de collections.Counter().

s = 'supercalifragilisticexpialidocious'

print(s.count('p'))
# 2

c = collections.Counter(s)

print(c)
# Counter({'i': 7, 's': 3, 'c': 3, 'a': 3, 'l': 3, 'u': 2, 'p': 2, 'e': 2, 'r': 2, 'o': 2, 'f': 1, 'g': 1, 't': 1, 'x': 1, 'd': 1})

Ejemplo de recuperación de los 5 caracteres más frecuentes.

print(c.most_common(5))
# [('i', 7), ('s', 3), ('c', 3), ('a', 3), ('l', 3)]

values, counts = zip(*c.most_common(5))

print(values)
# ('i', 's', 'c', 'a', 'l')
Copied title and URL