Python Laskuri kokoelmissa esimerkin kanssa

Mikä on Python Laskuri?

Python Laskuri on säiliö, joka sisältää jokaisen säiliössä olevien elementtien määrän. Laskuri on alaluokka, joka on saatavilla sanakirjaluokan sisällä.

Laskuri on alaluokka, joka on saatavilla sanakirjaluokan sisällä. Käyttämällä Python Laskurityökalulla voit laskea objektin avainarvoparit, jota kutsutaan myös hash-taulukkoobjektiksi.

Miksi käyttää Python Laskuri?

Tässä on tärkeimmät syyt käyttää Python 3 Laskuri:

• Laskuri säilyttää tiedot järjestämättömässä kokoelmassa, aivan kuten hashtable-objektit. Tässä olevat elementit edustavat avaimia ja niiden määrää arvoina.
• Sen avulla voit laskea kohteet iteroitavassa luettelossa.
• Aritmeettiset laskutoimitukset, kuten yhteenlasku ja osalaskutracYhdistäminen, leikkaaminen ja yhdistäminen voidaan helposti suorittaa laskurilla.
• Laskuri voi myös laskea elementtejä toiselta laskurilta

Johdatus Python Laskuri

Python Laskuri ottaa syötteeksi luettelon, monikon, sanakirjan, merkkijonon, jotka ovat kaikki iteroitavia objekteja, ja se antaa sinulle tulosteen, jossa on kunkin elementin määrä.

Syntaksi:

Counter(list)

Oletetaan, että sinulla on seuraava luettelo:

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

Listassa on elementit x , y ja z. Kun käytät tässä luettelossa laskuria, se laskee kuinka monta kertaa x , y ja z on läsnä. Jos laskuria käytetään listassa1, tulosteen pitäisi olla jotain tällaista:

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

Joten meillä on x:n määrä 4, y:n 2 ja z:n luku 2.

Käyttääksemme laskuria meidän on ensin tuotava se alla olevan esimerkin mukaisesti:

from collections import Counter

Tässä on yksinkertainen esimerkki, joka näyttää Counter-moduulin toiminnan.

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

lähtö:

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

Stringillä varustettu laskuri

In Python, kaikki on esine ja merkkijono on myös objekti. Python jono voidaan luoda yksinkertaisesti lisäämällä merkit kaksoislainausmerkkeihin. Python ei tue merkkityyppiä. Näitä käsitellään merkkijonoina, joiden pituus on yksi, ja niitä pidetään myös osamerkkijonoina.

Alla olevassa esimerkissä merkkijono välitetään laskuriin. Se palauttaa sanakirjamuodon, jossa on avain/arvo-pari, jossa avain on elementti ja arvo on määrä. Se pitää myös tilaa elementtinä ja antaa merkkijonon välilyöntien määrän.

Esimerkiksi:

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

lähtö:

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

Laskuri listalla

Lista on iteroitava objekti, jonka elementit ovat hakasulkeissa.

Listan elementit, kun ne annetaan laskuriin, muunnetaan hashtable-objekteiksi, joissa elementeistä tulee avaimia ja arvot ovat annetun luettelon elementtien lukumäärä.

Esimerkiksi ['x', 'y', 'z', 'x', 'x', 'x', 'y', 'z']. Kun annat luettelolle laskurin, se antaa sinulle luettelon jokaisen elementin määrän.

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

lähtö:

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

Laskuri sanakirjalla

Sanakirjassa on elementtejä avain/arvo-pareina, ja ne kirjoitetaan hakasulkeisiin.

Kun sanakirja on annettu laskuriin, se muunnetaan hashtable-objekteiksi, joissa elementeistä tulee avaimia ja arvot ovat annetun sanakirjan elementtien lukumäärää.

Esimerkki: {'x': 4, 'y': 2, 'z': 2, 'z': 2}. Laskuri-toiminto yrittää löytää kunkin avaimen määrän annetusta sanakirjasta.

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

lähtö:

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

Laskuri Tuplella

Tuple on kokoelma objekteja, jotka on erotettu pilkuilla hakasulkeiden sisällä. Laskuri antaa sinulle annetussa monikossa olevien elementtien määrän.

Kun monikko on annettu laskurille, se muunnetaan hashtable-objektiksi, jossa elementeistä tulee avaimia ja arvot ovat annetun monikon elementtien määrä.

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

lähtö:

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

Laskurien käyttäminen, alustaminen ja päivittäminen

Laskuria alustetaan

Laskuri voidaan alustaa välittämällä merkkijonoarvo, luettelo, sanakirja tai monikko alla olevan kuvan mukaisesti:

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

Voit myös alustaa tyhjän laskurin alla olevan kuvan mukaisesti:

from collections import Counter
_count = Counter()

Päivitetään laskuria

Voit lisätä arvoja laskuriin käyttämällä update()-menetelmää.

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

Lopullinen koodi on:

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

Tuotos on:

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

Laskuriin pääsy

Voit saada arvot laskurista seuraavasti:

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

lähtö:

u : 3

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

Elementin poistaminen laskurista

Voit poistaa elementin Counterista käyttämällä del -toimintoa alla olevan esimerkin mukaisesti:

Esimerkiksi:

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

lähtö:

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

Aritmeettinen operaatio päällä Python Laskuri

Aritmeettiset operaatiot, kuten yhteenlasku, osalaskutraction, leikkauspisteen ja yhdisteen voi tehdä laskurilla alla olevan esimerkin mukaisesti:

Esimerkiksi:

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)

lähtö:

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

Käytettävissä olevat menetelmät Python Laskuri

Counterilla on saatavilla joitakin tärkeitä menetelmiä, tässä on luettelo samoista:

• elementit () : Tämä menetelmä palauttaa sinulle kaikki elementit, joiden lukumäärä on >0. Elementtejä, joiden määrä on 0 tai -1, ei palauteta.
• useimmat_common(arvo): Tämä menetelmä palauttaa yleisimmät elementit laskuriluettelosta.
• allatract(): Tätä menetelmää käytetään elementtien vähentämiseen toisesta laskurista.
• päivittää(): Tätä menetelmää käytetään elementtien päivittämiseen toisesta laskurista.

Esimerkki: elementit()

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)

lähtö:

x
x
x
x
x
y
y

Esimerkki: useimmat_common(arvo)

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)

lähtö:

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

Esimerkki: alaryhmätract()

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)

lähtö:

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

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

lähtö:

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

Määrää uudelleen Python

Voit määrittää laskurien määrän uudelleen alla olevan kuvan mukaisesti:

Oletetaan, että sinulla on sanakirja muodossa : {'x': 5, 'y': 12, 'z': -2, 'x1':0}

Voit muuttaa elementin määrää alla olevan kuvan mukaisesti:

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

counter1['y'] = 20

print(counter1)

lähtö: Suorituksen jälkeen näet, että y-luku on muutettu 12:sta 20:een

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

Hanki ja aseta elementtien määrä laskurin avulla

Voit saada elementin määrän laskurin avulla seuraavasti:

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'

lähtö:

12

Voit asettaa elementin määrän seuraavasti:

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)

lähtö:

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

Yhteenveto

• Laskuri on säiliö, joka sisältää jokaisen säiliössä olevien elementtien määrän.
• Counter on alaluokka, joka on saatavilla sanakirjaluokan sisällä.
• Käyttäen Python Laskurityökalulla voit laskea objektin avainarvo-parit, jota kutsutaan myös hashtable-objektiksi.
• Laskuri säilyttää tiedot järjestämättömässä kokoelmassa, aivan kuten hashtable-objektit. Tässä olevat elementit edustavat avaimia ja niiden määrää arvoina.
• Sen avulla voit laskea kohteet iteroitavassa luettelossa.
• Aritmeettiset laskutoimitukset, kuten yhteenlasku ja osalaskutracYhdistäminen, leikkaaminen ja yhdistäminen voidaan helposti suorittaa laskurilla.
• Laskuri voi myös laskea elementtejä toiselta laskurilta.
• Counterissa käytettävissä olevat tärkeät metodit ovat elements(), most_common(value), subtract() ja päivitä().
• Laskuria voidaan käyttää merkkijonossa, luettelossa, sanakirjassa ja monissa.