Slik bruker du Pythons teller fra samlingsmodulen

I denne opplæringen lærer du hvordan du bruker tellerobjektet fra Pythons samlingsmodul.

Når du jobber med lange sekvenser i Python, for eksempel Python-lister eller strenger, kan det hende du må lagre elementene som vises i sekvensen og antall ganger de vises.

En Python-ordbok er en passende innebygd datastruktur for slike applikasjoner. Imidlertid kan Pythons Counter-klasse fra samlingsmodulen forenkle dette – ved å konstruere en teller – som er en ordbok over gjenstander og deres telling i sekvensen.

I løpet av de neste minuttene lærer du følgende:

• Bruk Pythons tellerobjekt
• Lag en Python-ordbok for å lagre telleverdier for elementer i en iterabel
• Omskriv ordboken ved å bruke Pythons teller med en forenklet syntaks
• Utfør operasjoner som å oppdatere og trekke fra elementer, finne skjæringspunktet mellom to tellerobjekter
• Få de hyppigste elementene i telleren ved å bruke most_common()-metoden

La oss komme i gang!

Python Collections Modul og Counter Class

Du vil ofte bruke en Python-ordbok for å lagre elementene og antallet deres i en iterabel. Varene og antallet lagres som henholdsvis nøkler og verdier.

Siden Counter-klassen er en del av Pythons innebygde samlingsmodul, kan du importere den i Python-skriptet slik:

from collections import Counter

Etter å ha importert Counter-klassen som nevnt, kan du instansiere et tellerobjekt som vist:

<counter_object> = Counter(iterable)

Her:

• iterable er en hvilken som helst gyldig Python iterabel som Python-liste, streng eller tuppel.
• Elementene i iterablen skal være hashbare.

Nå som vi vet hvordan vi bruker Counter til å lage tellerobjekter fra hvilken som helst Python-iterbar, la oss begynne å kode.

Eksemplene som brukes i denne opplæringen kan bli funnet i denne GitHub-konsernet.

Hvordan lage et motobjekt fra Python Iterables

La oss lage en Python-streng, si «renessanse» og kalle det ord.

>>> word = "renaissance"

Målet vårt er å lage en ordbok der hver bokstav i ordstrengen er kartlagt til antall ganger den forekommer i strengen. En tilnærming er å bruke for løkker som vist:

>>> letter_count = {}
>>> for letter in word:
...     if letter not in letter_count:
...         letter_count[letter] = 0
...     letter_count[letter] += 1
...
>>> letter_count
{'r': 1, 'e': 2, 'n': 2, 'a': 2, 'i': 1, 's': 2, 'c': 1}

La oss analysere hva kodebiten ovenfor gjør:

• Initialiserer letter_count til en tom Python-ordbok.
• Sløyfer gjennom ordstrengen.
• Sjekker om bokstav er til stede i bokstavantall-ordboken.
• Hvis bokstaven ikke er til stede, legger den den til med en verdi på 0 og øker deretter verdien med 1.
• For hver forekomst av bokstav i ord, økes verdien som tilsvarer bokstaven med 1.
• Dette fortsetter til vi går gjennom hele strengen.

Vi konstruerte letter_count-ordboken – på egen hånd – ved å bruke for løkke til løkke gjennom strengordet.

La oss nå bruke Counter-klassen fra samlingsmodulen. Vi trenger bare å sende inn ordstrengen til Counter() for å få letter_count uten å måtte gå gjennom iterables.

>>> from collections import Counter
>>> letter_count = Counter(word)
>>> letter_count
Counter({'e': 2, 'n': 2, 'a': 2, 's': 2, 'r': 1, 'i': 1, 'c': 1})

Tellerobjektet er også en Python-ordbok. Vi kan bruke den innebygde isinstance()-funksjonen for å bekrefte dette:

>>> isinstance(letter_count,dict)
True

Som sett returnerer isinstance(letter_count, dict) True som indikerer at tellerobjektet letter_count er en forekomst av Python dict-klassen.

Modifisering av motobjektet

Så langt har vi lært å lage motobjekter fra Python-strenger.

Du kan også endre tellerobjekter ved å oppdatere dem med elementer fra en annen iterabel eller trekke fra en annen iterabel fra dem.

Oppdatering av en teller med elementer fra Another Iterable

La oss initialisere en annen streng another_word:

>>> another_word = "effervescence"

Anta at vi ønsker å oppdatere tellerobjektet letter_count med elementene fra en annen_ord-streng.

Vi kan bruke update()-metoden på tellerobjektet letter_count.

>>> letter_count.update(another_word)
>>> letter_count
Counter({'e': 7, 'n': 3, 's': 3, 'c': 3, 'r': 2, 'a': 2, 'f': 2, 'i': 1, 'v': 1})

I utgangen ser vi at tellerobjektet har blitt oppdatert til også å inkludere bokstavene og deres antall forekomster fra et annet_ord.

Å trekke elementer fra en annen iterabel

La oss nå trekke verdien av et annet_ord fra objektet bokstavantall. For å gjøre det kan vi bruke subtract()-metoden. Ved å bruke .subtract() trekkes verdiene som tilsvarer elementer i fra .

La oss trekke et annet_ord fra bokstavantall.

>>> letter_count.subtract(another_word)
>>> letter_count
Counter({'e': 2, 'n': 2, 'a': 2, 's': 2, 'r': 1, 'i': 1, 'c': 1, 'f': 0, 'v': 0})

Vi ser at verdiene som tilsvarer bokstavene i et annet_ord er trukket fra, men de adderte nøklene «f» og «v» er ikke fjernet. De kartlegger nå til en verdi på 0.

Merk: Her har vi sendt inn another_word, en Python-streng, til subtract()-metodekallet. Vi kan også sende inn et Python-tellerobjekt eller et annet iterabelt.

Kryss mellom to motobjekter i Python

Noen ganger vil du kanskje finne skjæringspunktet mellom to Python-tellerobjekter for å identifisere hvilke nøkler som er felles mellom de to.

La oss lage et telleobjekt, for eksempel bokstavantall_2, fra strengen for et annet_ord «brusing».

>>> another_word = "effervescence"
>>> letter_count_2 = Counter(another_word)
>>> letter_count_2
Counter({'e': 5, 'f': 2, 'c': 2, 'r': 1, 'v': 1, 's': 1, 'n': 1})

Vi kan bruke simple &-operatoren for å finne skjæringspunktet mellom bokstavantall og bokstavantall_2.

>>> letter_count & letter_count_2
Counter({'e': 2, 'r': 1, 'n': 1, 's': 1, 'c': 1})

Legg merke til hvordan du får nøklene og antall forekomster som er felles for de to ordene. Både «renessanse» og «brusing» inneholder to forekomster av «e», ​​og en forekomst hver av «r», «n», «s» og «c» til felles.

Finn de mest vanlige elementene ved å bruke most_common

En annen vanlig operasjon på Python-tellerobjektet er å finne de elementene som forekommer oftest.

For å få de k mest vanlige elementene i telleren, kan du bruke most_common()-metoden på tellerobjektet. Her kaller vi most_common() på letter_count for å finne de tre hyppigst forekommende bokstavene.

>>> letter_count.most_common(3)
[('e', 2), ('n', 2), ('a', 2)]

Vi ser at bokstavene «e», ​​’n» og «a» forekommer to ganger i ordet «renessanse».

Dette er spesielt nyttig hvis telleren inneholder et stort antall oppføringer og du er interessert i å jobbe med de vanligste nøklene.

Konklusjon

Her er en rask gjennomgang av hva vi har lært i opplæringen:

• Counter-klassen fra Pythons innebygde samlingsmodul kan brukes til å få en ordbok med telleverdier for alle gjenstander i enhver iterabel. Du bør sørge for at alle elementene i iterable er hashable.
• Du kan oppdatere innholdet til ett Python-tellerobjekt med innhold fra et annet telleobjekt eller et hvilket som helst annet iterabelt ved å bruke update()-metoden med syntaksen: counter1.update(counter2). Merk at du kan bruke hvilken som helst iterable i stedet for teller2.
• Hvis du vil fjerne innholdet i en av de iterablene fra den oppdaterte telleren, kan du bruke subtract()-metoden: counter1.subtract(counter2).
• For å finne felleselementene mellom to telleobjekter kan du bruke &-operatoren. Gitt to tellere teller1 og teller2, returnerer teller1 og teller2 skjæringspunktet mellom disse to telleobjektene.
• For å få de k hyppigste elementene i en teller, kan du bruke most_common()-metoden. counter.most_common(k) gir de k vanligste elementene og de respektive tellingene.

Deretter lærer du hvordan du bruker standard dict, en annen klasse i samlingsmodulen. Du kan bruke standard dikt i stedet for en vanlig Python-ordbok for å håndtere manglende nøkler.