Hvad er Python Counter?
Python Counter er en beholder, der holder antallet af elementerne i containeren. Tælleren er en underklasse, der er tilgængelig inden for ordbogsklassen.
Tælleren er en underklasse, der er tilgængelig inden for ordbogsklassen. Ved hjælp af Python Counter-værktøjet kan du tælle nøgleværdiparene i et objekt, også kaldet et hash-tabelobjekt.
Hvorfor bruge Python Counter?
Her er hovedårsagerne til brugen af Python 3-tæller:
- Tælleren opbevarer dataene i en uordnet samling ligesom hashtable objekter. Elementerne her repræsenterer tasterne og tæller som værdier.
- Det giver dig mulighed for at tælle elementerne på en iterabel liste.
- Aritmetiske operationer som addition, subtraktion, kryds og union kan let udføres på en tæller.
- En tæller kan også tælle elementer fra en anden tæller
I denne Python-tutorial lærer du:
- Hvad er Python Counter?
- Hvorfor bruge Python Counter?
- Introduktion til Python Counter
- Tæller med streng
- Tæller med liste
- Tæller med ordbog
- Tæller med Tuple
- Adgang til, initialisering og opdatering af tællere
- Sletning af et element fra tælleren
- Aritmetisk operation på Python Counter
- Metoder tilgængelige på Python Counter
- Omfordeling af tællinger i Python
- Få og indstil antallet af elementer ved hjælp af tæller
Introduktion til Python Counter
Python Counter tager input en liste, tuple, ordbog, streng, som alle er iterable objekter, og det giver dig output, der vil have antallet af hvert element.
Syntaks:
Counter(list)
Overvej at du har en følgende liste:
list1 = ['x','y','z','x','x','x','y', 'z']
Listen har elementerne x, y og z. Når du bruger Counter på denne liste, tæller den hvor mange gange x, y og z er til stede. Output hvis tæller bruges på liste1 skal være noget som:
Counter({'x': 4, 'y': 2, 'z': 2})
Så vi har antallet af x som 4, y som 2 og z som 2.
For at gøre brug af Counter skal vi først importere det som vist i nedenstående eksempel:
from collections import Counter
Her er et simpelt eksempel, der viser funktionen af tællermodul.
from collections import Counterlist1 = ['x','y','z','x','x','x','y', 'z']print(Counter(list1))
Produktion:
Counter({'x': 4, 'y': 2, 'z': 2})
Tæller med streng
I Python er alt et objekt, og streng er også et objekt. Python-streng kan oprettes ved blot at omslutte tegn i det dobbelte citat. Python understøtter ikke en karaktertype. Disse behandles som strenge af længde en, også betragtet som en understreng.
I eksemplet nedenfor sendes en streng til Counter. Det returnerer ordbogformat med nøgle / værdipar, hvor nøglen er elementet, og værdien er tællingen. Det betragter også plads som et element og giver antallet af mellemrum i strengen.
Eksempel:
from collections import Countermy_str = "Welcome to Guru99 Tutorials!"print(Counter(my_str))
Produktion:
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})
Tæller med liste
En liste er et gentageligt objekt, der har sine elementer inden for firkantede parenteser.
Elementerne på listen, når de gives til tælleren, konverteres til en hashtable objekter, hvor elementerne bliver nøgler, og værdierne vil være antallet af elementer fra den givne liste.
For eksempel ['x', 'y', 'z', 'x', 'x', 'x', 'y', 'z']. Når du først har givet listen tælleren, giver den dig antallet af hvert element på listen.
from collections import Counterlist1 = ['x','y','z','x','x','x','y','z']print(Counter(list1))
Produktion:
Counter({'x': 4, 'y': 2, 'z': 2})
Tæller med ordbog
En ordbog har elementer som nøgle / værdipar, og de er skrevet inden for krøllede parenteser.
Når ordbogen er givet til tælleren, konverteres den til en hashtable objekter, hvor elementerne bliver nøgler, og værdierne vil være antallet af elementer fra den angivne ordbog.
For eksempel: {'x': 4, 'y': 2, 'z': 2, 'z': 2}. Tæller-funktionen forsøger at finde antallet af nøgler i den givne ordbog.
from collections import Counterdict1 = {'x': 4, 'y': 2, 'z': 2, 'z': 2}print(Counter(dict1))
Produktion:
Counter({'x': 4, 'y': 2, 'z': 2})
Tæller med Tuple
Tuple er en samling af objekter adskilt af komma inden for runde parenteser. Tæller giver dig optællingen af hvert af elementerne i den angivne tuple.
Når tuplen er givet til tælleren, konverteres den til et hashtabelt objekt, hvor elementerne bliver nøgler, og værdierne vil være antallet af elementer fra den givne tuple.
from collections import Countertuple1 = ('x','y','z','x','x','x','y','z')print(Counter(tuple1))
Produktion:
Counter({'x': 4, 'y': 2, 'z': 2})
Adgang til, initialisering og opdatering af tællere
Initialisering af tæller
En tæller kan initialiseres ved at sende strengværdi, liste, ordbog 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 tæller som vist nedenfor:
from collections import Counter_count = Counter()
Opdaterer tæller
Du kan tilføje værdier til tælleren ved hjælp af opdateringsmetoden ().
_count.update('Welcome to Guru99 Tutorials!')
Den endelige kode er:
from collections import Counter_count = Counter()_count.update('Welcome to Guru99 Tutorials!')print(_count)
Outputtet 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})
Adgang til tæller
For at få værdierne fra tælleren kan du gø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]))
Produktion:
u : 3G : 1u : 3r : 2u : 3
Sletning af et element fra tælleren
For at slette et element fra Counter kan du gøre brug af del, som vist i eksemplet nedenfor:
Eksempel:
from collections import Counterdict1 = {'x': 4, 'y': 2, 'z': 2}del dict1["x"]print(Counter(dict1))
Produktion:
Counter({'y': 2, 'z': 2})
Aritmetisk operation på Python Counter
Aritmetisk operation som addition, subtraktion, kryds og union kan udføres på en tæller 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)
Produktion:
Counter({'y': 7, 'x': 4, 'z': 2})Counter({'x1': 12, 'x': 4})Counter({'y': 2})Counter({'y': 5, 'x': 4, 'z': 4})
Metoder tilgængelige på Python Counter
Der er nogle vigtige metoder til rådighed med Counter, her er listen over det samme:
- elementer () : Denne metode returnerer alle elementerne med antal> 0. Elementer med 0 eller -1 tæller returneres ikke.
- most_common (værdi): Denne metode giver dig de mest almindelige elementer fra Counter-listen.
- subtrahere (): Denne metode bruges til at trække elementerne fra en anden tæller.
- opdatering (): Denne metode bruges til at opdatere elementerne fra en anden tæller.
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)
Produktion:
xxxxxyy
Eksempel: most_common (værdi)
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)
Produktion:
[('y', 12), ('x', 5)][('y', 12), ('x', 5), ('x1', 0), ('z', -2)]
Eksempel: træk ()
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter2 = Counter({'x': 2, 'y':5})counter1.subtract(counter2)print(counter1)
Produktion:
Counter({'y': 7, 'x': 3, 'x1': 0, 'z': -2})
Eksempel: opdatering ()
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter2 = Counter({'x': 2, 'y':5})counter1.update(counter2)print(counter1)
Produktion:
Counter({'y': 17, 'x': 7, 'x1': 0, 'z': -2})
Omfordeling af tællinger i Python
Du kan omfordele antallet af tællere som vist nedenfor:
Overvej at du har en ordbog som: {'x': 5, 'y': 12, 'z': -2, 'x1': 0}
Du kan ændre antallet af elementet som vist nedenfor:
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter1['y'] = 20print(counter1)
Output: Efter udførelse vil du se, at y-antallet ændres fra 12 til 20
Counter({'y': 20, 'x': 5, 'x1': 0, 'z': -2})
Få og indstil antallet af elementer ved hjælp af tæller
For at få optællingen af et element ved hjælp af Counter kan du gø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'
Produktion:
12
For at indstille antallet af elementet kan du gø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)
Produktion:
12Counter({'y': 20, 'y1': 10, 'x': 5, 'x1': 0, 'z': -2})
Resumé:
- Tæller er en container, der holder antallet af elementerne i containeren.
- Counter er en underklasse, der er tilgængelig inden for ordbogsklassen.
- Ved hjælp af Python Counter-værktøjet kan du tælle nøgleværdiparene i et objekt, også kaldet et hashtabelt objekt.
- Tælleren opbevarer dataene i en uordnet samling ligesom hashtable objekter. Elementerne her repræsenterer tasterne og tæller som værdier.
- Det giver dig mulighed for at tælle elementerne på en iterabel liste.
- Aritmetiske operationer som addition, subtraktion, kryds og union kan let udføres på en tæller.
- En tæller kan også tælle elementer fra en anden tæller.
- De vigtige metoder, der er tilgængelige på en tæller, er elementer (), most_common (værdi), trækker () og opdatering ().
- En tæller kan bruges på en streng, liste, ordbog og tuple.