I den här guiden kommer du att utforska hur man använder `Counter`-objektet från Pythons modul `collections`.
När du hanterar långa sekvenser i Python, som listor eller strängar, kan det ibland vara nödvändigt att hålla reda på vilka objekt som finns i sekvensen och hur många gånger de uppträder.
Ett Python-lexikon kan vara en användbar datastruktur för detta. Men Pythons `Counter`-klass, som finns i modulen `collections`, gör det enklare. Den skapar ett räknarobjekt – ett lexikon som lagrar objekt och deras antal i den givna sekvensen.
Under de kommande minuterna kommer du att lära dig följande:
- Hur man använder Pythons `Counter`-objekt.
- Hur man skapar ett Python-lexikon för att lagra antalet förekomster av objekt i ett itererbart objekt.
- Hur man återskapar lexikonet med Pythons `Counter`-klass, med förenklad syntax.
- Hur man utför operationer som uppdatering och subtraktion av element, samt hur man hittar gemensamma element i två `Counter`-objekt.
- Hur man hämtar de mest frekventa objekten i objektet med metoden `most_common()`.
Låt oss komma igång!
Python-modulen `collections` och `Counter`-klassen
Ofta används ett Python-lexikon för att lagra objekt och deras antal i en sekvens. Objekten lagras som nycklar och antalet som värden.
Eftersom `Counter`-klassen är en del av Pythons standardmodul `collections`, kan du importera den i ditt Python-skript så här:
from collections import Counter
Efter importen av `Counter`-klassen kan du skapa ett `Counter`-objekt enligt följande:
<counter_object> = Counter(iterable)
Här:
- `iterable` kan vara vilket giltigt Python-objekt som helst, såsom en lista, sträng eller tupel.
- Objekten i `iterable` måste vara hashbara.
Nu när vi vet hur man använder `Counter` för att skapa objekt från vilken Python-sekvens som helst, låt oss börja koda.
Exemplen som används i den här guiden finns i detta GitHub-arkiv.
Skapa ett `Counter`-objekt från Python-sekvenser
Låt oss skapa en Python-sträng, till exempel ”renässans”, och lagra den i variabeln `word`.
>>> word = "renaissance"
Vårt mål är att skapa ett lexikon där varje bokstav i strängen mappas till antalet gånger den förekommer i strängen. Ett sätt är att använda en `for`-loop, som nedan:
>>> 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}
Låt oss granska vad kodavsnittet ovan gör:
- Initierar `letter_count` till ett tomt Python-lexikon.
- Itererar genom strängen `word`.
- Kontrollerar om bokstaven finns som en nyckel i lexikonet `letter_count`.
- Om bokstaven inte finns, läggs den till med värdet 0, och sedan ökar värdet med 1.
- För varje förekomst av en bokstav i `word`, ökar värdet som motsvarar bokstaven med 1.
- Detta fortsätter tills hela strängen har itererats igenom.
Vi skapade lexikonet `letter_count` manuellt med hjälp av en `for`-loop för att iterera genom `word`.
Låt oss nu använda `Counter`-klassen från modulen `collections`. Vi behöver bara ange strängen `word` till `Counter()` för att få `letter_count` utan att manuellt iterera genom den.
>>> 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})
`Counter`-objektet är också ett Python-lexikon. Vi kan använda den inbyggda funktionen `isinstance()` för att verifiera detta:
>>> isinstance(letter_count,dict) True
Som vi ser returnerar `isinstance(letter_count, dict)` `True`, vilket indikerar att `letter_count`-objektet är en instans av Pythons `dict`-klass.
Ändra `Counter`-objektet
Hittills har vi lärt oss att skapa `Counter`-objekt från Python-strängar.
Du kan även ändra `Counter`-objekt genom att uppdatera dem med element från en annan sekvens eller subtrahera en annan sekvens från dem.
Uppdatera en räknare med element från en annan sekvens
Låt oss initialisera en annan sträng, `another_word`:
>>> another_word = "effervescence"
Antag att vi vill uppdatera `letter_count`-objektet med elementen från strängen `another_word`.
Vi kan använda metoden `update()` på `letter_count`-objektet.
>>> 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 resultatet ser vi att `Counter`-objektet har uppdaterats och nu även inkluderar bokstäverna och deras antal från `another_word`.
Subtrahera element från en annan sekvens
Låt oss nu subtrahera antalet förekomster i `another_word` från `letter_count`-objektet. För att göra det, kan vi använda metoden `subtract()`. Att använda `
Låt oss subtrahera `another_word` från `letter_count`.
>>> 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 att antalet förekomster av bokstäverna i `another_word` har subtraherats, men de tillagda nycklarna ’f’ och ’v’ tas inte bort. De har nu värdet 0.
Observera: Här skickade vi `another_word`, en Python-sträng, till anropet av `subtract()`-metoden. Vi kan också skicka in ett `Counter`-objekt eller någon annan sekvens.
Gemensamma element mellan två `Counter`-objekt i Python
Ibland kan det vara bra att hitta skärningspunkten mellan två `Counter`-objekt för att identifiera vilka nycklar som är gemensamma för båda.
Låt oss skapa ett nytt `Counter`-objekt, `letter_count_2`, från strängen `another_word` (”effervescence”).
>>> 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 använda operatorn `&` för att hitta skärningspunkten mellan `letter_count` och `letter_count_2`.
>>> letter_count & letter_count_2
Counter({'e': 2, 'r': 1, 'n': 1, 's': 1, 'c': 1})
Observera hur resultatet visar nycklarna och antalet förekomster som är gemensamma för båda orden. Både ”renaissance” och ”effervescence” har två förekomster av ’e’ och en förekomst av ’r’, ’n’, ’s’ och ’c’ gemensamt.
Hitta de mest frekventa objekten med `most_common`
En annan vanlig operation på `Counter`-objekt är att hitta de mest frekvent förekommande objekten.
För att få de *k* vanligaste objekten i räknaren, kan du använda metoden `most_common()` på `Counter`-objektet. Här kallar vi `most_common()` på `letter_count` för att hitta de tre vanligaste bokstäverna.
>>> letter_count.most_common(3)
[('e', 2), ('n', 2), ('a', 2)]
Vi ser att bokstäverna ’e’, ’n’ och ’a’ förekommer två gånger i ordet ”renaissance”.
Detta är särskilt användbart om räknaren innehåller ett stort antal poster, och du vill arbeta med de vanligaste nycklarna.
Sammanfattning
Här är en snabb genomgång av vad vi har lärt oss i den här guiden:
- `Counter`-klassen från Pythons standardmodul `collections` kan användas för att få ett lexikon med räknade värden för alla objekt i vilken sekvens som helst. Se till att alla objekt i sekvensen är hashbara.
- Du kan uppdatera innehållet i ett `Counter`-objekt med innehåll från ett annat `Counter`-objekt eller annan sekvens med metoden `update()`, med syntaxen: `counter1.update(counter2)`. Kom ihåg att du kan använda vilken sekvens som helst i stället för `counter2`.
- Om du vill ta bort innehållet i en av de iterabla från den uppdaterade räknaren kan du använda metoden `subtract()`: `counter1.subtract(counter2)`.
- För att hitta de gemensamma elementen mellan två `Counter`-objekt kan du använda operatorn `&`. Givet två räknare, `counter1` och `counter2`, returnerar `counter1 & counter2` skärningspunkten mellan dessa två räknarobjekt.
- För att få de *k* vanligaste objekten i en räknare, kan du använda metoden `most_common()`. `counter.most_common(k)` ger de *k* vanligaste objekten och deras respektive antal.
Lär dig sedan hur du använder `defaultdict`, en annan klass i modulen `collections`. Du kan använda `defaultdict` istället för ett vanligt Python-lexikon för att hantera saknade nycklar.