Az egyes elemek előfordulási számának számlálása egy listában a Python számlálójával

Üzleti

Pythonban egy lista vagy tuple összes elemének számát a beépített len() függvény segítségével, az egyes elemek számát (az egyes elemek előfordulásainak számát) pedig a count() metódussal kaphatjuk meg.

Ezen kívül a Python szabványos könyvtár gyűjteményeinek Counter osztálya használható arra, hogy az elemeket az előfordulások számának sorrendjében kapjuk meg.

Ebben a szakaszban a következőket tárgyaljuk

  • Számolja meg az elemek teljes számát:len()
  • Számolja meg az egyes elemek számát (az egyes elemek előfordulásának számát):count()
  • Használat.collections.Counter
  • Az elemek az előfordulás gyakoriságának sorrendjében kerülnek elő:most_common()
  • Számolja meg a nem átfedő elemek (egyedi elemek) számát (típusát).
  • Számolja meg a feltételnek megfelelő elemek számát.

Ezen kívül konkrét példaként a következőket ismertetjük egy mintakóddal.

  • Megszámolja egy szó előfordulásának számát egy karakterláncban.
  • Megszámolja egy karakter előfordulásának számát egy karakterláncban.

A minta egy lista, de ugyanez a feldolgozás elvégezhető tuplikkal is.

Az elemek teljes számának megszámlálása: len()

Egy lista vagy tuple elemeinek összeszámlálásához használja a len() beépített függvényt.

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

print(len(l))
# 7

Az egyes elemek számának számlálása (az egyes elemek előfordulásának száma): count() metódus

Az egyes elemek számának (az egyes elemek előfordulási számának) megszámlálásához használja a count() metódust listák, tuplik stb. esetén.

Ha olyan értéket adunk át argumentumként, amely nem létezik elemként, akkor 0-t kapunk vissza.

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

Ha az egyes elemek előfordulásainak számát szeretné egyszerre megkapni, a következő collection.Counter hasznos.

Hogyan használjuk a collections.Counter-t

A Python szabványos könyvtárának gyűjteményei tartalmaznak egy Counter osztályt.

A Counter() a dict szótár típus egy alosztálya, amelynek adatai az elemek mint kulcsok és az előfordulások mint értékek.

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

Ha egy elemet adunk meg kulcsként, akkor az elemek számát kaphatjuk meg. Ha elemként nem létező értéket adunk meg, akkor 0-t kapunk vissza.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Használhatsz szótár típusú módszereket is, mint például a keys(), values(), items(), stb.

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

Ezek a módszerek dict_keys típusú objektumokat adnak vissza, stb. Így is használhatók, ha egy for utasítást akarunk futtatni. Ha listává akarod alakítani, használd a list() funkciót.

Elemek kinyerése a megjelenés gyakorisága szerinti sorrendben: a most_common() módszer

A számláló rendelkezik a most_common() metódussal, amely az előfordulások száma szerint rendezett (elem, előfordulás száma) formájú tuplik listáját adja vissza.

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

A legnagyobb számú előfordulással rendelkező elemet egy index megadásával kaphatjuk meg, például [0] a legnagyobb számú előfordulás esetén és [-1] a legkisebb számú előfordulás esetén. Ha csak az elemeket vagy csak az előfordulások számát szeretné megkapni, akkor az indexet tovább adhatja meg.

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

Ha az előfordulások csökkenő száma szerinti sorrendbe akarja rendezni őket, használja a slice-t -1-es inkrementummal.

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

Ha a most_common() módszerhez n argumentumot adunk meg, akkor csak a legtöbbször előforduló n elemet kapjuk vissza. Ha elhagyjuk, akkor az összes elemet.

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

Ha nem egy (elem, előfordulásszám) tuple-t, hanem az előfordulás száma szerint rendezett elemek\előfordulások különálló listáját szeretné, akkor a következőképpen bonthatja fel azt

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

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

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

A beépített zip() függvényt egy kétdimenziós lista (ebben az esetben egy tuplikból álló lista) transzponálására, majd kicsomagolására és kivonására használjuk.

Számolja meg a nem átfedő elemek (egyedi elemek) számát (típusát).

Ahhoz, hogy megszámoljuk, hány nem átfedő elem (egyedi elem) van egy listában vagy tuple-ban (hány típus van), használjuk a Counter vagy a set() funkciót a fent leírtak szerint.

A Counter objektum elemeinek száma megegyezik az eredeti lista nem átfedő elemeinek számával, amelyet a len() segítségével kaphatunk meg.

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

print(len(c))
# 3

Használhatja a set(), a set típusú set konstruktorát is, ami egyszerűbb, ha nincs szüksége Counter objektumra.

A halmaz típus olyan adattípus, amelynek nincsenek duplikált elemei. Ha a set()-nek egy listát adunk át, akkor a duplikált értékeket figyelmen kívül hagyjuk, és egy set típusú objektumot adunk vissza, amelynek elemei csak egyedi értékek. Az ilyen típusú elemek számát a len() segítségével kapjuk meg.

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

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

Számolja meg a feltételnek megfelelő elemek számát.

Ha meg akarja számolni, hogy egy listában vagy halmazban hány elem felel meg egy bizonyos feltételnek, használja a listamegértési jelölést vagy a generátoros kifejezéseket.

Példaként számolja meg a negatív értékű elemek számát a következő számok listájánál

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

A feltételes kifejezés alkalmazása minden egyes elemre a listamegértés jelölésében egy olyan listát eredményez, amelynek elemei Boolean boolok (igaz, hamis). A bool Boolean típus az int egész szám típus egy alosztálya, ahol az igaz értéket 1-nek, a hamisat pedig 0-nak tekintjük. Ezért az igaz értékek száma (a feltételnek megfelelő elemek száma) megszámolható az összeg kiszámításával a sum() segítségével.

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

Ha a [] helyettesítjük a listamegértés jelölésében a () kifejezést, akkor egy generátor kifejezést kapunk. A listamegértés jelölés egy listát generál az összes feldolgozott elemről, míg a generátor kifejezés szekvenciálisan dolgozza fel az elemeket, és ezért memóriatakarékosabb.

Ha a generátor kifejezés az egyetlen argumentum, a () elhagyható, így úgy írható, mint az utóbbi esetben.

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

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

Ha a hamis értékek számát (a feltételnek nem megfelelő elemek számát) szeretné megszámolni, használja a not parancsot. Vegyük észre, hogy a > előbbre való, mint a not (előbb kerül kiszámításra), ezért a következő példában az (i < 0) zárójelekre () nincs szükség.

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

Természetesen maguk a feltételek is megváltoztathatók.

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

Az alábbiakban néhány további példát mutatunk be.

Példa a számok listájának páratlan elemeinek számítására.

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

Példa egy feltételre egy karakterláncok listájára.

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

A számlálót az előfordulások száma alapján történő számlálásra használjuk. items() egy (elem, előfordulások száma) tuple-t kér le, és az előfordulások száma adja meg a feltételt.

A következő példa a két vagy több előfordulással rendelkező elemek kiemelésére és az összes előfordulás számának megszámlálására szolgál. Ebben a példában négy a és két c van, összesen hat.

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

A következő példa a két vagy több előfordulással rendelkező elemek típusainak kivonására és az előfordulás számának megszámlálására szolgál. Ebben a példában két típus van, a és 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

Megszámolja egy szó előfordulásának számát egy karakterláncban.

Konkrét példaként számoljuk meg egy szó előfordulásának számát egy karakterláncban.

Először a replace() metódus segítségével cserélje ki a felesleges vesszőket és pontokat üres karakterláncra, majd törölje őket. Ezután a split() metódussal hozzon létre egy szóközökkel elválasztott listát.

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

Ha tudsz listát készíteni, akkor megkaphatod, hogy az egyes szavak hányszor fordulnak elő, milyen típusú szavak fordulnak elő, és a collections.Counter most_common() parancsával megkaphatod azt a szót, amelyik a legtöbbször fordul elő.

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

A fenti folyamat nagyon egyszerű, ezért az összetettebb természetes nyelvi feldolgozáshoz jobb, ha olyan könyvtárakat használunk, mint az NLTK.

A japán szöveg esetében a split() nem használható a szöveg szétválasztására, mivel nincs egyértelmű szavak szétválasztása. Ehhez például a Janome könyvtárat használhatja.

Megszámolja egy karakter előfordulásának számát egy karakterláncban.

Mivel a stringek szintén szekvencia típusok, használhatók a count() metódussal, vagy átadhatók argumentumként a collections.Counter() konstruktorának.

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

Példa az 5 leggyakrabban előforduló karakter keresésére.

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