Wat is Python-teller?
Python Counter is een container die het aantal elementen in de container bevat. De teller is een subklasse die beschikbaar is in de woordenboekklasse.
De teller is een subklasse die beschikbaar is in de woordenboekklasse. Met behulp van de Python Counter-tool kunt u de sleutel / waarde-paren in een object tellen, ook wel een hashtabelobject genoemd.
Waarom Python Counter gebruiken?
Hier zijn de belangrijkste redenen om Python 3 Counter te gebruiken:
- The Counter bewaart de gegevens in een ongeordende verzameling, net als hash-objecten. De elementen hier vertegenwoordigen de sleutels en de telling als waarden.
- Hiermee kunt u de items in een itereerbare lijst tellen.
- Rekenkundige bewerkingen zoals optellen, aftrekken, doorsnijden en samenvoegen kunnen eenvoudig op een teller worden uitgevoerd.
- Een teller kan ook elementen van een andere teller tellen
In deze Python-tutorial leer je:
- Wat is Python-teller?
- Waarom Python Counter gebruiken?
- Inleiding tot Python Counter
- Teller met koord
- Teller met lijst
- Teller met woordenboek
- Teller met Tuple
- Toegang tot, initialiseren en bijwerken van tellers
- Een element verwijderen uit de teller
- Rekenkundige bewerking op Python Counter
- Methoden die beschikbaar zijn op Python Counter
- Tellingen opnieuw toewijzen in Python
- Verkrijg en stel het aantal elementen in met behulp van Counter
Inleiding tot Python Counter
Python Counter neemt als invoer een lijst, tuple, woordenboek, tekenreeks op, die allemaal itereerbare objecten zijn, en het geeft je uitvoer met de telling van elk element.
Syntaxis:
Counter(list)
Bedenk dat je een volgende lijst hebt:
list1 = ['x','y','z','x','x','x','y', 'z']
De lijst heeft de elementen x, y en z. Als je Teller in deze lijst gebruikt, zal het tellen hoe vaak x, y en z aanwezig zijn. De uitvoer als teller wordt gebruikt op lijst1 zou zoiets moeten zijn als:
Counter({'x': 4, 'y': 2, 'z': 2})
Dus we hebben de telling van x als 4, y als 2 en z als 2.
Om gebruik te maken van Counter moeten we deze eerst importeren zoals in het onderstaande voorbeeld wordt getoond:
from collections import Counter
Hier is een eenvoudig voorbeeld dat de werking van de tellermodule laat zien.
from collections import Counterlist1 = ['x','y','z','x','x','x','y', 'z']print(Counter(list1))
Uitgang:
Counter({'x': 4, 'y': 2, 'z': 2})
Teller met koord
In Python is alles een object en is string ook een object. Python-string kan eenvoudig worden gemaakt door tekens in de dubbele aanhalingstekens te plaatsen. Python ondersteunt geen tekentype. Deze worden behandeld als snaren met een lengte van één, ook wel beschouwd als een deelstring.
In het onderstaande voorbeeld wordt een string doorgegeven aan Counter. Het retourneert woordenboekindeling, met sleutel / waarde-paar waarbij de sleutel het element is en de waarde het aantal. Het beschouwt ook de spatie als een element en geeft het aantal spaties in de string.
Voorbeeld:
from collections import Countermy_str = "Welcome to Guru99 Tutorials!"print(Counter(my_str))
Uitgang:
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 met lijst
Een lijst is een itereerbaar object waarvan de elementen tussen vierkante haken staan.
De elementen in de lijst wanneer ze aan de teller worden gegeven, worden geconverteerd naar een hashtabel object waarin de elementen sleutels worden en de waarden het aantal elementen uit de gegeven lijst zijn.
Bijvoorbeeld ['x', 'y', 'z', 'x', 'x', 'x', 'y', 'z']. Zodra u de lijst de teller geeft, krijgt u de telling van elk element in de lijst.
from collections import Counterlist1 = ['x','y','z','x','x','x','y','z']print(Counter(list1))
Uitgang:
Counter({'x': 4, 'y': 2, 'z': 2})
Teller met woordenboek
Een woordenboek heeft elementen als sleutel / waarde-paar en ze worden tussen accolades geschreven.
Zodra het woordenboek aan de teller is gegeven, wordt het geconverteerd naar een hashtabelobject waarin de elementen sleutels worden, en de waarden zijn het aantal elementen uit het gegeven woordenboek.
Bijvoorbeeld: {'x': 4, 'y': 2, 'z': 2, 'z': 2}. De functie Teller zal proberen de telling van elk van de sleutels in het opgegeven woordenboek te vinden.
from collections import Counterdict1 = {'x': 4, 'y': 2, 'z': 2, 'z': 2}print(Counter(dict1))
Uitgang:
Counter({'x': 4, 'y': 2, 'z': 2})
Teller met Tuple
Tuple is een verzameling objecten gescheiden door komma's tussen ronde haakjes. Teller geeft u de telling van elk van de elementen in het gegeven tupel.
Zodra het tupel aan de teller is gegeven, wordt het geconverteerd naar een hashtabel-object waarin de elementen sleutels worden en de waarden het aantal elementen van het gegeven tupel zijn.
from collections import Countertuple1 = ('x','y','z','x','x','x','y','z')print(Counter(tuple1))
Uitgang:
Counter({'x': 4, 'y': 2, 'z': 2})
Toegang tot, initialiseren en bijwerken van tellers
Teller initialiseren
Een teller kan worden geïnitialiseerd door tekenreekswaarde, lijst, woordenboek of tuple door te geven, zoals hieronder wordt weergegeven:
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
U kunt ook een lege teller initialiseren zoals hieronder weergegeven:
from collections import Counter_count = Counter()
Teller bijwerken
U kunt waarden aan de teller toevoegen door de methode update () te gebruiken.
_count.update('Welcome to Guru99 Tutorials!')
De uiteindelijke code is:
from collections import Counter_count = Counter()_count.update('Welcome to Guru99 Tutorials!')print(_count)
De output is:
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})
Toegang tot teller
Om de waarden van de teller te krijgen, kunt u het volgende doen:
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]))
Uitgang:
u : 3G : 1u : 3r : 2u : 3
Een element verwijderen uit de teller
Om een element uit Counter te verwijderen kun je gebruik maken van del, zoals te zien is in onderstaand voorbeeld:
Voorbeeld:
from collections import Counterdict1 = {'x': 4, 'y': 2, 'z': 2}del dict1["x"]print(Counter(dict1))
Uitgang:
Counter({'y': 2, 'z': 2})
Rekenkundige bewerking op Python Counter
Rekenkundige bewerkingen zoals optellen, aftrekken, doorsnijden en samenvoegen kunnen op een teller worden uitgevoerd, zoals in het onderstaande voorbeeld wordt getoond:
Voorbeeld:
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)
Uitgang:
Counter({'y': 7, 'x': 4, 'z': 2})Counter({'x1': 12, 'x': 4})Counter({'y': 2})Counter({'y': 5, 'x': 4, 'z': 4})
Methoden die beschikbaar zijn op Python Counter
Er zijn enkele belangrijke methoden beschikbaar met Counter, hier is de lijst met dezelfde:
- elements () : Deze methode retourneert alle elementen met count> 0. Elementen met 0 of -1 tellen worden niet geretourneerd.
- most_common (waarde): deze methode retourneert de meest voorkomende elementen uit de tellerlijst .
- subtract (): deze methode wordt gebruikt om de elementen van een andere teller af te trekken.
- update (): deze methode wordt gebruikt om de elementen van een andere teller bij te werken.
Voorbeeld: elementen ()
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)
Uitgang:
xxxxxyy
Voorbeeld: most_common (waarde)
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)
Uitgang:
[('y', 12), ('x', 5)][('y', 12), ('x', 5), ('x1', 0), ('z', -2)]
Voorbeeld: aftrekken ()
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter2 = Counter({'x': 2, 'y':5})counter1.subtract(counter2)print(counter1)
Uitgang:
Counter({'y': 7, 'x': 3, 'x1': 0, 'z': -2})
Voorbeeld: 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)
Uitgang:
Counter({'y': 17, 'x': 7, 'x1': 0, 'z': -2})
Tellingen opnieuw toewijzen in Python
U kunt tellingen van de teller opnieuw toewijzen zoals hieronder wordt weergegeven:
Stel dat u een woordenboek heeft als: {'x': 5, 'y': 12, 'z': -2, 'x1': 0}
U kunt de telling van het element wijzigen zoals hieronder weergegeven:
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter1['y'] = 20print(counter1)
Output: Na het uitvoeren zul je zien dat de y-telling is gewijzigd van 12 in 20
Counter({'y': 20, 'x': 5, 'x1': 0, 'z': -2})
Verkrijg en stel het aantal elementen in met behulp van Counter
Om de telling van een element te krijgen met Counter, kun je het volgende doen:
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'
Uitgang:
12
Om de telling van het element in te stellen, kunt u het volgende doen:
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})print(counter1['y'])counter1['y'] = 20counter1['y1'] = 10print(counter1)
Uitgang:
12Counter({'y': 20, 'y1': 10, 'x': 5, 'x1': 0, 'z': -2})
Overzicht:
- Teller is een container die de telling van elk van de elementen in de container zal bevatten.
- Teller is een subklasse die beschikbaar is in de woordenboekklasse.
- Met behulp van de Python Counter-tool kun je de sleutel / waarde-paren in een object tellen, ook wel een hashtabel object genoemd.
- The Counter bewaart de gegevens in een ongeordende verzameling, net als hash-objecten. De elementen hier vertegenwoordigen de sleutels en de telling als waarden.
- Hiermee kunt u de items in een itereerbare lijst tellen.
- Rekenkundige bewerkingen zoals optellen, aftrekken, doorsnijden en samenvoegen kunnen eenvoudig op een teller worden uitgevoerd.
- Een teller kan ook elementen van een andere teller tellen.
- De belangrijkste methoden die beschikbaar zijn op een teller zijn elements (), most_common (waarde), aftrekken () en update ().
- Een teller kan worden gebruikt voor een string, lijst, woordenboek en tupel.