Utforsk bruken av Counter-objektet i Python
I denne veiledningen skal vi fordype oss i hvordan du kan utnytte tellerobjektet fra Pythons samlingsmodul. Dette verktøyet er spesielt nyttig når du arbeider med lange sekvenser som lister eller strenger, der du trenger å spore forekomstene av hvert element.
Selv om en Python-ordbok kan tjene dette formålet, tilbyr `Counter`-klassen en mer strømlinjeformet tilnærming. Den fungerer som en spesialtilpasset ordbok som teller forekomstene av hvert element i en gitt sekvens.
I løpet av de kommende minuttene vil du lære:
- Hvordan manipulere Python-tellerobjekter.
- Hvordan konstruere en ordbok som lagrer forekomster av elementer i en iterabel.
- Hvordan forenkle opprettelsen av en slik ordbok ved hjelp av `Counter`-klassen.
- Hvordan utføre operasjoner som oppdatering, subtraksjon og finne felles elementer i tellerobjekter.
- Hvordan hente de mest frekvente elementene i en teller ved hjelp av `most_common()`-metoden.
La oss begynne!
Python Samlingsmodul og `Counter`-klassen
Ofte vil du opprette en ordbok for å lagre elementer og deres tilhørende antall forekomster. I en slik ordbok fungerer elementene som nøkler, og antall forekomster som verdier.
Siden `Counter`-klassen er en del av Pythons samlingsmodul, kan du importere den slik:
from collections import Counter
Etter import kan du opprette et tellerobjekt som følger:
<teller_objekt> = Counter(itererbar)
Hvor:
- `itererbar` er en hvilken som helst gyldig Python-itererbar, som en liste, streng eller tuppel.
- Elementene i den itererbare må være hashbare.
Nå som vi har et grunnleggende grep om hvordan vi bruker `Counter`, la oss utforske noen praktiske eksempler. Alle kodene som brukes i denne opplæringen finnes i denne GitHub-repositoriet.
Hvordan generere et tellerobjekt fra Python Iterables
La oss begynne med å definere en Python-streng, for eksempel «eksempel», og kalle den `ord`.
>>> ord = "eksempel"
Vårt mål er å lage en ordbok hvor hver bokstav i `ord` er kartlagt til antall ganger den forekommer. En tilnærming er å bruke en `for`-løkke som vist:
>>> bokstav_antall = {}
>>> for bokstav in ord:
... if bokstav not in bokstav_antall:
... bokstav_antall[bokstav] = 0
... bokstav_antall[bokstav] += 1
...
>>> bokstav_antall
{'e': 3, 'k': 1, 's': 1, 'm': 1, 'p': 1, 'l': 1}
La oss analysere denne kodebiten:
- Vi initialiserer `bokstav_antall` som en tom ordbok.
- Vi går gjennom hver bokstav i strengen `ord`.
- For hver bokstav sjekker vi om den finnes i ordboken.
- Hvis bokstaven ikke finnes, legges den til med verdien 0, deretter økes verdien med 1.
- Dette fortsetter til vi har iterert gjennom hele strengen.
Vi har manuelt opprettet `bokstav_antall`-ordboken ved å bruke en `for`-løkke. La oss nå bruke `Counter`-klassen. Vi trenger bare å sende `ord`-strengen til `Counter()` for å få den samme `bokstav_antall`:
>>> from collections import Counter
>>> bokstav_antall = Counter(ord)
>>> bokstav_antall
Counter({'e': 3, 'k': 1, 's': 1, 'm': 1, 'p': 1, 'l': 1})
`Counter`-objektet er også en Python-ordbok. Vi kan bekrefte dette ved hjelp av `isinstance()`-funksjonen:
>>> isinstance(bokstav_antall,dict) True
`isinstance(bokstav_antall, dict)` returnerer `True`, som bekrefter at tellerobjektet `bokstav_antall` er en forekomst av Python `dict`-klassen.
Endring av tellerobjektet
Vi har nå lært å lage tellerobjekter fra Python-strenger. Det er også mulig å endre tellerobjekter ved å oppdatere dem med elementer fra andre itererbare eller trekke fra dem.
Oppdatere en teller med elementer fra en annen itererbar
La oss initialisere en annen streng, `annet_ord`:
>>> annet_ord = "prøve"
Anta at vi ønsker å oppdatere tellerobjektet `bokstav_antall` med elementene fra `annet_ord`-strengen. Vi kan oppnå dette ved hjelp av `update()`-metoden:
>>> bokstav_antall.update(annet_ord)
>>> bokstav_antall
Counter({'e': 4, 'p': 2, 'k': 1, 's': 1, 'm': 1, 'l': 1, 'r': 1, 'ø': 1, 'v': 1})
Vi ser at tellerobjektet nå inkluderer bokstavene fra `annet_ord` og deres tilhørende antall.
Trekke fra elementer fra en annen itererbar
La oss nå trekke verdien av `annet_ord` fra `bokstav_antall`. For å gjøre dette, bruker vi `subtract()`-metoden. `<teller-objekt>.subtract(<en-itererbar>)` trekker verdiene av elementene i `<en-itererbar>` fra `<teller-objekt>`.
>>> bokstav_antall.subtract(annet_ord)
>>> bokstav_antall
Counter({'e': 3, 'k': 1, 's': 1, 'm': 1, 'l': 1, 'p': 0, 'r': 0, 'ø': 0, 'v': 0})
Vi ser at antall forekomster for bokstavene i `annet_ord` har blitt trukket fra. Nøkler som bare var i `annet_ord` har fått verdien 0, men er ikke fjernet.
Merk: Vi kan bruke andre itererbare, som et annet `Counter`-objekt, som argument til `subtract()`.
Felles elementer mellom to tellerobjekter
Noen ganger kan det være nyttig å finne felleselementene mellom to tellerobjekter for å identifisere overlappende nøkler.
La oss lage et tellerobjekt, for eksempel `bokstav_antall_2`, fra strengen `annet_ord`.
>>> annet_ord = "prøve"
>>> bokstav_antall_2 = Counter(annet_ord)
>>> bokstav_antall_2
Counter({'p': 1, 'r': 1, 'ø': 1, 'v': 1, 'e': 1})
Vi kan bruke `&`-operatoren for å finne felleselementene mellom `bokstav_antall` og `bokstav_antall_2`:
>>> bokstav_antall & bokstav_antall_2
Counter({'e': 1})
Vi har hentet de felles nøklene og antall forekomster. Både «eksempel» og «prøve» inneholder en forekomst av bokstaven «e».
Finne de mest frekvente elementene med `most_common`
En annen vanlig operasjon er å finne elementene med flest forekomster. Dette kan gjøres ved hjelp av `most_common()`-metoden:
For å finne de k mest frekvente elementene i en teller kan du bruke `most_common(k)`. I dette eksemplet finner vi de tre mest vanlige bokstavene i `bokstav_antall`:
>>> bokstav_antall.most_common(3)
[('e', 3), ('k', 1), ('s', 1)]
Vi ser at «e» forekommer tre ganger, mens «k» og «s» forekommer en gang hver.
Dette er spesielt nyttig når du har en stor samling og kun er interessert i de vanligste elementene.
Konklusjon
La oss oppsummere hva vi har lært:
- `Counter`-klassen fra Pythons `collections`-modul gir deg en ordbok med tellinger for elementer i en hvilken som helst itererbar.
- Du kan oppdatere innholdet i et `Counter`-objekt ved hjelp av `update()`-metoden. For eksempel `teller1.update(teller2)`, hvor `teller2` kan erstattes av en hvilken som helst itererbar.
- For å trekke fra elementer, bruk `subtract()`-metoden som `teller1.subtract(teller2)`.
- For å finne felles elementer, bruk `&`-operatoren: `teller1 & teller2`.
- For å hente de k mest vanlige elementene, bruk `most_common(k)`, som gir de k vanligste elementene med deres respektive antall forekomster.
Neste skritt er å utforske bruken av `defaultdict`, en annen klasse i `collections`-modulen. `defaultdict` er et godt alternativ til vanlige Python-ordbøker når du skal håndtere manglende nøkler.