Liczenie liczby wystąpień każdego elementu na liście za pomocą Pythona Counter

Biznes

W Pythonie liczba wszystkich elementów listy lub krotki może być uzyskana za pomocą wbudowanej funkcji len(), a liczba każdego elementu (liczba wystąpień każdego elementu) może być uzyskana za pomocą metody count().

Dodatkowo, klasa Counter z kolekcji biblioteki standardowej Pythona może być użyta do uzyskania elementów w kolejności liczby wystąpień.

W tym rozdziale omówimy następujące zagadnienia

  • Policz całkowitą liczbę elementów:len()
  • Policz liczbę każdego elementu (liczbę wystąpień każdego elementu):count()
  • Zastosowanie.collections.Counter
  • Elementy są pobierane w kolejności według częstotliwości występowania:most_common()
  • Policzyć liczbę (typ) elementów nienakładających się na siebie (elementów unikalnych).
  • Zlicza liczbę elementów, które spełniają warunek.

Dodatkowo, jako konkretny przykład, wyjaśnione jest następujące zagadnienie z przykładowym kodem.

  • Zlicza liczbę wystąpień słowa w łańcuchu znaków.
  • Policz ilość wystąpień znaku w łańcuchu.

Próbka jest listą, ale to samo przetwarzanie może być wykonane z tuples.

Policz całkowitą liczbę elementów: len()

Aby policzyć całkowitą liczbę elementów w liście lub tuple, użyj wbudowanej funkcji len().

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

print(len(l))
# 7

Zliczanie ilości każdego elementu (ilość wystąpień każdego elementu): metoda count()

Aby policzyć ilość każdego elementu (ilość wystąpień każdego elementu), użyj metody count() dla list, tupli, itp.

Jeśli jako argument zostanie przekazana wartość, która nie istnieje jako element, zwracane jest 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

Jeśli chcesz uzyskać liczbę wystąpień każdego elementu naraz, przydatna jest następująca kolekcja.Counter.

Jak korzystać z kolekcji.Counter

W kolekcjach biblioteki standardowej Pythona znajduje się klasa Counter.

Counter() jest podklasą typu słownikowego dict, który posiada dane w postaci elementów jako kluczy i wystąpień jako wartości.

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

Jeżeli jako klucz podany jest element, to można uzyskać liczbę elementów. Jeżeli podano wartość, która nie istnieje jako element, zwracane jest 0.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Możesz również użyć metod typu słownikowego, takich jak keys(), values(), items(), itp.

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

Metody te zwracają obiekty typu dict_keys, itd. Mogą one być użyte jako takie, jeśli chcesz uruchomić instrukcję for. Jeśli chcesz przekonwertować je na listę, użyj list().

Uzyskiwanie elementów w kolejności częstości występowania: metoda most_common()

Counter posiada metodę most_common(), która zwraca listę tupli postaci (element, liczba wystąpień) posortowanych według liczby wystąpień.

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

Element o największej liczbie wystąpień można uzyskać przez podanie indeksu, takiego jak [0] dla największej liczby wystąpień i [-1] dla najmniejszej liczby wystąpień. Jeśli chcesz uzyskać tylko elementy lub tylko liczbę wystąpień, możesz dokładniej określić indeks.

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

Jeśli chcesz posortować je w kolejności malejącej liczby wystąpień, użyj wycinka z inkrementacją ustawioną na -1.

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

Jeśli dla metody most_common() podany jest argument n, to zwracane jest tylko n elementów o największej liczbie wystąpień. Jeśli zostanie on pominięty, zwracane są wszystkie elementy.

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

Jeśli chcesz otrzymać osobną listę elementówWystąpień uporządkowaną według liczby wystąpień, a nie tuple (element, liczba wystąpień), możesz rozłożyć ją w następujący sposób

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

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

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

Wbudowana funkcja zip() jest używana do transpozycji dwuwymiarowej listy (w tym przypadku listy krotek), a następnie rozpakowania i wyodrębnienia jej.

Policzyć liczbę (typ) elementów nienakładających się na siebie (elementów unikalnych).

Aby policzyć ile nienakładających się elementów (unikalnych elementów) znajduje się na liście lub tuple (ile jest typów), użyj Counter lub set() jak opisano powyżej.

Liczba elementów w obiekcie licznika jest równa liczbie nienakładających się elementów na oryginalnej liście, którą można uzyskać za pomocą len().

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

print(len(c))
# 3

Możesz również użyć set(), konstruktora dla typu set, co jest łatwiejsze, jeśli nie potrzebujesz obiektu Counter.

Typ set jest typem danych, który nie posiada zduplikowanych elementów. Przekazanie listy do set() ignoruje zduplikowane wartości i zwraca obiekt typu set z tylko unikalnymi wartościami jako elementami. Liczba elementów tego typu jest uzyskiwana przez len().

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

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

Zlicza liczbę elementów, które spełniają warunek.

Aby policzyć liczbę elementów w liście lub tuple, które spełniają pewien warunek, użyj notacji list comprehension lub wyrażeń generatora.

Na przykład, policz liczbę elementów z wartościami ujemnymi dla następującej listy liczb

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

Zastosowanie wyrażenia warunkowego do każdego elementu w notacji list comprehension daje listę, której elementy są boolowskimi boolami (true, false). Typ boolean bool jest podklasą typu całkowitego int, gdzie true jest traktowane jako 1, a false jako 0. Dlatego liczba wartości true (liczba elementów spełniających warunek) może być policzona poprzez obliczenie sumy przy użyciu funkcji 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

Jeśli zastąpimy [] w notacji list comprehension przez (), otrzymamy wyrażenie generatora. Notacja list comprehension generuje listę wszystkich przetwarzanych elementów, podczas gdy wyrażenie generator przetwarza elementy sekwencyjnie i dlatego jest bardziej wydajne pod względem pamięci.

Gdy wyrażenie generatora jest jedynym argumentem, () może być pominięte, więc można to zapisać jak w drugim przypadku.

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

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

Jeśli chcesz policzyć liczbę fałszywych wartości (liczbę elementów, które nie spełniają warunku), użyj not. Zauważ, że > ma wyższy priorytet niż not (jest obliczane jako pierwsze), więc nawiasy () w (i < 0) w poniższym przykładzie nie są konieczne.

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

Oczywiście, same warunki można zmienić.

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

Poniżej przedstawiono kilka innych przykładów.

Przykład obliczania liczby elementów nieparzystych dla listy liczb.

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

Przykład warunku dla listy ciągów znaków.

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

Licznik jest używany do zliczania na podstawie liczby wystąpień. items() pobiera tuple (element, liczba wystąpień), a liczba wystąpień określa warunek.

Poniżej znajduje się przykład wyodrębniania elementów z dwoma lub więcej wystąpieniami i liczenia całkowitej liczby wystąpień. W tym przykładzie są cztery a i dwa c, czyli w sumie sześć.

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

Poniżej znajduje się przykład wyodrębniania typów elementów z dwoma lub więcej wystąpieniami i liczenia liczby wystąpień. W tym przykładzie są dwa typy, 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

Zlicza liczbę wystąpień słowa w łańcuchu znaków.

Jako konkretny przykład, policzmy liczbę wystąpień słowa w łańcuchu znaków.

Najpierw zastąp niepotrzebne przecinki i kropki pustym łańcuchem za pomocą metody replace(), a następnie usuń je. Następnie użyj metody split(), aby utworzyć listę oddzieloną spacjami.

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

Jeśli możesz zrobić listę, możesz uzyskać liczbę razy każde słowo pojawia się, rodzaje słów, które pojawiają się i most_common() kolekcji.Counter, aby uzyskać słowo, które pojawia się najwięcej razy.

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

Powyższy proces jest bardzo prosty, dlatego do bardziej złożonego przetwarzania języka naturalnego lepiej jest używać bibliotek takich jak NLTK.

Również, w przypadku tekstu japońskiego, split() nie może być użyty do podziału tekstu, ponieważ nie ma wyraźnej separacji słów. Na przykład, możesz użyć biblioteki Janome, aby to osiągnąć.

Policz ilość wystąpień znaku w łańcuchu.

Ponieważ ciągi są również typem sekwencyjnym, mogą być użyte z metodą count() lub przekazane jako argument do konstruktora 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})

Przykład wyszukania 5 najczęściej występujących znaków.

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