Python-teller in verzamelingen met voorbeeld

Wat is Python Counter?

Python Counter is een container die de telling van elk van de elementen in de container bevat. 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 Counter-tool kun je de sleutel-waardeparen in een object tellen, ook wel een hashtabelobject genoemd.

Waarom Python Counter gebruiken?

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

• De teller houdt de gegevens in een ongeordende verzameling, net als hashtable-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, snijpunten en samenvoegen kunnen eenvoudig worden uitgevoerd op een teller.
• Een teller kan ook elementen tellen van een andere teller

In deze Python-tutorial leer je:

• Wat is Python Counter?
• Waarom Python Counter gebruiken?
• Inleiding tot Python Counter
• Teller met string
• Teller met lijst
• Tegen met woordenboek
• Tegen met Tuple
• Toegang tot, initialiseren en bijwerken van tellers
• Een element verwijderen uit teller
• Rekenkundige bewerking op Python Counter
• Beschikbare methoden op Python Counter
• Tellen opnieuw toewijzen in Python
• Verkrijg en stel het aantal elementen in met Teller

Inleiding tot Python Counter

Python Counter neemt een lijst, tuple, woordenboek, string in, die allemaal itereerbare objecten zijn, en het zal je output geven die het aantal van elk element bevat.

Syntaxis:

Counter(list)

Overweeg dat je een volgende lijst hebt:

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

De lijst heeft de elementen x , y en z. Wanneer u Teller in deze lijst gebruikt, wordt geteld hoe vaak x , y en z aanwezig is. 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 Teller, 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 Teller-module laat zien.

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

Uitgang:

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

Teller met string

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

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

Voorbeeld:

from collections import Counter
my_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 hashtable-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 Counter
list1 = ['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 zijn tussen accolades geschreven.

Zodra het woordenboek aan de teller is gegeven, wordt het geconverteerd naar een hashtabel-object 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 Teller-functie zal proberen de telling van elk van de sleutels in het gegeven woordenboek te vinden.

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

Uitgang:

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

Tegen met Tuple

Tuple is een verzameling objecten gescheiden door komma's tussen ronde haakjes. Teller geeft je de telling van elk van de elementen in de gegeven tupel.

Zodra de tuple aan de teller is gegeven, wordt deze geconverteerd naar een hash-tabel object waarin de elementen sleutels worden en de waarden het aantal elementen van de gegeven tuple zijn.

from collections import Counter
tuple1 = ('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 een tekenreekswaarde, lijst, woordenboek of tuple 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 de update()-methode.

_count.update('Welcome to Guru99 Tutorials!')

De laatste 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})

Toegangsteller

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 : 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 in het onderstaande voorbeeld:

Voorbeeld:

from collections import Counter
dict1 =  {'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, snijpunt en vereniging kunnen worden gedaan op een teller, zoals weergegeven in het onderstaande voorbeeld:

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)

Uitgang:

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

Beschikbare methoden op Python Counter

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

• elementen() :Deze methode geeft je alle elementen terug met count>0. Elementen met een telling van 0 of -1 worden niet geretourneerd.
• most_common(value): Deze methode geeft je de meest voorkomende elementen uit de Tellerlijst.
• aftrekken(): 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 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)

Uitgang:

x
x
x
x
x
y
y

Voorbeeld:most_common(value)

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)

Uitgang:

 [('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)

Uitgang:

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)

Uitgang:

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

Tellen opnieuw toewijzen in Python

U kunt tellingen van de teller opnieuw toewijzen, zoals hieronder weergegeven:

Stel je hebt een woordenboek 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)

Uitvoer:na het uitvoeren zult u 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 Teller

Om de telling van een element met behulp van Teller te krijgen, 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'

Uitgang:

12

Om de telling 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)

Uitgang:

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

Samenvatting:

• Teller is een container die de telling van elk van de elementen in de container bevat.
• Teller is een subklasse die beschikbaar is binnen de woordenboekklasse.
• Met de Python Counter-tool kun je de sleutel-waardeparen in een object tellen, ook wel een hashtable-object genoemd.
• De teller houdt de gegevens in een ongeordende verzameling, net als hashtable-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, snijpunten en samenvoegen kunnen eenvoudig worden uitgevoerd op een teller.
• Een teller kan ook elementen tellen van een andere teller.
• 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 tuple.