Het aantal voorkomens van elk element in een lijst tellen met Python’s Counter

Bedrijf

In Python kan het aantal van alle elementen in een lijst of tupel worden verkregen met de ingebouwde functie len(), en het aantal van elk element (het aantal keren dat elk element voorkomt) kan worden verkregen met de methode count().

Bovendien kan de klasse Teller van de standaardverzamelingen van de Python-bibliotheek worden gebruikt om de elementen op te vragen in volgorde van het aantal keren dat ze voorkomen.

In dit deel bespreken we het volgende

  • Tel het totaal aantal elementen:len()
  • Tel het aantal van elk element (het aantal keren dat elk element voorkomt):count()
  • Gebruik.collections.Counter
  • Elementen worden opgezocht in volgorde van frequentie van voorkomen:most_common()
  • Tel het aantal (type) niet-overlappende elementen (unieke elementen).
  • Tel het aantal elementen dat aan de voorwaarde voldoet.

Daarnaast wordt als concreet voorbeeld het volgende uitgelegd met voorbeeldcode.

  • Telt het aantal keren dat een woord voorkomt in een tekenreeks.
  • Telt het aantal keren dat een teken in een tekenreeks voorkomt.

Het voorbeeld is een lijst, maar dezelfde bewerking kan worden gedaan met tupels.

Tel het totaal aantal elementen: len()

Om het totaal aantal elementen in een lijst of tupel te tellen, gebruik je de ingebouwde functie len().

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

print(len(l))
# 7

Het aantal van elk element tellen (het aantal keren dat elk element voorkomt): count() methode

Om het aantal van elk element te tellen (het aantal keren dat elk element voorkomt), gebruik je de count() methode voor lijsten, tupels, enz.

Indien een waarde die niet bestaat als element wordt doorgegeven als argument, wordt 0 teruggegeven.

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

Als je het aantal voorkomens van elk element in één keer wilt krijgen, is de volgende collection.counter handig.

Hoe collections.counter te gebruiken

De Python standaard bibliotheek collecties heeft een Teller klasse.

Teller() is een subklasse van het woordenboektype dict, dat gegevens heeft in de vorm van elementen als sleutels en occurrences als waarden.

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

Als een element als sleutel wordt opgegeven, kan het aantal elementen worden verkregen. Indien een waarde wordt opgegeven die niet bestaat als element, wordt 0 teruggezonden.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Je kunt ook methodes van het woordenboektype gebruiken, zoals keys(), values(), items(), enz.

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

Deze methodes geven objecten terug van het type dict_keys, enz. Ze kunnen als zodanig gebruikt worden als je een for statement wilt uitvoeren. Als u het wilt omzetten in een lijst, gebruik dan list().

Elementen verkrijgen in volgorde van verschijningsfrequentie: methode most_common()

Teller heeft de methode most_common(), die een lijst van tupels van de vorm (element, aantal voorkomens) teruggeeft, gesorteerd op het aantal voorkomens.

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

Het element met het hoogste aantal occurrences kan worden verkregen door een index op te geven, zoals [0] voor het hoogste aantal occurrences en [-1] voor het laagste aantal occurrences. Als u alleen de elementen of alleen het aantal occurrences wilt krijgen, kunt u de index verder specificeren.

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

Als u ze wilt sorteren in volgorde van afnemend aantal keren dat ze voorkomen, gebruikt u de slice met de toename ingesteld op -1.

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

Indien het argument n is gespecificeerd voor de most_common() methode, worden enkel de n elementen met het hoogste aantal voorvallen teruggegeven. Indien het wordt weggelaten, worden alle elementen.

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

Als u een afzonderlijke lijst van elementen wilt, gerangschikt volgens het aantal voorkomens, in plaats van een tupel van (element, aantal voorkomens), kunt u deze als volgt samenstellen

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

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

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

De ingebouwde functie zip() wordt gebruikt om een tweedimensionale lijst (in dit geval een lijst van tupels) te transponeren, en vervolgens uit te pakken en te extraheren.

Tel het aantal (type) niet-overlappende elementen (unieke elementen).

Om te tellen hoeveel niet-overlappende elementen (unieke elementen) er in een lijst of tupel zitten (hoeveel types er zijn), gebruik je Counter of set() zoals hierboven beschreven.

Het aantal elementen in het Teller-object is gelijk aan het aantal niet-overlappende elementen in de oorspronkelijke lijst, dat verkregen kan worden met len().

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

print(len(c))
# 3

Je kunt ook set() gebruiken, de constructor voor het type set, wat makkelijker is als je geen Teller object nodig hebt.

Het type set is een gegevenstype dat geen dubbele elementen heeft. Het doorgeven van een lijst aan set() negeert dubbele waarden en geeft een object van het type set terug met alleen unieke waarden als elementen. Het aantal elementen van dit type wordt verkregen met len().

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

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

Tel het aantal elementen dat aan de voorwaarde voldoet.

Om het aantal elementen in een lijst of tupel te tellen dat aan een bepaalde voorwaarde voldoet, gebruik je list comprehension notatie of generator expressies.

Tel bij wijze van voorbeeld het aantal elementen met negatieve waarden voor de volgende lijst getallen

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

Toepassing van een voorwaardelijke uitdrukking op elk element in de lijstbegripnotatie levert een lijst op waarvan de elementen Boolean bools (waar, onwaar) zijn. Het Booleaanse type bool is een subklasse van het gehele type int, waarbij true wordt behandeld als 1 en false als 0. Daarom kan het aantal true waarden (het aantal elementen dat aan de voorwaarde voldoet) worden geteld door de som te berekenen met 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

Als we [] in de list comprehension notatie vervangen door (), krijgen we een generator expressie. De list comprehension notatie genereert een lijst van alle verwerkte elementen, terwijl de generator expressie de elementen sequentieel verwerkt en daardoor geheugenefficiënter is.

Wanneer de generatoruitdrukking het enige argument is, kan () weggelaten worden, zodat het geschreven kan worden zoals in het laatste geval.

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

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

Als u het aantal foute waarden wilt tellen (het aantal elementen dat niet aan de voorwaarde voldoet), gebruik dan not. Merk op dat > een hogere prioriteit heeft dan not (het wordt eerst berekend), dus de haakjes () in (i < 0) in het volgende voorbeeld zijn niet nodig.

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

Natuurlijk kunnen de voorwaarden zelf worden veranderd.

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

Enkele andere voorbeelden zijn hieronder weergegeven.

Voorbeeld van het verkrijgen van het aantal oneven elementen voor een lijst van getallen.

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

Voorbeeld van een voorwaarde voor een lijst van tekenreeksen.

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

Teller wordt gebruikt om te tellen op basis van het aantal voorkomens. items() haalt een tupel op van (element, aantal voorkomens), en het aantal voorkomens specificeert de voorwaarde.

Het volgende is een voorbeeld van het extraheren van elementen met twee of meer voorkomens en het tellen van het totale aantal voorkomens. In dit voorbeeld zijn er vier a's en twee c's, voor een totaal van zes.

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

Het volgende is een voorbeeld van het extraheren van de types van elementen met twee of meer voorkomens en het tellen van het aantal voorkomens. In dit voorbeeld zijn er twee types, a en 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

Telt het aantal keren dat een woord voorkomt in een tekenreeks.

Laten we, als concreet voorbeeld, het aantal keren tellen dat een woord voorkomt in een tekenreeks.

Vervang eerst onnodige komma's en punten door een lege tekenreeks met de methode replace(), en verwijder ze dan. Gebruik vervolgens de methode split() om een lijst te maken, gescheiden door spaties.

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

Als je een lijst kunt maken, kun je het aantal keren krijgen dat elk woord voorkomt, de soorten woorden die voorkomen, en de most_common() van collections.Counter om het woord te krijgen dat het vaakst voorkomt.

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

Het bovenstaande is een zeer eenvoudig proces, dus het is beter om bibliotheken zoals NLTK te gebruiken voor meer complexe natuurlijke taalverwerking.

In het geval van Japanse tekst kan split() ook niet worden gebruikt om de tekst te splitsen, omdat er geen duidelijke woordscheiding is. U kunt bijvoorbeeld de Janome bibliotheek gebruiken om dit te bereiken.

Telt het aantal keren dat een teken in een tekenreeks voorkomt.

Aangezien strings ook een sequentietype zijn, kunnen ze gebruikt worden met de methode count() of doorgegeven worden als argument aan de constructor van 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})

Voorbeeld van het ophalen van de top 5 meest voorkomende karakters.

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