Kas ir Python Counter?
Python Counter ir konteiners, kas saturēs katra konteinerā esošā elementa skaitu. Skaitītājs ir apakšklase, kas pieejama vārdnīcas klasē.
Skaitītājs ir apakšklase, kas pieejama vārdnīcas klasē. Izmantojot rīku Python Counter, jūs varat uzskaitīt atslēgas un vērtību pārus objektā, sauktu arī par hash table objektu.
Kāpēc izmantot Python Counter?
Šeit ir galvenie Python 3 Counter izmantošanas iemesli:
- Skaitītājs datus glabā nesakārtotā kolekcijā, tāpat kā hashtable objektus. Elementi šeit attēlo atslēgas un skaitās kā vērtības.
- Tas ļauj skaitīt vienumus atkārtojamā sarakstā.
- Skaitītājā var viegli veikt aritmētiskās darbības, piemēram, saskaitīšanu, atņemšanu, krustojumu un savienošanu.
- Skaitītājs var saskaitīt arī elementus no cita skaitītāja
Šajā Python apmācībā jūs uzzināsiet:
- Kas ir Python Counter?
- Kāpēc izmantot Python Counter?
- Ievads Python Counter
- Skaitītājs ar stīgu
- Skaitītājs ar sarakstu
- Skaitītājs ar vārdnīcu
- Counter ar Tuple
- Piekļuve skaitītājiem, to inicializēšana un atjaunināšana
- Elementa dzēšana no skaitītāja
- Aritmētiskā darbība Python Counter
- Metodes, kas pieejamas Python Counter
- Skaitļu atkārtota piešķiršana Python
- Iegūstiet un iestatiet Elementu skaitu, izmantojot Counter
Ievads Python Counter
Python Counter ievada sarakstu, kopu, vārdnīcu, virkni, kas visi ir iterējami objekti, un tas dos jums izvadi, kurā būs katra elementa skaits.
Sintakse:
Counter(list)
Uzskatiet, ka jums ir šāds saraksts:
list1 = ['x','y','z','x','x','x','y', 'z']
Sarakstā ir elementi x, y un z. Ja šajā sarakstā izmantojat skaitītāju, tiks skaitīts, cik reizes x, y un z ir klāt. Izejai, ja 1. sarakstā tiek izmantots skaitītājs, jābūt apmēram šādam:
Counter({'x': 4, 'y': 2, 'z': 2})
Tātad mums ir skaitlis x kā 4, y kā 2 un z kā 2.
Lai izmantotu skaitītāju, mums tas vispirms jāimportē, kā parādīts zemāk dotajā piemērā:
from collections import Counter
Šeit ir vienkāršs piemērs, kas parāda Counter moduļa darbību.
from collections import Counterlist1 = ['x','y','z','x','x','x','y', 'z']print(Counter(list1))
Izeja:
Counter({'x': 4, 'y': 2, 'z': 2})
Skaitītājs ar stīgu
Programmā Python viss ir objekts, un virkne ir arī objekts. Python virkni var izveidot, vienkārši ievietojot rakstzīmes dubultā pēdiņā. Python neatbalsta rakstzīmju tipu. Tie tiek uzskatīti par viena garuma virknēm, kuras arī tiek uzskatītas par apakšvirsmām.
Šajā piemērā virkne tiek nodota skaitītājam. Tas atgriež vārdnīcas formātu ar atslēgu / vērtību pāri, kur atslēga ir elements un vērtība ir skaits. Tas arī uzskata vietu par elementu un norāda virkņu atstarpju skaitu.
Piemērs:
from collections import Countermy_str = "Welcome to Guru99 Tutorials!"print(Counter(my_str))
Izeja:
Counter({'o': 3, ' ': 3, 'u': 3, 'e': 2, 'l': 2, 't': 2, 'r': 2, '9': 2, 'W': 1,'c': 1, 'm': 1, 'G': 1, 'T': 1, 'i': 1, 'a': 1, 's': 1, '!': 1})
Skaitītājs ar sarakstu
Saraksts ir iterējams objekts, kura elementi atrodas kvadrātiekavās.
Skaitītājam piešķirtie saraksta elementi tiks pārveidoti par hashtable objektiem, kur elementi kļūs par atslēgām, un vērtības būs elementu skaits no norādītā saraksta.
Piemēram, ['x', 'y', 'z', 'x', 'x', 'x', 'y', 'z']. Kad sarakstam dodat skaitītāju, tas dos jums katra saraksta elementa skaitu.
from collections import Counterlist1 = ['x','y','z','x','x','x','y','z']print(Counter(list1))
Izeja:
Counter({'x': 4, 'y': 2, 'z': 2})
Skaitītājs ar vārdnīcu
Vārdnīcai ir elementi kā atslēgu / vērtību pāris, un tie ir ierakstīti cirtainās iekavās.
Kad vārdnīca tiks nodota skaitītājam, tā tiks pārveidota par hashtable objektiem, kuros elementi kļūs par atslēgām, un vērtības būs elementu skaits no dotās vārdnīcas.
Piemēram: {'x': 4, 'y': 2, 'z': 2, 'z': 2}. Funkcija Skaitītājs mēģinās atrast katra atslēgas skaitu dotajā vārdnīcā.
from collections import Counterdict1 = {'x': 4, 'y': 2, 'z': 2, 'z': 2}print(Counter(dict1))
Izeja:
Counter({'x': 4, 'y': 2, 'z': 2})
Counter ar Tuple
Tuple ir objektu kolekcija, ko apaļi iekavās atdala komati. Skaitītājs sniegs jums katra dotā elementa skaitu.
Kad kopa tiks nodota skaitītājam, tā tiks pārveidota par hashtable objektu, kurā elementi kļūs par atslēgām, un vērtības būs elementu skaits no norādītā dubultā.
from collections import Countertuple1 = ('x','y','z','x','x','x','y','z')print(Counter(tuple1))
Izeja:
Counter({'x': 4, 'y': 2, 'z': 2})
Piekļuve skaitītājiem, to inicializēšana un atjaunināšana
Inicializē skaitītāju
Skaitītāju var inicializēt, nododot virknes vērtību, sarakstu, vārdnīcu vai kopu, kā parādīts zemāk:
from collections import Counterprint(Counter("Welcome to Guru99 Tutorials!")) #using stringprint(Counter(['x','y','z','x','x','x','y', 'z'])) #using listprint(Counter({'x': 4, 'y': 2, 'z': 2})) #using dictionaryprint(Counter(('x','y','z','x','x','x','y', 'z'))) #using tuple
Varat arī inicializēt tukšu skaitītāju, kā parādīts zemāk:
from collections import Counter_count = Counter()
Atjaunina skaitītāju
Izmantojot atjaunināšanas () metodi, skaitītājam var pievienot vērtības.
_count.update('Welcome to Guru99 Tutorials!')
Galīgais kods ir:
from collections import Counter_count = Counter()_count.update('Welcome to Guru99 Tutorials!')print(_count)
Rezultāts ir:
Counter({'o': 3, ' ': 3, 'u': 3, 'e': 2, 'l': 2, 't': 2, 'r': 2, '9': 2, 'W': 1,'c': 1, 'm': 1, 'G': 1, 'T': 1, 'i': 1, 'a': 1, 's': 1, '!': 1})
Piekļuve skaitītājam
Lai iegūtu skaitītāja skaitītāja vērtības, varat rīkoties šādi:
from collections import Counter_count = Counter()_count.update('Welcome to Guru99 Tutorials!')print('%s : %d' % ('u', _count['u']))print('\n')for char in 'Guru':print('%s : %d' % (char, _count[char]))
Izeja:
u : 3G : 1u : 3r : 2u : 3
Elementa dzēšana no skaitītāja
Lai izdzēstu elementu no skaitītāja, varat izmantot del, kā parādīts zemāk esošajā piemērā:
Piemērs:
from collections import Counterdict1 = {'x': 4, 'y': 2, 'z': 2}del dict1["x"]print(Counter(dict1))
Izeja:
Counter({'y': 2, 'z': 2})
Aritmētiskā darbība Python Counter
Aritmētisko darbību, piemēram, saskaitīšanu, atņemšanu, krustojumu un savienošanu, var veikt ar skaitītāju, kā parādīts zemāk esošajā piemērā:
Piemērs:
from collections import Countercounter1 = Counter({'x': 4, 'y': 2, 'z': -2})counter2 = Counter({'x1': -12, 'y': 5, 'z':4 })#Additioncounter3 = counter1 + counter2 # only the values that are positive will be returned.print(counter3)#Subtractioncounter4 = counter1 - counter2 # all -ve numbers are excluded.For example z will be z = -2-4=-6, since it is -ve value it is not shown in the outputprint(counter4)#Intersectioncounter5 = counter1 & counter2 # it will give all common positive minimum values from counter1 and counter2print(counter5)#Unioncounter6 = counter1 | counter2 # it will give positive max values from counter1 and counter2print(counter6)
Izeja:
Counter({'y': 7, 'x': 4, 'z': 2})Counter({'x1': 12, 'x': 4})Counter({'y': 2})Counter({'y': 5, 'x': 4, 'z': 4})
Metodes, kas pieejamas Python Counter
Programmā Counter ir pieejamas dažas svarīgas metodes, šeit ir to pašu saraksts:
- elements () : Šī metode atgriezīs visus elementus ar skaitu> 0. Elementi ar 0 vai -1 skaitu netiks atgriezti.
- most_common (vērtība): Šī metode atgriezīs visbiežāk sastopamos elementus no Counter saraksta.
- atņemt (): Šo metodi izmanto, lai atņemtu elementus no cita skaitītāja.
- update (): Šo metodi izmanto, lai atjauninātu elementus no cita skaitītāja.
Piemērs: elements ()
from collections import Countercounter1 = Counter({'x': 5, 'y': 2, 'z': -2, 'x1':0})_elements = counter1.elements() # will give you all elements with positive value and count>0for a in _elements:print(a)
Izeja:
xxxxxyy
Piemērs: most_common (vērtība)
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})common_element = counter1.most_common(2) # The dictionary will be sorted as per the most common element first followed by next.print(common_element)common_element1 = counter1.most_common() # if the value is not given to most_common , it will sort the dictionary and give the most common elements from the start.The last element will be the least common element.print(common_element1)
Izeja:
[('y', 12), ('x', 5)][('y', 12), ('x', 5), ('x1', 0), ('z', -2)]
Piemērs: atņemt ()
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter2 = Counter({'x': 2, 'y':5})counter1.subtract(counter2)print(counter1)
Izeja:
Counter({'y': 7, 'x': 3, 'x1': 0, 'z': -2})
Piemērs: update ()
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter2 = Counter({'x': 2, 'y':5})counter1.update(counter2)print(counter1)
Izeja:
Counter({'y': 17, 'x': 7, 'x1': 0, 'z': -2})
Skaitļu atkārtota piešķiršana Python
Varat atkārtoti piešķirt skaitītāja skaitu, kā parādīts zemāk:
Uzskatiet, ka jums ir vārdnīca: {'x': 5, 'y': 12, 'z': -2, 'x1': 0}
Varat mainīt elementa skaitu, kā parādīts zemāk:
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter1['y'] = 20print(counter1)
Rezultāts: Pēc izpildes jūs redzēsiet, ka y skaits tiek mainīts no 12 uz 20
Counter({'y': 20, 'x': 5, 'x1': 0, 'z': -2})
Iegūstiet un iestatiet Elementu skaitu, izmantojot Counter
Lai iegūtu elementa skaitu, izmantojot skaitītāju, varat rīkoties šādi:
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})print(counter1['y']) # this will give you the count of element 'y'
Izeja:
12
Lai iestatītu elementa skaitu, varat rīkoties šādi:
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})print(counter1['y'])counter1['y'] = 20counter1['y1'] = 10print(counter1)
Izeja:
12Counter({'y': 20, 'y1': 10, 'x': 5, 'x1': 0, 'z': -2})
Kopsavilkums:
- Skaitītājs ir konteiners, kurā tiks uzskaitīti visi konteinerā esošie elementi.
- Skaitītājs ir apakšklase, kas pieejama vārdnīcas klasē.
- Izmantojot rīku Python Counter, jūs varat uzskaitīt atslēgu un vērtību pārus objektā, sauktu arī par hashtable objektu.
- Skaitītājs datus glabā nesakārtotā kolekcijā, tāpat kā hashtable objektus. Elementi šeit attēlo atslēgas un skaitās kā vērtības.
- Tas ļauj skaitīt vienumus atkārtojamā sarakstā.
- Skaitītājā var viegli veikt aritmētiskās darbības, piemēram, saskaitīšanu, atņemšanu, krustojumu un savienošanu.
- Skaitītājs var saskaitīt arī elementus no cita skaitītāja.
- Svarīgas skaitītājā pieejamās metodes ir elementi (), most_common (vērtība), atņemšana () un atjaunināšana ().
- Skaitītāju var izmantot virknei, sarakstam, vārdnīcai un kopai.