Hva er Python Counter?
Python Counter er en beholder som vil telle antallet av elementene i beholderen. Telleren er en underklasse tilgjengelig i ordboksklassen.
Telleren er en underklasse tilgjengelig i ordboksklassen. Ved hjelp av Python Counter-verktøyet kan du telle nøkkelverdiparene i et objekt, også kalt et hash-bordobjekt.
Hvorfor bruke Python Counter?
Her er hovedårsakene til å bruke Python 3 Counter:
- Telleren holder dataene i en uordnet samling, akkurat som hashable objekter. Elementene her representerer nøklene og teller som verdier.
- Den lar deg telle elementene i en iterabel liste.
- Aritmetiske operasjoner som tillegg, subtraksjon, kryss og forening kan enkelt utføres på en teller.
- En teller kan også telle elementer fra en annen teller
I denne Python-opplæringen lærer du:
- Hva er Python Counter?
- Hvorfor bruke Python Counter?
- Introduksjon til Python Counter
- Mot med String
- Teller med liste
- Teller med ordbok
- Teller med Tuple
- Få tilgang til, initialisere og oppdatere tellere
- Slette et element fra telleren
- Aritmetisk operasjon på Python Counter
- Metoder tilgjengelig på Python Counter
- Omfordele tellinger i Python
- Få og angi antall Elements ved hjelp av Counter
Introduksjon til Python Counter
Python Counter tar inn input en liste, tuple, ordbok, streng, som alle er iterable objekter, og det vil gi deg utdata som vil telle hvert element.
Syntaks:
Counter(list)
Vurder at du har en følgende liste:
list1 = ['x','y','z','x','x','x','y', 'z']
Listen har elementene x, y og z. Når du bruker Counter på denne listen, teller den hvor mange ganger x, y og z er til stede. Utgangen hvis telleren brukes på liste1 skal være omtrent som:
Counter({'x': 4, 'y': 2, 'z': 2})
Så vi har antallet x som 4, y som 2 og z som 2.
For å gjøre bruk av Counter må vi importere den først som vist i eksemplet nedenfor:
from collections import Counter
Her er et enkelt eksempel som viser hvordan Counter-modulen fungerer.
from collections import Counterlist1 = ['x','y','z','x','x','x','y', 'z']print(Counter(list1))
Produksjon:
Counter({'x': 4, 'y': 2, 'z': 2})
Mot med String
I Python er alt et objekt og streng er også et objekt. Python-streng kan opprettes ganske enkelt ved å legge inn tegn i det dobbelte sitatet. Python støtter ikke en karaktertype. Disse blir behandlet som strenger av lengde én, også betraktet som underlag.
I eksemplet nedenfor sendes en streng til Counter. Den returnerer ordbokformat, med nøkkel / verdipar der nøkkelen er elementet og verdien er telleren. Den anser også plass som et element og gir antall rom i strengen.
Eksempel:
from collections import Countermy_str = "Welcome to Guru99 Tutorials!"print(Counter(my_str))
Produksjon:
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})
Teller med liste
En liste er et gjentakbart objekt som har elementene sine i parentes.
Elementene i listen når de blir gitt til telleren vil bli konvertert til en hashtable objekter der elementene blir nøkler og verdiene vil være antallet elementer fra listen som er gitt.
For eksempel ['x', 'y', 'z', 'x', 'x', 'x', 'y', 'z']. Når du har gitt telleren til listen, vil den gi deg tellingen av hvert element i listen.
from collections import Counterlist1 = ['x','y','z','x','x','x','y','z']print(Counter(list1))
Produksjon:
Counter({'x': 4, 'y': 2, 'z': 2})
Teller med ordbok
En ordbok har elementer som nøkkel / verdipar, og de er skrevet i krøllete parenteser.
Når ordboken er gitt til telleren, vil den bli konvertert til en hashtable objekter der elementene blir nøkler, og verdiene vil være antallet av elementene fra ordboken som er gitt.
For eksempel: {'x': 4, 'y': 2, 'z': 2, 'z': 2}. Tellerfunksjonen vil prøve å finne tellingen til hver av nøklene i gitt ordbok.
from collections import Counterdict1 = {'x': 4, 'y': 2, 'z': 2, 'z': 2}print(Counter(dict1))
Produksjon:
Counter({'x': 4, 'y': 2, 'z': 2})
Teller med Tuple
Tuple er en samling objekter atskilt med komma innenfor runde parenteser. Telleren vil gi deg tellingen av hvert av elementene i tupelen gitt.
Når tupelen er gitt til telleren, blir den konvertert til et hashtabelt objekt der elementene blir nøkler og verdiene vil være antall elementer fra tuplen som er gitt.
from collections import Countertuple1 = ('x','y','z','x','x','x','y','z')print(Counter(tuple1))
Produksjon:
Counter({'x': 4, 'y': 2, 'z': 2})
Få tilgang til, initialisere og oppdatere tellere
Initialiserer teller
En teller kan initialiseres ved å sende strengverdi, liste, ordbok eller tuple som vist nedenfor:
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
Du kan også initialisere en tom teller som vist nedenfor:
from collections import Counter_count = Counter()
Oppdaterer teller
Du kan legge til verdier i telleren ved hjelp av oppdateringsmetoden ().
_count.update('Welcome to Guru99 Tutorials!')
Den endelige koden er:
from collections import Counter_count = Counter()_count.update('Welcome to Guru99 Tutorials!')print(_count)
Utgangen er:
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})
Få tilgang til teller
For å få verdiene fra telleren, kan du gjøre som følger:
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]))
Produksjon:
u : 3G : 1u : 3r : 2u : 3
Slette et element fra telleren
For å slette et element fra Counter kan du bruke del, som vist i eksemplet nedenfor:
Eksempel:
from collections import Counterdict1 = {'x': 4, 'y': 2, 'z': 2}del dict1["x"]print(Counter(dict1))
Produksjon:
Counter({'y': 2, 'z': 2})
Aritmetisk operasjon på Python Counter
Aritmetisk operasjon som tillegg, subtraksjon, kryss og forening kan gjøres på en teller som vist i eksemplet nedenfor:
Eksempel:
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)
Produksjon:
Counter({'y': 7, 'x': 4, 'z': 2})Counter({'x1': 12, 'x': 4})Counter({'y': 2})Counter({'y': 5, 'x': 4, 'z': 4})
Metoder tilgjengelig på Python Counter
Det er noen viktige metoder tilgjengelig med Counter, her er listen over det samme:
- elementer () : Denne metoden gir deg alle elementene med antall> 0. Elementer med 0 eller -1 teller returneres ikke.
- most_common (verdi): Denne metoden gir deg de vanligste elementene fra Counter-listen.
- subtraher (): Denne metoden brukes til å trekke elementene fra en annen teller.
- oppdatering (): Denne metoden brukes til å oppdatere elementene fra en annen teller.
Eksempel: elementer ()
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)
Produksjon:
xxxxxyy
Eksempel: most_common (verdi)
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)
Produksjon:
[('y', 12), ('x', 5)][('y', 12), ('x', 5), ('x1', 0), ('z', -2)]
Eksempel: trekke fra ()
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter2 = Counter({'x': 2, 'y':5})counter1.subtract(counter2)print(counter1)
Produksjon:
Counter({'y': 7, 'x': 3, 'x1': 0, 'z': -2})
Eksempel: oppdatering ()
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter2 = Counter({'x': 2, 'y':5})counter1.update(counter2)print(counter1)
Produksjon:
Counter({'y': 17, 'x': 7, 'x1': 0, 'z': -2})
Omfordele tellinger i Python
Du kan tildele antall teller på nytt som vist nedenfor:
Vurder at du har en ordbok som: {'x': 5, 'y': 12, 'z': -2, 'x1': 0}
Du kan endre antall elementer som vist nedenfor:
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter1['y'] = 20print(counter1)
Utgang: Etter utførelsen vil du se at antall teller endres fra 12 til 20
Counter({'y': 20, 'x': 5, 'x1': 0, 'z': -2})
Få og angi antall Elements ved hjelp av Counter
For å få tellingen av et element ved hjelp av Counter kan du gjøre som følger:
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'
Produksjon:
12
For å angi antallet av elementet kan du gjøre som følger:
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})print(counter1['y'])counter1['y'] = 20counter1['y1'] = 10print(counter1)
Produksjon:
12Counter({'y': 20, 'y1': 10, 'x': 5, 'x1': 0, 'z': -2})
Sammendrag:
- Teller er en beholder som vil holde tellingen av hvert av elementene som er tilstede i containeren.
- Counter er en underklasse tilgjengelig i ordboksklassen.
- Ved hjelp av Python Counter-verktøyet kan du telle nøkkelverdiparene i et objekt, også kalt et hashtabelt objekt.
- Telleren holder dataene i en uordnet samling, akkurat som hashable objekter. Elementene her representerer nøklene og teller som verdier.
- Den lar deg telle elementene i en iterabel liste.
- Aritmetiske operasjoner som tillegg, subtraksjon, kryss og forening kan enkelt utføres på en teller.
- En teller kan også telle elementer fra en annen teller.
- De viktige metodene som er tilgjengelige på en teller er elementer (), most_common (verdi), subtraherer () og oppdatering ().
- En teller kan brukes på en streng, liste, ordbok og tupel.