Python Teller in verzamelingen met voorbeeld

Wat is Python Balie?

Python Teller is een container die het aantal van elk van de aanwezige elementen in de container bijhoudt. De teller is een subklasse die beschikbaar is binnen de woordenboekklasse.

De teller is een subklasse die beschikbaar is binnen de woordenboekklasse. Met behulp van de Python Met de tellertool kunt u de sleutelwaardeparen in een object tellen, ook wel een hashtabelobject genoemd.

Waarom gebruik maken van Python Balie?

Hier zijn de belangrijkste redenen om te gebruiken Python 3 Teller:

• De Counter bewaart de gegevens in een ongeordende verzameling, net als hashbare objecten. De elementen vertegenwoordigen hier de sleutels en het aantal als waarden.
• Hiermee kunt u de items in een iterabele lijst tellen.
• Rekenkundige bewerkingen zoals optellen, aftrekken, snijden en samenvoegen kunnen eenvoudig op een teller worden uitgevoerd.
• Een teller kan ook elementen van een andere teller tellen

Inleiding tot Python Counter

Python Counter neemt als invoer een lijst, tupel, woordenboek, string op, allemaal itereerbare objecten, en het geeft je uitvoer met het aantal van elk element.

Syntax:

Counter(list)

Stel dat u de volgende lijst hebt:

list1 = ['x','y','z','x','x','x','y', 'z']

De lijst bevat de elementen x , y en z. Wanneer u Counter in deze lijst gebruikt, wordt geteld hoe vaak x , y en z aanwezig zijn. Als de teller op lijst1 wordt gebruikt, zou de uitvoer er ongeveer zo uit moeten zien:

Counter({'x': 4, 'y': 2, 'z': 2})

Dus we hebben de telling van x als 4, y als 2 en z als 2.

Om Counter te kunnen gebruiken, moeten we deze eerst importeren, zoals weergegeven in het onderstaande voorbeeld:

from collections import Counter

Hier is een eenvoudig voorbeeld dat de werking van de tellermodule laat zien.

from collections import Counter
list1 = ['x','y','z','x','x','x','y', 'z']
print(Counter(list1))

Output:

Counter({'x': 4, 'y': 2, 'z': 2})

Teller met touwtje

In Python, alles is een object en string is ook een object. Python snaar kan eenvoudig worden gemaakt door tekens tussen dubbele aanhalingstekens te plaatsen. Python ondersteunt geen tekentype. Deze worden behandeld als strings met lengte één, ook wel beschouwd als een substring.

In het onderstaande voorbeeld wordt een string doorgegeven aan Counter. Het retourneert de woordenboekindeling, met een sleutel/waarde-paar waarbij de sleutel het element is en de waarde het aantal. Het beschouwt ruimte ook als een element en geeft het aantal spaties in de string weer.

Voorbeeld:

from collections import Counter
my_str = "Welcome to Guru99 Tutorials!"
print(Counter(my_str))

Output:

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 zullen, wanneer ze aan de teller worden gegeven, worden geconverteerd naar hashtabelobjecten waarin de elementen sleutels zullen worden en de waarden het aantal elementen uit de gegeven lijst zullen zijn.

Bijvoorbeeld ['x','y','z','x','x','x','y','z']. Zodra u de lijst de teller geeft, krijgt u het aantal van elk element in de lijst.

from collections import Counter
list1 = ['x','y','z','x','x','x','y','z']
print(Counter(list1))

Output:

Counter({'x': 4, 'y': 2, 'z': 2})

Teller met woordenboek

Een woordenboek heeft elementen als sleutel/waarde-paren en deze worden tussen accolades geschreven.

Zodra het woordenboek aan de teller is gegeven, wordt het geconverteerd naar hashtabelobjecten waarin de elementen sleutels worden en de waarden het aantal elementen uit het gegeven woordenboek zijn.

Bijvoorbeeld: {'x': 4, 'y': 2, 'z': 2, 'z': 2}. De Counter-functie zal proberen het aantal van elke sleutel in het gegeven woordenboek te vinden.

from collections import Counter
dict1 =  {'x': 4, 'y': 2, 'z': 2, 'z': 2}
print(Counter(dict1))

Output:

Counter({'x': 4, 'y': 2, 'z': 2})

Teller met Tuple

Tuple is een verzameling objecten gescheiden door komma's binnen ronde haakjes. Counter geeft u het aantal van elk van de elementen in de gegeven tuple.

Zodra het tupel aan de teller is gegeven, wordt het geconverteerd naar een hashtabelobject waarin de elementen sleutels worden en de waarden het aantal elementen uit het gegeven tupel zijn.

from collections import Counter
tuple1 = ('x','y','z','x','x','x','y','z')
print(Counter(tuple1))

Output:

Counter({'x': 4, 'y': 2, 'z': 2})

Tellers openen, initialiseren en bijwerken

Teller initialiseren

Een teller kan worden geïnitialiseerd door een tekenreekswaarde, lijst, woordenboek of tupel door te geven, zoals hieronder weergegeven:

from collections import Counter
print(Counter("Welcome to Guru99 Tutorials!"))   #using string
print(Counter(['x','y','z','x','x','x','y', 'z'])) #using list
print(Counter({'x': 4, 'y': 2, 'z': 2})) #using dictionary
print(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 met behulp van de update() -methode.

_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 uitvoer 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 verkrijgen, 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]))

Output:

u : 3

G : 1
u : 3
r : 2
u : 3

Een element uit de teller verwijderen

Om een ​​element uit Counter te verwijderen kun je gebruik maken van del, zoals je ziet in onderstaand voorbeeld:

Voorbeeld:

from collections import Counter
dict1 =  {'x': 4, 'y': 2, 'z': 2}
del dict1["x"]
print(Counter(dict1))

Output:

Counter({'y': 2, 'z': 2})

Rekenkundige bewerking op Python Counter

Rekenkundige bewerkingen zoals optellen, aftrekken, snijden en verenigen kunnen op een teller worden uitgevoerd zoals in het onderstaande voorbeeld wordt getoond:

Voorbeeld:

from collections import Counter
counter1 =  Counter({'x': 4, 'y': 2, 'z': -2})

counter2 = Counter({'x1': -12, 'y': 5, 'z':4 })

#Addition
counter3 = counter1 + counter2 # only the values that are positive will be returned.

print(counter3)

#Subtraction
counter4 = 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 output

print(counter4)

#Intersection
counter5 = counter1 & counter2 # it will give all common positive minimum values from counter1 and counter2

print(counter5)

#Union
counter6 = counter1 | counter2 # it will give positive max values from counter1 and counter2

print(counter6)

Output:

Counter({'y': 7, 'x': 4, 'z': 2})
Counter({'x1': 12, 'x': 4})
Counter({'y': 2})
Counter({'y': 5, 'x': 4, 'z': 4})

Methoden Beschikbaar op Python Counter

Er zijn enkele belangrijke methoden beschikbaar bij Counter, hier is de lijst met dezelfde:

• elementen() : Deze methode levert u alle elementen op met telling >0. Elementen met een telling van 0 of -1 worden niet geretourneerd.
• meest_common(waarde): Deze methode levert u de meest voorkomende elementen uit de Tellerlijst op.
• aftrekken(): Deze methode wordt gebruikt om de elementen van een andere teller af te trekken.
• bijwerken(): Deze methode wordt gebruikt om de elementen van een andere teller bij te werken.

Voorbeeld: elementen()

from collections import Counter
counter1 =  Counter({'x': 5, 'y': 2, 'z': -2, 'x1':0})

_elements = counter1.elements() # will give you all elements with positive value and count>0
for a in _elements:
    print(a)

Output:

x
x
x
x
x
y
y

Voorbeeld: most_common(waarde)

from collections import Counter
counter1 =  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)

Output:

 [('y', 12), ('x', 5)]
[('y', 12), ('x', 5), ('x1', 0), ('z', -2)]

Voorbeeld: aftrekken()

from collections import Counter
counter1 =  Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})
counter2 = Counter({'x': 2, 'y':5})

counter1.subtract(counter2)
print(counter1)

Output:

Counter({'y': 7, 'x': 3, 'x1': 0, 'z': -2})

Voorbeeld: update()

from collections import Counter
counter1 =  Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})
counter2 = Counter({'x': 2, 'y':5})
counter1.update(counter2)
print(counter1)

Output:

Counter({'y': 17, 'x': 7, 'x1': 0, 'z': -2})

Tellingen opnieuw toewijzen Python

U kunt tellingen van Counter opnieuw toewijzen, zoals hieronder weergegeven:

Stel dat je een woordenboek hebt als: {'x': 5, 'y': 12, 'z': -2, 'x1':0}

U kunt de telling van het element wijzigen, zoals hieronder weergegeven:

from collections import Counter
counter1 =  Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})

counter1['y'] = 20

print(counter1)

Output: Na het uitvoeren zul je zien dat het aantal y is gewijzigd van 12 naar 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 achterhalen met behulp van Counter, kunt u het volgende doen:

from collections import Counter
counter1 =  Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})
print(counter1['y']) # this will give you the count of element 'y'

Output:

12

Om het aantal van het element in te stellen, kunt u het volgende doen:

from collections import Counter
counter1 =  Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})

print(counter1['y'])

counter1['y'] = 20
counter1['y1'] = 10

print(counter1)

Output:

12
Counter({'y': 20, 'y1': 10, 'x': 5, 'x1': 0, 'z': -2})

Samenvatting

• Teller is een container die het aantal van elk van de aanwezige elementen in de container bijhoudt.
• Counter is een subklasse die beschikbaar is binnen de woordenboekklasse.
• De Python Met de tellertool kunt u de sleutelwaardeparen in een object tellen, ook wel een hashtabelobject genoemd.
• De Counter bewaart de gegevens in een ongeordende verzameling, net als hashbare objecten. De elementen vertegenwoordigen hier de sleutels en het aantal als waarden.
• Hiermee kunt u de items in een iterabele lijst tellen.
• Rekenkundige bewerkingen zoals optellen, aftrekken, snijden en samenvoegen kunnen eenvoudig op een teller worden uitgevoerd.
• Een teller kan ook elementen van een andere teller tellen.
• De belangrijke methoden die beschikbaar zijn op een Counter zijn elements() , most_common(value), subtract() en update().
• Een teller kan worden gebruikt voor een string, lijst, woordenboek en tupel.