Python Teller i samlinger med eksempel

Hva er Python Disk?

Python Teller er en beholder som vil holde tellingen av hvert av elementene som finnes i beholderen. Telleren er en underklasse som er tilgjengelig i ordbokklassen.

Telleren er en underklasse tilgjengelig i ordbokklassen. Ved å bruke Python Tellerverktøy, du kan telle nøkkelverdi-parene i et objekt, også kalt et hash-tabellobjekt.

Hvorfor bruke Python Disk?

Her er viktige grunner til å bruke Python 3 Teller:

• Telleren holder dataene i en uordnet samling, akkurat som hashbare objekter. Elementene her representerer nøklene og teller som verdier.
• Den lar deg telle elementene i en itererbar liste.
• Aritmetiske operasjoner som addisjon, subtilitettracsjon, skjæringspunkt og forening kan enkelt utføres på en teller.
• En teller kan også telle elementer fra en annen teller

Introduksjon til Python Motvirke

Python Telleren tar inn en liste, tuppel, ordbok, streng, som alle er gjentakbare objekter, og den vil gi deg utdata som vil ha antallet av hvert element.

Syntaks:

Counter(list)

Tenk på at du har en følgende liste:

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

Listen har elementene x , y og z. Når du bruker Counter på denne listen , vil den telle hvor mange ganger x , y og z er tilstede. Utgangen hvis telleren brukes på liste1 skal være noe sånt som:

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

Så vi har antallet x som 4, y som 2 og z som 2.

For å bruke Counter må vi først importere den som vist i eksemplet nedenfor:

from collections import Counter

Her er et enkelt eksempel som viser hvordan tellemodulen fungerer.

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

Utgang:

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

Teller med streng

In Python, alt er et objekt og streng er også et objekt. Python string kan lages ganske enkelt ved å omslutte tegn i det doble anførselstegn. Python støtter ikke en tegntype. Disse behandles som strenger med lengde én, også betraktet som en understreng.

I eksemplet nedenfor sendes en streng til Counter. Den returnerer ordbokformat, med nøkkel/verdi-par der nøkkelen er elementet og verdien er antallet. Den vurderer også plass som et element og gir antall mellomrom i strengen.

Eksempel:

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

Utgang:

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 med List

En liste er et gjentakelig objekt som har elementene sine innenfor hakeparenteser.

Elementene i listen når de gis til telleren vil bli konvertert til hashbare objekter der elementene blir nøkler og verdiene vil være antallet av elementene fra listen gitt.

For eksempel ['x','y','z','x','x','x','y','z']. Når du gir listen telleren, vil den gi deg antallet av hvert element i listen.

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

Utgang:

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

Teller med ordbok

En ordbok har elementer som nøkkel/verdi-par, og de er skrevet innenfor krøllede parenteser.

Når ordboken er gitt til telleren, vil den bli konvertert til et hashbart objekt der elementene blir nøkler, og verdiene vil være tellingen av elementene fra ordboken som er gitt.

For eksempel: {'x': 4, 'y': 2, 'z': 2, 'z': 2}. Tellerfunksjonen vil prøve å finne antallet av hver av tastene i den gitte ordboken.

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

Utgang:

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

Teller med Tuple

Tuple er en samling objekter atskilt med kommaer innenfor runde parenteser. Teller vil gi deg tellingen av hvert av elementene i tuppelen som er gitt.

Når tuppelen er gitt til telleren, vil den bli konvertert til et hashbart objekt der elementene blir nøkler og verdiene vil være tellingen av elementene fra den gitte tuppelen.

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

Utgang:

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

Få tilgang til, initialisering og oppdatering av tellere

Initialiserer teller

En teller kan initialiseres ved å sende strengverdi, liste, ordbok eller tuppel 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 teller som vist nedenfor:

from collections import Counter
_count = Counter()

Oppdaterer telleren

Du kan legge til verdier til telleren ved å bruke update()-metoden.

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

Den endelige koden er:

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

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

Tilgang til teller

For å hente verdiene fra telleren kan du gjø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]))

Utgang:

u : 3

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

Sletting av et element fra telleren

For å slette et element fra Counter kan du bruke del , som vist i eksemplet nedenfor:

Eksempel:

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

Utgang:

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

Aritmetisk operasjon på Python Motvirke

Aritmetiske operasjoner som addisjon, subtracsjon, skjæringspunkt og forening kan gjøres på en teller 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)

Utgang:

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

Metoder tilgjengelig på Python Motvirke

Det er noen viktige metoder tilgjengelig med Counter, her er listen over de samme:

• elementer() : Denne metoden vil returnere alle elementene med telling >0. Elementer med 0 eller -1 teller vil ikke bli returnert.
• mest_vanlig(verdi): Denne metoden vil returnere de vanligste elementene fra tellerlisten.
• nedenfortract(): Denne metoden brukes til å trekke elementene fra en annen teller.
• oppdatering(): Denne metoden brukes til å oppdatere elementene fra en annen teller.

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)

Utgang:

x
x
x
x
x
y
y

Eksempel: most_common(verdi)

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)

Utgang:

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

Utgang:

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)

Utgang:

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

Omtildeling teller inn Python

Du kan tilordne tellere på nytt som vist nedenfor:

Tenk på at du har en ordbok som: {'x': 5, 'y': 12, 'z': -2, 'x1':0}

Du kan endre antallet av elementet som vist nedenfor:

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

counter1['y'] = 20

print(counter1)

Utgang: Etter å ha utført vil du se at y-tellingen endres fra 12 til 20

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

Få og still inn antallet elementer ved hjelp av Counter

For å få tellingen til et element ved å bruke Counter kan du gjø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'

Utgang:

12

For å stille inn antallet av elementet kan du gjø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)

Utgang:

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

Spørsmål og svar