Python Räknare i samlingar med exempel

Vad är Python Disk?

Python Räknare är en behållare som kommer att hålla räkningen av vart och ett av de element som finns i behållaren. Räknaren är en underklass tillgänglig i ordboksklassen.

Räknaren är en underklass tillgänglig i ordboksklassen. Med hjälp av Python Räknarverktyg, du kan räkna nyckel-värdeparen i ett objekt, även kallat ett hashtabellobjekt.

Varför användning Python Disk?

Här är viktiga skäl för att använda Python 3 Räknare:

• Räknaren håller data i en oordnad samling, precis som hashbara objekt. Elementen här representerar nycklarna och räknas som värden.
• Det låter dig räkna objekten i en itererbar lista.
• Aritmetiska operationer som addition, subtraction, skärningspunkt och union kan enkelt utföras på en räknare.
• En räknare kan också räkna element från en annan räknare

Introduktion till Python Motverka

Python Räknaren tar in en lista, tupel, ordbok, sträng, som alla är itererbara objekt, och den kommer att ge dig utdata som kommer att ha räkningen av varje element.

Syntax:

Counter(list)

Tänk på att du har följande lista:

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

Listan har elementen x , y och z. När du använder Counter på den här listan kommer den att räkna hur många gånger x , y och z är närvarande. Utdata om räknaren används på lista1 bör vara något i stil med:

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

Så vi har räkningen av x som 4, y som 2 och z som 2.

För att använda Counter måste vi först importera det som visas i nedanstående exempel:

from collections import Counter

Här är ett enkelt exempel som visar hur räknarmodulen fungerar.

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

Produktion:

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

Räkna med sträng

In Python, allt är ett objekt och sträng är också ett objekt. Python sträng kan skapas helt enkelt genom att omge tecken i det dubbla citattecken. Python stöder inte en teckentyp. Dessa behandlas som strängar med längd ett, även betraktade som en delsträng.

I exemplet nedan skickas en sträng till Counter. Den returnerar ordboksformat, med nyckel/värdepar där nyckeln är elementet och värdet är räkningen. Den betraktar också rymden som ett element och ger antalet mellanslag i strängen.

Exempel:

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

Produktion:

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

Räkna med lista

En lista är ett itererbart objekt som har sina element inom hakparenteser.

Elementen i listan när de ges till räknaren kommer att konverteras till ett hashbart objekt där elementen blir nycklar och värdena kommer att vara antalet av elementen från den angivna listan.

Till exempel ['x','y','z','x','x','x','y','z']. När du ger listan räknaren kommer den att ge dig antalet av varje element i listan.

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

Produktion:

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

Räknare med ordbok

En ordbok har element som nyckel/värdepar, och de är skrivna inom parenteser.

När ordboken har getts till räknaren kommer den att konverteras till ett hashbart objekt där elementen blir nycklar, och värdena kommer att vara antalet element från den angivna ordboken.

Till exempel: {'x': 4, 'y': 2, 'z': 2, 'z': 2}. Räknarfunktionen kommer att försöka hitta antalet för var och en av tangenterna i den givna ordboken.

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

Produktion:

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

Räknare med Tuple

Tuple är en samling objekt separerade med kommatecken inom runda parenteser. Räknaren ger dig antalet av vart och ett av elementen i den givna tupeln.

När tuppeln är given till räknaren, kommer den att omvandlas till ett hashbart objekt där elementen blir nycklar och värdena kommer att vara antalet element från den givna tuppeln.

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

Produktion:

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

Åtkomst till, initiering och uppdatering av räknare

Initierar räknare

En räknare kan initieras genom att skicka strängvärde, lista, ordbok eller tupel som visas nedan:

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 också initiera en tom räknare som visas nedan:

from collections import Counter
_count = Counter()

Uppdaterar räknaren

Du kan lägga till värden till Counter genom att använda metoden update().

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

Den sista koden är:

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

Utgången är:

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

Åtkomst till disk

För att få värdena från räknaren kan du göra så här:

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

Produktion:

u : 3

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

Ta bort ett element från räknaren

För att ta bort ett element från Counter kan du använda del , som visas i exemplet nedan:

Exempel:

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

Produktion:

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

Aritmetisk operation på Python Motverka

Aritmetiska operationer som addition, subtraction, skärningspunkt och union kan göras på en räknare som visas i exemplet nedan:

Exempel:

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)

Produktion:

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

Metoder tillgängliga på Python Motverka

Det finns några viktiga metoder tillgängliga med Counter, här är listan över desamma:

• elements() : Denna metod kommer att returnera alla element med count >0. Element med 0 eller -1 räkning kommer inte att returneras.
• most_common(värde): Denna metod kommer att returnera de vanligaste elementen från Counter list.
• nedantract(): Denna metod används för att dra av elementen från en annan räknare.
• uppdatering(): Denna metod används för att uppdatera elementen från en annan räknare.

Exempel: element()

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)

Produktion:

x
x
x
x
x
y
y

Exempel: most_common(värde)

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)

Produktion:

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

Exempel: 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)

Produktion:

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

Exempel: 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)

Produktion:

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

Omtilldelning räknas in Python

Du kan tilldela om antalet räknare enligt nedan:

Anse att du har en ordbok som: {'x': 5, 'y': 12, 'z': -2, 'x1':0}

Du kan ändra antalet element enligt nedan:

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

counter1['y'] = 20

print(counter1)

Produktion: Efter exekvering kommer du att se att antalet y ändras från 12 till 20

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

Få och ställ in antalet element med hjälp av Counter

För att få räkningen av ett element med hjälp av Counter kan du göra så här:

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'

Produktion:

12

För att ställa in antalet av elementet kan du göra så här:

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)

Produktion:

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

Vanliga frågor