Numărarea numărului de apariții ale fiecărui element dintr-o listă cu Python’s Counter

Afaceri

În Python, numărul tuturor elementelor dintr-o listă sau dintr-un tuple poate fi obținut cu ajutorul funcției încorporate len(), iar numărul fiecărui element (numărul de apariții ale fiecărui element) poate fi obținut cu ajutorul metodei count().

În plus, clasa Counter din colecțiile bibliotecii standard Python poate fi utilizată pentru a obține elementele în ordinea numărului de apariții.

În această secțiune, vom discuta următoarele

  • Numără numărul total de elemente:len()
  • Numărați numărul fiecărui element (numărul de apariții ale fiecărui element):count()
  • Utilizare.collections.Counter
  • Elementele sunt recuperate în ordinea frecvenței de apariție:most_common()
  • Numărați numărul (tipul) de elemente care nu se suprapun (elemente unice).
  • Numără numărul de elemente care îndeplinesc condiția.

În plus, ca exemplu concret, sunt explicate următoarele, însoțite de un cod de probă.

  • Numără numărul de apariții ale unui cuvânt într-un șir de caractere.
  • Numără numărul de apariții ale unui caracter într-un șir de caractere.

Exemplul este o listă, dar aceeași prelucrare se poate face și cu tupluri.

Numărați numărul total de elemente: len()

Pentru a număra numărul total de elemente dintr-o listă sau dintr-un tupluplu, utilizați funcția încorporată len().

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

print(len(l))
# 7

Numărarea numărului fiecărui element (numărul de apariții ale fiecărui element): metoda count()

Pentru a număra numărul fiecărui element (numărul de apariții ale fiecărui element), utilizați metoda count() pentru liste, tuple etc.

În cazul în care ca argument este transmisă o valoare care nu există ca element, se returnează 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

Dacă doriți să obțineți numărul de apariții ale fiecărui element în parte, este utilă următoarea colecție.Counter.

Cum se utilizează collections.Counter

Colecțiile din biblioteca standard Python au o clasă Counter.

Counter() este o subclasă a tipului dicționar dict, care are date sub formă de elemente ca chei și ocurențe ca valori.

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

În cazul în care se specifică un element ca cheie, se poate obține numărul de elemente. În cazul în care se specifică o valoare care nu există ca element, se returnează 0.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

De asemenea, puteți utiliza metode de tip dicționar, cum ar fi 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)])

Aceste metode returnează obiecte de tip dict_keys, etc. Ele pot fi utilizate ca atare dacă doriți să executați o instrucțiune for. Dacă doriți să le convertiți într-o listă, utilizați list().

Obținerea elementelor în ordinea frecvenței de apariție: metoda most_common()

Counter are metoda most_common(), care returnează o listă de tupluri de forma (element, număr de apariții) ordonate în funcție de numărul de apariții.

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

Elementul cu cel mai mare număr de prezențe poate fi obținut prin specificarea unui indice, cum ar fi [0] pentru cel mai mare număr de prezențe și [-1] pentru cel mai mic număr de prezențe. Dacă doriți să obțineți numai elementele sau numai numărul de apariții, puteți specifica indicele în continuare.

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

Dacă doriți să le sortați în ordinea descrescătoare a numărului de apariții, utilizați slice cu incrementul setat la -1.

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

În cazul în care se specifică argumentul n pentru metoda most_common(), sunt returnate numai cele n elemente cu cel mai mare număr de apariții. În cazul în care este omis, toate elementele sunt returnate.

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

Dacă doriți o listă separată de elemente\ocurențe ordonate în funcție de numărul de apariții, mai degrabă decât o tuple de (element, număr de apariții), o puteți descompune după cum urmează

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

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

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

Funcția încorporată zip() este utilizată pentru a transpune o listă bidimensională (în acest caz, o listă de tupluri) și apoi pentru a o despacheta și extrage.

Numărați numărul (tipul) de elemente care nu se suprapun (elemente unice).

Pentru a număra câte elemente care nu se suprapun (elemente unice) există într-o listă sau într-un tupluplu (câte tipuri există), utilizați Counter sau set(), așa cum s-a descris mai sus.

Numărul de elemente din obiectul Counter este egal cu numărul de elemente care nu se suprapun din lista originală, care poate fi obținut cu len().

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

print(len(c))
# 3

De asemenea, puteți utiliza set(), constructorul pentru tipul de set set, care este mai ușor dacă nu aveți nevoie de un obiect Counter.

Tipul set este un tip de date care nu are elemente duplicate. Transmiterea unei liste către set() ignoră valorile duplicate și returnează un obiect de tip set având ca elemente numai valori unice. Numărul de elemente de acest tip se obține prin len().

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

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

Numără numărul de elemente care îndeplinesc condiția.

Pentru a număra numărul de elemente dintr-o listă sau dintr-un tupluplu care îndeplinesc o anumită condiție, utilizați notația de înțelegere a listei sau expresiile generatoare.

Ca exemplu, numărați numărul de elemente cu valori negative pentru următoarea listă de numere

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

Aplicând o expresie condițională la fiecare element în notația de înțelegere a listelor, se obține o listă ale cărei elemente sunt booleene (true, false). Tipul boolean bool este o subclasă a tipului întreg int, unde true este tratat ca 1 și false ca 0. Prin urmare, numărul de valori adevărate (numărul de elemente care îndeplinesc condiția) poate fi numărat prin calcularea sumei cu ajutorul 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

Dacă înlocuim [] în notația de înțelegere a listei cu (), obținem o expresie generatoare. Notația de înțelegere a listei generează o listă cu toate elementele procesate, în timp ce expresia generatoare procesează elementele secvențial și, prin urmare, este mai eficientă din punct de vedere al memoriei.

În cazul în care expresia generatorului este singurul argument, () poate fi omis, astfel încât se poate scrie ca în ultimul caz.

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

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

Dacă doriți să numărați numărul de valori false (numărul de elemente care nu îndeplinesc condiția), utilizați not. Rețineți că > are o precedență mai mare decât not (se calculează primul), astfel încât parantezele () din (i < 0) din exemplul următor nu sunt necesare.

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

Bineînțeles, condițiile în sine pot fi schimbate.

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

Alte câteva exemple sunt prezentate mai jos.

Exemplu de obținere a numărului de elemente impare pentru o listă de numere.

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

Exemplu de condiție pentru o listă de șiruri de caractere.

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

Counter este utilizat pentru a număra pe baza numărului de apariții. items() recuperează o tupla de (element, număr de apariții), iar numărul de apariții specifică condiția.

Următorul este un exemplu de extragere a elementelor cu două sau mai multe ocurențe și de numărare a numărului total de ocurențe. În acest exemplu, există patru a și două c, pentru un total de șase.

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

Următorul este un exemplu de extragere a tipurilor de elemente cu două sau mai multe ocurențe și de numărare a numărului de ocurențe. În acest exemplu, există două tipuri, 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

Numără numărul de apariții ale unui cuvânt într-un șir de caractere.

Ca un exemplu concret, să numărăm numărul de apariții ale unui cuvânt într-un șir de caractere.

În primul rând, înlocuiți virgulele și punctele inutile cu un șir gol folosind metoda replace(), apoi ștergeți-le. Apoi, utilizați metoda split() pentru a crea o listă separată prin spații.

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

Dacă puteți face o listă, puteți obține numărul de ori de câte ori apare fiecare cuvânt, tipurile de cuvinte care apar și most_common() din collections.Counter pentru a obține cuvântul care apare de cele mai multe ori.

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

Procesul de mai sus este foarte simplu, așa că este mai bine să folosiți biblioteci precum NLTK pentru procesarea mai complexă a limbajului natural.

De asemenea, în cazul textului japonez, split() nu poate fi utilizat pentru a diviza textul deoarece nu există o separare clară a cuvintelor. De exemplu, puteți utiliza biblioteca Janome pentru a realiza acest lucru.

Numără numărul de apariții ale unui caracter într-un șir de caractere.

Deoarece șirurile de caractere sunt, de asemenea, un tip de secvență, acestea pot fi utilizate cu metoda count() sau pot fi trecute ca argument la constructorul 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})

Exemplu de regăsire a primelor 5 caractere care apar cel mai frecvent.

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