Python Tæller i Samlinger med Eksempel

Hvad er Python Tæller?

Python Tæller er en beholder, der vil holde tællingen af ​​hvert af de elementer, der er til stede i beholderen. Tælleren er en underklasse tilgængelig i ordbogsklassen.

Tælleren er en underklasse tilgængelig i ordbogsklassen. Ved hjælp af Python Tællerværktøj, du kan tælle nøgleværdi-parrene i et objekt, også kaldet et hash-tabelobjekt.

Hvorfor bruge Python Tæller?

Her er de vigtigste grunde til at bruge Python 3 Tæller:

• Tælleren opbevarer dataene i en uordnet samling ligesom hashbare objekter. Elementerne her repræsenterer nøglerne og tæller som værdier.
• Det giver dig mulighed for at tælle elementerne på en gentagelig liste.
• Aritmetiske operationer som addition og subtraktiontraction, skæringspunkt og forening kan nemt udføres på en tæller.
• En tæller kan også tælle elementer fra en anden tæller

Introduktion til Python Counter

Python Tælleren indlæser en liste, tupel, ordbog, streng, som alle er gentagelige objekter, og den vil give 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 Tæller på denne liste , vil den tælle hvor mange gange x , y og z er til stede. Outputtet, hvis tælleren bruges på liste1, skulle 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 tæller skal vi først importere den som vist i nedenstående eksempel:

from collections import Counter

Her er et simpelt eksempel, der viser tællermodulets funktion.

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

Output:

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

Tæller med streng

In Python, alt er et objekt og streng er også et objekt. Python streng kan oprettes ved blot at omslutte tegn i det dobbelte anførselstegn. Python understøtter ikke en tegntype. Disse behandles som strenge med længde 1, også betragtet som en understreng.

I eksemplet nedenfor sendes en streng til Counter. Det returnerer ordbogsformat med nøgle/værdi-par, hvor nøglen er elementet og værdien er antallet. Det betragter også rummet som et element og giver antallet af mellemrum i strengen.

Eksempel:

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

Tæller med Liste

En liste er et iterabelt objekt, der har sine elementer inden for firkantede parenteser.

Elementerne på listen, når de gives til tælleren, vil blive konverteret til et hashbare objekt, hvor elementerne bliver til nøgler, og værdierne vil være antallet af elementer fra den angivne liste.

For eksempel ['x','y','z','x','x','x','y','z']. Når du giver listen tælleren, vil den give dig antallet af hvert element på listen.

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

Output:

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

Tæller med ordbog

En ordbog har elementer som nøgle/værdi-par, og de er skrevet inden for krøllede parenteser.

Når ordbogen er givet til tælleren, vil den blive konverteret til et hashbart objekt, 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ællerfunktionen vil forsøge at finde antallet af hver nøgle i den givne ordbog.

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

Output:

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

Tæller med Tuple

Tuple er en samling af objekter adskilt af kommaer inden for runde parenteser. Tælleren vil give dig antallet af hvert af elementerne i den givne tuple.

Når tuplen er givet til tælleren, vil den blive konverteret til et hashbart objekt, hvor elementerne bliver til nøgler, og værdierne vil være optællingen af ​​elementerne fra den givne tuple.

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

Output:

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

Adgang til, initialisering og opdatering af tællere

Initialiserer tæller

En tæller kan initialiseres ved at sende strengværdi, liste, ordbog eller tuple som vist nedenfor:

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

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 at bruge update()-metoden.

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

Den endelige kode er:

from collections import Counter
_count = Counter()
_count.update('Welcome to Guru99 Tutorials!')
print(_count)

Udgangen 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]))

Output:

u : 3

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

Sletning af et element fra tæller

For at slette et element fra Counter kan du gøre brug af del , som vist i eksemplet nedenfor:

Eksempel:

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

Output:

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

Aritmetisk operation på Python Counter

Aritmetiske operationer som addition og subtraction, skæringspunkt og forening kan udføres på en tæller som vist i eksemplet nedenfor:

Eksempel:

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

Metoder tilgængelige på Python Counter

Der er nogle vigtige metoder tilgængelige med Counter, her er listen over samme:

• elementer() : Denne metode vil returnere alle elementer med tæller >0. Elementer med 0 eller -1 tæller vil ikke blive returneret.
• mest_almindelig(værdi): Denne metode vil returnere de mest almindelige elementer fra tællerlisten.
• nedenfortract(): 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 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

Eksempel: mest_almindelig(værdi)

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)]

Eksempel: subtract()

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

Eksempel: 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})

Gentildeling tæller ind Python

Du kan gentildele tællinger af tæller 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 Counter
counter1 =  Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})

counter1['y'] = 20

print(counter1)

Output: Efter udførelse vil du se, at y-tal ændres fra 12 til 20

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

Hent og indstil antallet af elementer ved hjælp af tæller

For at få tællingen af ​​et element ved hjælp af tæller kan du gøre som følger:

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

For at indstille antallet af elementet kan du gøre som følger:

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

Ofte Stillede Spørgsmål