Kunkin elementin esiintymien määrän laskeminen luettelossa Pythonin laskurilla

liiketoiminta

Pythonissa listan tai tuplan kaikkien elementtien lukumäärä saadaan käyttämällä sisäänrakennettua funktiota len(), ja kunkin elementin lukumäärä (kunkin elementin esiintymien lukumäärä) saadaan käyttämällä count()-metodia.

Lisäksi Pythonin standardikirjaston kokoelmien Counter-luokkaa voidaan käyttää elementtien hakemiseen esiintymien lukumäärän mukaisessa järjestyksessä.

Tässä jaksossa käsitellään seuraavia asioita

  • Laske elementtien kokonaismäärä:len()
  • Laske kunkin elementin lukumäärä (kunkin elementin esiintymien lukumäärä):count()
  • Käyttö.collections.Counter
  • Elementit haetaan esiintymistiheyden mukaisessa järjestyksessä:most_common()
  • Laske päällekkäisten elementtien (ainutlaatuisten elementtien) määrä (tyyppi).
  • Laske ehdon täyttävien elementtien määrä.

Konkreettisena esimerkkinä selitetään lisäksi seuraavaa esimerkkikoodin avulla.

  • Laskee sanan esiintymien määrän merkkijonossa.
  • Laskee merkkijonossa esiintyvien merkkien lukumäärän.

Esimerkki on lista, mutta sama käsittely voidaan tehdä myös tupleilla.

Laske elementtien kokonaismäärä: len()

Voit laskea listan tai tuplen elementtien kokonaismäärän käyttämällä sisäänrakennettua funktiota len().

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

print(len(l))
# 7

Kunkin elementin lukumäärän laskeminen (kunkin elementin esiintymien lukumäärä): count()-metodi

Voit laskea kunkin elementin lukumäärän (kunkin elementin esiintymien lukumäärän) käyttämällä listojen, tuplien jne. count()-metodia.

Jos argumenttina annetaan arvo, jota ei ole olemassa elementtinä, palautetaan 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

Jos haluat saada kunkin elementin esiintymien määrän kerralla, seuraava collection.Counter on hyödyllinen.

Kuinka käyttää collections.Counteria

Pythonin standardikirjaston kokoelmissa on Counter-luokka.

Counter() on sanakirjatyypin dict aliluokka, jonka tiedot ovat elementtejä avaimina ja esiintymiä arvoina.

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

Jos avaimeksi määritetään elementti, saadaan elementtien lukumäärä. Jos annetaan arvo, jota ei ole elementtinä, palautetaan 0.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Voit myös käyttää sanakirjatyyppisiä metodeja, kuten keys(), values(), items() jne.

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

Nämä menetelmät palauttavat dict_keys-tyyppisiä objekteja jne. Niitä voidaan käyttää sellaisenaan, jos haluat suorittaa for-lauseen. Jos haluat muuntaa ne listaksi, käytä list()-funktiota.

Elementtien saaminen esiintymistiheyden mukaisessa järjestyksessä: most_common()-menetelmä

Laskurilla on most_common()-metodi, joka palauttaa listan (elementti, esiintymien määrä) -muotoisista tupeleista, jotka on lajiteltu esiintymien määrän mukaan.

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

Elementti, jolla on eniten esiintymiä, saadaan määrittämällä indeksi, esimerkiksi [0] suurimmalle esiintymismäärälle ja [-1] pienimmälle esiintymismäärälle. Jos haluat saada vain elementit tai vain esiintymien lukumäärän, voit määrittää indeksin tarkemmin.

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

Jos haluat lajitella ne vähenevän esiintymismäärän mukaisessa järjestyksessä, käytä viipaletta, jonka inkrementiksi on asetettu -1.

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

Jos most_common()-menetelmälle annetaan argumentti n, palautetaan vain ne n elementtiä, joilla on eniten esiintymiä. Jos se jätetään pois, palautetaan kaikki elementit.

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

Jos haluat erillisen listan elementeistä\esiintymiä järjestettynä esiintymien lukumäärän mukaan, etkä tupleeta (elementti, esiintymien lukumäärä), voit hajottaa sen seuraavasti

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

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

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

Sisäänrakennettua funktiota zip() käytetään kaksiulotteisen listan (tässä tapauksessa tupleluettelon) transponointiin ja sen jälkeen sen purkamiseen ja poimimiseen.

Laske päällekkäisten elementtien (ainutlaatuisten elementtien) määrä (tyyppi).

Jos haluat laskea, kuinka monta päällekkäistä elementtiä (uniikkia elementtiä) listassa tai tuplissa on (kuinka monta tyyppiä on), käytä Counter- tai set()-ohjelmaa, kuten edellä on kuvattu.

Laskuriobjektin elementtien määrä on yhtä suuri kuin alkuperäisen listan päällekkäisten elementtien määrä, joka saadaan len()-ohjelmalla.

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

print(len(c))
# 3

Voit myös käyttää set(), set-tyypin set konstruktoria, mikä on helpompaa, jos et tarvitse Counter-oliota.

Joukkotyyppi on tietotyyppi, jossa ei ole päällekkäisiä elementtejä. Luettelon antaminen set()-funktiolle ei huomioi päällekkäisiä arvoja ja palauttaa set-tyyppisen objektin, jonka elementteinä on vain yksilöllisiä arvoja. Tämän tyypin elementtien lukumäärä saadaan len()-operaatiolla.

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

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

Laske ehdon täyttävien elementtien määrä.

Jos haluat laskea tietyn ehdon täyttävien elementtien määrän listassa tai tuplissa, käytä listan ymmärtämisen merkintätapaa tai generaattorilausekkeita.

Laske esimerkiksi negatiivisia arvoja sisältävien elementtien määrä seuraavassa luettelossa olevista luvuista

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

Soveltamalla ehdollista lauseketta jokaiseen elementtiin listan ymmärrettävyyden merkintätavalla saadaan lista, jonka elementit ovat Boolean bools (true, false). Bool-tyyppi bool on kokonaislukutyypin int alaluokka, jossa true on 1 ja false 0. Siksi tosiarvojen määrä (ehdon täyttävien elementtien määrä) voidaan laskea laskemalla summa käyttämällä sum()-ohjelmaa.

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

Jos korvataan [] listan ymmärtämisen merkinnässä merkinnällä (), saadaan generaattorilauseke. Listan ymmärtämisen merkintätapa tuottaa luettelon kaikista käsitellyistä elementeistä, kun taas generaattorilauseke käsittelee elementit peräkkäin ja on siksi muistitehokkaampi.

Kun generaattorilauseke on ainoa argumentti, () voidaan jättää pois, joten se voidaan kirjoittaa kuten jälkimmäisessä tapauksessa.

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

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

Jos haluat laskea väärien arvojen määrän (niiden elementtien määrä, jotka eivät täytä ehtoa), käytä not. Huomaa, että >:llä on korkeampi etusija kuin not:lla (se lasketaan ensin), joten sulkeet () seuraavassa esimerkissä (i < 0) eivät ole tarpeen.

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

Olosuhteita voidaan tietysti muuttaa.

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

Seuraavassa on joitakin muita esimerkkejä.

Esimerkki parittomien alkioiden lukumäärän saamisesta numeroluettelosta.

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

Esimerkki merkkijonojen luettelon ehdosta.

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

Laskuria käytetään laskemiseen esiintymien lukumäärän perusteella. items() hakee tuplan (elementti, esiintymien lukumäärä), ja esiintymien lukumäärä määrittää ehdon.

Seuraavassa on esimerkki sellaisten elementtien poimimisesta, joissa on kaksi tai useampia esiintymiä, ja esiintymien kokonaismäärän laskemisesta. Tässä esimerkissä on neljä a:ta ja kaksi c:tä, eli yhteensä kuusi.

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

Seuraavassa on esimerkki sellaisten elementtien tyyppien poimimisesta, joilla on kaksi tai useampia esiintymiä, ja esiintymien lukumäärän laskemisesta. Tässä esimerkissä on kaksi tyyppiä, a ja 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

Laskee sanan esiintymien määrän merkkijonossa.

Konkreettisena esimerkkinä voidaan laskea sanan esiintymien määrä merkkijonossa.

Korvaa ensin tarpeettomat pilkut ja pisteet tyhjällä merkkijonolla käyttämällä replace()-metodia ja poista ne sitten. Luo sitten split()-metodilla välilyönneillä erotettu luettelo.

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

Jos voit laatia luettelon, voit saada selville, kuinka monta kertaa kukin sana esiintyy, minkä tyyppisiä sanoja esiintyy, ja collections.Counterin most_common()-toiminnolla saat selville useimmin esiintyvän sanan.

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

Edellä kuvattu prosessi on hyvin yksinkertainen, joten monimutkaisempaan luonnollisen kielen käsittelyyn on parempi käyttää NLTK:n kaltaisia kirjastoja.

Japaninkielisen tekstin tapauksessa split()-ohjelmaa ei myöskään voi käyttää tekstin jakamiseen, koska siinä ei ole selvää sanojen erottelua. Voit käyttää esimerkiksi Janome-kirjastoa tämän saavuttamiseksi.

Laskee merkkijonossa esiintyvien merkkien lukumäärän.

Koska merkkijonot ovat myös sekvenssityyppi, niitä voidaan käyttää count()-metodin kanssa tai ne voidaan välittää argumenttina collections.Counter():n konstruktorille.

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

Esimerkki 5 yleisimmin esiintyvän merkin hakemisesta.

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