Contando o número de ocorrencias de cada elemento nunha lista co contador de Python

Negocios

En Python, o número de todos os elementos dunha lista ou tupla pódese obter mediante a función integrada len(), e o número de cada elemento (o número de aparicións de cada elemento) pódese obter mediante o método count() .

Ademais, a clase Counter das coleccións de bibliotecas estándar de Python pódese usar para obter os elementos por orde do número de ocorrencias.

Nesta sección, comentaremos o seguinte

  • Conta o número total de elementos:len()
  • Conta o número de cada elemento (o número de aparicións de cada elemento):count()
  • Uso.collections.Counter
  • Os elementos son recuperados por orde de frecuencia de aparición:most_common()
  • Conta o número (tipo) de elementos non superpostos (elementos únicos).
  • Conta o número de elementos que cumpren a condición.

Ademais, como exemplo concreto, explícase o seguinte con código de exemplo.

  • Conta o número de aparicións dunha palabra nunha cadea.
  • Conta o número de aparicións dun carácter nunha cadea.

A mostra é unha lista, pero o mesmo procesamento pódese facer con tuplas.

Conta o número total de elementos: len()

Para contar o número total de elementos nunha lista ou tupla, use a función integrada len().

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

print(len(l))
# 7

Contando o número de cada elemento (o número de ocorrencias de cada elemento): método count().

Para contar o número de cada elemento (o número de ocorrencias de cada elemento), use o método count() para listas, tuplas, etc.

Se se pasa un valor que non existe como elemento como argumento, devólvese 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

Se queres obter o número de ocorrencias de cada elemento á vez, a seguinte colección. Contador é útil.

Como usar as coleccións.Contador

As coleccións da biblioteca estándar de Python teñen unha clase Counter.

Counter() é unha subclase do tipo dicionario dict, que ten datos en forma de elementos como claves e ocorrencias 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

Se se especifica un elemento como clave, pódese obter o número de elementos. Se se especifica un valor que non existe como elemento, devólvese 0.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Tamén pode usar métodos de tipo dicionario 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)])

Estes métodos devolven obxectos do tipo dict_keys, etc. Pódense usar tal e como se quere executar unha instrución for. Se queres convertelo nunha lista, usa list().

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

Counter ten o método most_common(), que devolve unha lista de tuplas da forma (elemento, número de ocorrencias) ordenadas polo número de ocorrencias.

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

O elemento con maior número de ocorrencias pódese obter especificando un índice, como [0] para o maior número de ocorrencias e [-1] para o menor número de ocorrencias. Se queres obter só os elementos ou só o número de ocorrencias, podes especificar máis o í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

Se queres ordenalos por orde decrecente de ocorrencias, utiliza o segmento co incremento establecido en -1.

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

Se se especifica o argumento n para o método most_common(), só se devolven os n elementos con maior número de ocorrencias. Se se omite, todos os elementos.

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

Se desexa unha lista separada de elementos/ocurrencias ordenados polo número de ocorrencias, en lugar dunha tupla de (elemento, conta de ocorrencias), pode descompoñela do seguinte xeito

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

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

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

A función incorporada zip() utilízase para transpoñer unha lista bidimensional (neste caso, unha lista de tuplas), e despois descomprimila e extraela.

Conta o número (tipo) de elementos non superpostos (elementos únicos).

Para contar cantos elementos non superpostos (elementos únicos) hai nunha lista ou tupla (cantos tipos hai), use Counter ou set() como se describe anteriormente.

O número de elementos do obxecto Counter é igual ao número de elementos que non se solapan na lista orixinal, que se pode obter con len().

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

print(len(c))
# 3

Tamén podes usar set(), o construtor para o conxunto de tipos de conxunto, que é máis doado se non necesitas un obxecto Counter.

O tipo de conxunto é un tipo de datos que non ten elementos duplicados. Pasar unha lista a set() ignora os valores duplicados e devolve un obxecto de tipo conxunto con só valores únicos como elementos. O número de elementos deste tipo obtense mediante len().

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

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

Conta o número de elementos que cumpren a condición.

Para contar o número de elementos dunha lista ou tupla que cumpren unha determinada condición, use a notación de comprensión de lista ou expresións xeradoras.

Como exemplo, conta o número de elementos con valores negativos para a seguinte lista de números

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

Ao aplicar unha expresión condicional a cada elemento na notación de comprensión de listas, obtén unha lista cuxos elementos son booleanos booleanos (verdadeiro, falso). O tipo booleano bool é unha subclase do tipo enteiro int, onde verdadeiro trátase como 1 e falso como 0. Polo tanto, o número de valores verdadeiros (o número de elementos que satisfacen a condición) pódese contar calculando a suma usando 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

Se substituímos [] na notación de comprensión da lista por (), obtemos unha expresión xeradora. A notación de comprensión de lista xera unha lista de todos os elementos procesados, mentres que a expresión xeradora procesa os elementos secuencialmente e, polo tanto, é máis eficiente na memoria.

Cando a expresión xeradora é o único argumento, pódese omitir (), polo que se pode escribir como no último caso.

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

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

Se quere contar o número de valores falsos (o número de elementos que non cumpren a condición), use non. Teña en conta que > ten unha prioridade maior que non (calcúlase primeiro), polo que non son necesarios os parénteses () en (i < 0) no seguinte exemplo.

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 suposto, as propias condicións pódense cambiar.

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

A continuación móstranse algúns outros exemplos.

Exemplo de obtención do número de elementos impares para unha 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

Exemplo de condición para unha lista de cadeas.

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

O contador úsase para contar en función do número de ocorrencias. items() recupera unha tupla de (elemento, número de ocorrencias) e o número de ocorrencias especifica a condición.

O seguinte é un exemplo de extracción de elementos con dúas ou máis aparicións e conta do número total de ocorrencias. Neste exemplo, hai catro a e dúas 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

O seguinte é un exemplo de extracción dos tipos de elementos con dúas ou máis aparicións e conta do número de ocorrencias. Neste exemplo, hai dous tipos, a e 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

Conta o número de aparicións dunha palabra nunha cadea.

Como exemplo concreto, imos contar o número de aparicións dunha palabra nunha cadea.

Primeiro, substitúe as comas e os puntos innecesarios cunha cadea baleira usando o método substituír() e despois elimínaos. Despois, use o método split() para crear unha lista separada por espazos.

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']

Se podes facer unha lista, podes obter o número de veces que aparece cada palabra, os tipos de palabras que aparecen e o máis_común() de coleccións. Contador para obter a palabra que aparece máis 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

O anterior é un proceso moi sinxelo, polo que é mellor utilizar bibliotecas como NLTK para un procesamento da linguaxe natural máis complexo.

Ademais, no caso do texto xaponés, split() non se pode usar para dividir o texto porque non hai unha separación clara de palabras. Por exemplo, podes usar a biblioteca Janome para conseguilo.

Conta o número de aparicións dun carácter nunha cadea.

Dado que as cadeas tamén son un tipo de secuencia, pódense usar co método count() ou pasar como argumento ao construtor de coleccións.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})

Exemplo de recuperación dos 5 caracteres máis 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')