Python Laskuri kokoelmissa esimerkin kanssa
Logan Young
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.
- Aritmeettisia operaatioita, kuten yhteen-, vähennys-, leikkaus- ja yhdistämistoimintoja, 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
Aritmeettisia operaatioita, kuten yhteen-, vähennys-, leikkaus- ja yhdistämistoimintoja, voidaan 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.
- vähentää(): 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: 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)
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.
- Aritmeettisia operaatioita, kuten yhteen-, vähennys-, leikkaus- ja yhdistämistoimintoja, voidaan helposti suorittaa laskurilla.
- Laskuri voi myös laskea elementtejä toiselta laskurilta.
- Tärkeitä laskurin käytettävissä olevia menetelmiä ovat elements() , most_common(value), subtract() ja update().
- Laskuria voidaan käyttää merkkijonossa, luettelossa, sanakirjassa ja monissa.
