Comptant el nombre d’ocurrències de cada element d’una llista amb el comptador de Python

Negocis

A Python, el nombre de tots els elements d’una llista o tupla es pot obtenir mitjançant la funció integrada len(), i el nombre de cada element (el nombre d’ocurrències de cada element) es pot obtenir mitjançant el mètode count() .

A més, la classe Counter de les col·leccions de biblioteques estàndard de Python es pot utilitzar per obtenir els elements per ordre del nombre d’ocurrències.

En aquesta secció, parlarem del següent

  • Compta el nombre total d’elements:len()
  • Compteu el nombre de cada element (el nombre d’ocurrències de cada element):count()
  • Ús.collections.Counter
  • Els elements es recuperen per ordre de freqüència d’ocurrència:most_common()
  • Compteu el nombre (tipus) d’elements no superposats (elements únics).
  • Comptar el nombre d’elements que compleixen la condició.

A més, com a exemple concret, s’explica el següent amb codi d’exemple.

  • Compta el nombre d’ocurrències d’una paraula en una cadena.
  • Comptar el nombre d’ocurrències d’un caràcter en una cadena.

La mostra és una llista, però el mateix processament es pot fer amb tuples.

Compteu el nombre total d’elements: len()

Per comptar el nombre total d’elements d’una llista o tupla, utilitzeu la funció integrada len().

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

print(len(l))
# 7

Comptant el nombre de cada element (el nombre d’ocurrències de cada element): mètode count().

Per comptar el nombre de cada element (el nombre d’ocurrències de cada element), utilitzeu el mètode count() per a llistes, tuples, etc.

Si es passa un valor que no existeix com a element com a argument, es retorna 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 voleu obtenir el nombre d’ocurrències de cada element alhora, la següent col·lecció.Comptador és útil.

Com utilitzar les col·leccions.Comptador

Les col·leccions de biblioteques estàndard de Python tenen una classe Counter.

Counter() és una subclasse del tipus diccionari dict, que té dades en forma d’elements com a claus i ocurrències com a valors.

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 s’especifica un element com a clau, es pot obtenir el nombre d’elements. Si s’especifica un valor que no existeix com a element, es retorna 0.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

També podeu utilitzar mètodes de tipus diccionari com 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)])

Aquests mètodes retornen objectes del tipus dict_keys, etc. Es poden utilitzar tal qual si voleu executar una instrucció for. Si voleu convertir-lo en una llista, feu servir list().

Obtenció d’elements per ordre de freqüència d’aparició: mètode most_common().

Counter té el mètode most_common(), que retorna una llista de tuples de la forma (element, nombre d’ocurrències) ordenades pel nombre d’ocurrències.

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

L’element amb el nombre més alt d’ocurrències es pot obtenir especificant un índex, com ara [0] per al nombre més alt d’ocurrències i [-1] per al nombre més baix d’ocurrències. Si voleu obtenir només els elements o només el nombre d’ocurrències, podeu especificar més l’índex.

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 voleu ordenar-los per ordre decreixent del nombre d’ocurrències, utilitzeu la secció amb l’increment establert a -1.

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

Si s’especifica l’argument n per al mètode most_common(), només es retornen els n elements amb el nombre més alt d’ocurrències. Si s’omet, tots els elements.

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

Si voleu una llista separada d’elements/ocurrències ordenades pel nombre d’ocurrències, en lloc d’una tupla de (element, recompte d’ocurrències), podeu descompondre-la de la següent manera

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

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

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

La funció integrada zip() s’utilitza per transposar una llista bidimensional (en aquest cas, una llista de tuples), i després descomprimir-la i extreure-la.

Compteu el nombre (tipus) d’elements no superposats (elements únics).

Per comptar quants elements no superposats (elements únics) hi ha en una llista o tupla (quants tipus hi ha), utilitzeu Counter o set() tal com es descriu anteriorment.

El nombre d’elements de l’objecte Counter és igual al nombre d’elements no superposats de la llista original, que es pot obtenir amb len().

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

print(len(c))
# 3

També podeu utilitzar set(), el constructor del set de tipus set, que és més fàcil si no necessiteu un objecte Counter.

El tipus de conjunt és un tipus de dades que no té elements duplicats. Passar una llista a set() ignora els valors duplicats i retorna un objecte de tipus conjunt amb només valors únics com a elements. El nombre d’elements d’aquest tipus s’obté per len().

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

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

Comptar el nombre d’elements que compleixen la condició.

Per comptar el nombre d’elements d’una llista o tupla que compleixen una determinada condició, utilitzeu la notació de comprensió de llista o expressions generadores.

Com a exemple, compta el nombre d’elements amb valors negatius per a la següent llista de nombres

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

L’aplicació d’una expressió condicional a cada element de la notació de comprensió de llista produeix una llista els elements de la qual són bools booleans (true, false). El tipus booleà bool és una subclasse del tipus enter int, on true es tracta com a 1 i fals com a 0. Per tant, el nombre de valors vertaders (el nombre d’elements que compleixen la condició) es pot comptar calculant la suma mitjançant 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 substituïm [] a la notació de comprensió de la llista per (), obtenim una expressió generadora. La notació de comprensió de llista genera una llista de tots els elements processats, mentre que l’expressió generadora processa els elements de manera seqüencial i, per tant, és més eficient en la memòria.

Quan l’expressió del generador és l’únic argument, es pot ometre (), de manera que es pot escriure com en el darrer cas.

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

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

Si voleu comptar el nombre de valors falsos (el nombre d’elements que no compleixen la condició), utilitzeu not. Tingueu en compte que > té una prioritat més alta que no (és calculada primer), de manera que els parèntesis () a (i < 0) a l’exemple següent no són necessaris.

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

Per descomptat, les condicions en si es poden canviar.

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

A continuació es mostren alguns altres exemples.

Exemple d’obtenir el nombre d’elements senars per a una llista de nombres.

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

Exemple de condició per a una llista de cadenes.

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 comptador s’utilitza per comptar en funció del nombre d’ocurrències. items() recupera una tupla de (element, nombre d’ocurrències) i el nombre d’ocurrències especifica la condició.

El següent és un exemple d’extracció d’elements amb dues o més ocurrències i comptant el nombre total d’ocurrències. En aquest exemple, hi ha quatre a i dues c, per a un total de sis.

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

El següent és un exemple d’extracció dels tipus d’elements amb dues o més aparicions i de comptar el nombre d’ocurrències. En aquest exemple, hi ha dos tipus, a i 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

Compta el nombre d’ocurrències d’una paraula en una cadena.

Com a exemple concret, comptem el nombre d’ocurrències d’una paraula en una cadena.

Primer, substituïu comes i punts innecessaris per una cadena buida utilitzant el mètode replace() i després suprimiu-los. A continuació, utilitzeu el mètode split() per crear una llista separada per espais.

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 podeu fer una llista, podeu obtenir el nombre de vegades que apareix cada paraula, els tipus de paraules que apareixen i el most_common() de col·leccions. Counter per obtenir la paraula que apareix més vegades.

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

L’anterior és un procés molt senzill, per la qual cosa és millor utilitzar biblioteques com NLTK per a un processament de llenguatge natural més complex.

A més, en el cas del text japonès, split() no es pot utilitzar per dividir el text perquè no hi ha una separació clara de paraules. Per exemple, podeu utilitzar la biblioteca Janome per aconseguir-ho.

Comptar el nombre d’ocurrències d’un caràcter en una cadena.

Com que les cadenes també són un tipus de seqüència, es poden utilitzar amb el mètode count() o passar com a argument al constructor de col·leccions.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})

Exemple de recuperació dels 5 principals caràcters que apareixen amb més freqüència.

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