Kā izmantot Python skaitītāju no kolekciju moduļa

Šajā apmācībā jūs uzzināsit, kā izmantot Python kolekcijas moduļa skaitītāja objektu.

Strādājot ar garām secībām Python, piemēram, Python sarakstiem vai virknēm, dažkārt var būt nepieciešams saglabāt secībā redzamos vienumus un to parādīšanas reižu skaitu.

Python vārdnīca ir piemērota iebūvēta datu struktūra šādām lietojumprogrammām. Tomēr Python’s Counter klase no kolekciju moduļa var to vienkāršot, izveidojot skaitītāju, kas ir vienumu vārdnīca un to skaits secībā.

Dažu nākamo minūšu laikā jūs uzzināsit tālāk norādīto.

• Izmantojiet Python skaitītāja objektu
• Izveidojiet Python vārdnīcu, lai saglabātu vienumu skaita vērtības iterējamā veidā
• Pārrakstiet vārdnīcu, izmantojot Python skaitītāju ar vienkāršotu sintaksi
• Veiciet tādas darbības kā elementu atjaunināšana un atņemšana, krustpunktu atrašana starp diviem skaitītāja objektiem
• Iegūstiet visbiežāk sastopamās preces skaitītājā, izmantojot metodi most_common().

Sāksim!

Python kolekciju modulis un skaitītāju klase

Jūs bieži izmantosit Python vārdnīcu, lai saglabātu vienumus un to skaitu iterējamā veidā. Vienumi un skaits tiek saglabāti attiecīgi kā atslēgas un vērtības.

Tā kā Counter klase ir daļa no Python iebūvētā kolekciju moduļa, varat to importēt savā Python skriptā šādi:

from collections import Counter

Pēc skaitītāja klases importēšanas, kā minēts, varat izveidot skaitītāja objektu, kā parādīts attēlā:

<counter_object> = Counter(iterable)

Šeit:

• iterable ir jebkura derīga Python iterable, piemēram, Python saraksts, virkne vai kortežs.
• Iterējamā vienumiem ir jābūt jauktiem.

Tagad, kad mēs zinām, kā izmantot skaitītāju, lai izveidotu skaitītāju objektus no jebkura Python atkārtojamības, sāksim kodēšanu.

Šajā apmācībā izmantotie piemēri ir atrodami šajā GitHub kopsavilkumā.

Kā izveidot skaitītāju objektu no Python Iterables

Izveidosim Python virkni, teiksim, “renesanse” un nosauksim to par vārdu.

>>> word = "renaissance"

Mūsu mērķis ir izveidot vārdnīcu, kurā katrs vārda virknes burts tiek kartēts ar to, cik reižu tas virknē parādās. Viena pieeja ir izmantot cilpas, kā parādīts attēlā:

>>> letter_count = {}
>>> for letter in word:
...     if letter not in letter_count:
...         letter_count[letter] = 0
...     letter_count[letter] += 1
...
>>> letter_count
{'r': 1, 'e': 2, 'n': 2, 'a': 2, 'i': 1, 's': 2, 'c': 1}

Parsēsim, ko dara iepriekš minētais koda fragments:

• Inicializē burtu_skaitu tukšā Python vārdnīcā.
• Apgriež vārdu virkni.
• Pārbauda, ​​vai burtu_skaita vārdnīcā ir burts.
• Ja burta nav, tas pievieno to ar vērtību 0 un pēc tam palielina vērtību par 1.
• Katram burta gadījumam vārdam atbilstošā burta vērtība tiek palielināta par 1.
• Tas turpinās, līdz mēs izgriežam visu virkni.

Mēs paši izveidojām burtu_skaita vārdnīcu, izmantojot cilpu, lai cilpinātu virknes vārdu.

Tagad izmantosim kolekciju moduļa Counter klasi. Mums ir tikai jānodod vārda virkne uz Counter(), lai iegūtu burtu_skaitījumu, neveicot atkārtojumus.

>>> from collections import Counter
>>> letter_count = Counter(word)
>>> letter_count
Counter({'e': 2, 'n': 2, 'a': 2, 's': 2, 'r': 1, 'i': 1, 'c': 1})

Skaitītāja objekts ir arī Python vārdnīca. Mēs varam izmantot iebūvēto funkciju isinstance(), lai to pārbaudītu:

>>> isinstance(letter_count,dict)
True

Kā redzams, isinstance(burtu_skaits, diktāts) atgriež True, norādot, ka skaitītāja objekts burtu_skaits ir Python dict klases gadījums.

Skaitītāja objekta modificēšana

Līdz šim mēs esam iemācījušies izveidot pretobjektus no Python virknēm.

Varat arī modificēt skaitītāju objektus, atjauninot tos ar elementiem no cita iterējama vai atņemot no tiem citu iterējamu.

Skaitītāja atjaunināšana ar elementiem no cita Iterable

Inicializēsim citu virkni other_word:

>>> another_word = "effervescence"

Pieņemsim, ka mēs vēlamies atjaunināt burtu_skaita skaitītāja objektu ar vienumiem no virknes other_word.

Mēs varam izmantot metodi update() skaitītāja objektā letter_count.

>>> letter_count.update(another_word)
>>> letter_count
Counter({'e': 7, 'n': 3, 's': 3, 'c': 3, 'r': 2, 'a': 2, 'f': 2, 'i': 1, 'v': 1})

Izvadā mēs redzam, ka skaitītāja objekts ir atjaunināts, iekļaujot arī burtus un to gadījumu skaitu no other_word.

Elementu atņemšana no cita atkārtojama

Tagad atņemsim cita_vārda vērtību no burtu_skaita objekta. Lai to izdarītu, mēs varam izmantot atņemšanas () metodi. Izmantojot .subtract(), no tiek atņemtas vērtības, kas atbilst vienumiem .

Atņemsim cits_vārds no burtu_skaita.

>>> letter_count.subtract(another_word)
>>> letter_count
Counter({'e': 2, 'n': 2, 'a': 2, 's': 2, 'r': 1, 'i': 1, 'c': 1, 'f': 0, 'v': 0})

Mēs redzam, ka vērtības, kas atbilst burtiem citā_vārdā, ir atņemtas, bet pievienotās atslēgas ‘f’ un ‘v’ nav noņemtas. Tagad tie tiek kartēti uz vērtību 0.

Piezīme. Šeit mēs esam nodevuši other_word, Python virkni, metodes subtract() izsaukumam. Mēs varam arī nodot Python skaitītāja objektu vai citu iterējamu.

Krustojums starp diviem pretobjektiem Python

Dažreiz var vēlēties atrast krustpunktu starp diviem Python skaitītāja objektiem, lai noteiktu, kuras atslēgas ir kopīgas starp abiem.

Izveidosim pretobjektu, piemēram, burtu_skaits_2, no otras_vārda virknes ‘putošanās’.

>>> another_word = "effervescence"
>>> letter_count_2 = Counter(another_word)
>>> letter_count_2
Counter({'e': 5, 'f': 2, 'c': 2, 'r': 1, 'v': 1, 's': 1, 'n': 1})

Mēs varam izmantot operatoru simple &, lai atrastu krustpunktu starp burtu_skaits un burtu_skaits_2.

>>> letter_count & letter_count_2
Counter({'e': 2, 'r': 1, 'n': 1, 's': 1, 'c': 1})

Ievērojiet, kā iegūstat taustiņus un abiem vārdiem kopīgo gadījumu skaitu. Gan “renesanse”, gan “putošanās” satur divus kopīgus “e” gadījumus un pa vienam gadījumam no “r”, “n”, “s” un “c”.

Atrodiet visbiežāk sastopamās preces, izmantojot most_common

Vēl viena izplatīta darbība Python skaitītāja objektā ir atrast visbiežāk sastopamos vienumus.

Lai skaitītājā iegūtu k populārāko vienumu, varat izmantot skaitītāja objekta metodi most_common(). Šeit mēs izsaucam most_common() par letter_count, lai atrastu trīs visbiežāk sastopamos burtus.

>>> letter_count.most_common(3)
[('e', 2), ('n', 2), ('a', 2)]

Mēs redzam, ka burti „e”, „n” un „a” ir sastopami divreiz vārdā „renesanse”.

Tas ir īpaši noderīgi, ja skaitītājā ir daudz ierakstu un jūs interesē darbs ar visizplatītākajiem taustiņiem.

Secinājums

Šeit ir īss pārskats par apmācībā apgūto:

• Python iebūvēto kolekciju moduļa skaitītāju klasi var izmantot, lai iegūtu visu vienumu skaita vērtību vārdnīcu jebkurā iterējamā veidā. Pārliecinieties, vai visi iterējamā vienumi ir jaukjami.
• Varat atjaunināt viena Python skaitītāja objekta saturu ar saturu no cita skaitītāja objekta vai jebkuru citu iterējamu, izmantojot metodi update() ar sintaksi: counter1.update(counter2). Ņemiet vērā, ka counter2 vietā varat izmantot jebkuru iterable.
• Ja vēlaties no atjauninātā skaitītāja noņemt viena iterable satura saturu, varat izmantot atņemšanas() metodi: counter1.subtract(counter2).
• Lai atrastu kopīgos elementus starp diviem skaitītāja objektiem, varat izmantot operatoru &. Ņemot vērā divus skaitītājus skaitītājs1 un skaitītājs2, skaitītājs1 un skaitītājs2 atgriež šo divu skaitītāja objektu krustpunktu.
• Lai skaitītājā iegūtu k visbiežāk sastopamos vienumus, varat izmantot metodi most_common(). counter.most_common(k) sniedz k visbiežāk sastopamos vienumus un attiecīgos skaitu.

Pēc tam uzziniet, kā izmantot noklusējuma dict — citu kolekciju moduļa klasi. Lai apstrādātu trūkstošos taustiņus, parastās Python vārdnīcas vietā varat izmantot noklusējuma diktātu.