Hur man använder Pythons räknare från samlingsmodulen

I den här handledningen kommer du att lära dig hur du använder motobjektet från Pythons samlingsmodul.

När du arbetar med långa sekvenser i Python, till exempel Python-listor eller strängar, kan du ibland behöva lagra objekten som visas i sekvensen och hur många gånger de visas.

En Python-ordbok är en lämplig inbyggd datastruktur för sådana applikationer. Däremot kan Pythons Counter-klass från samlingsmodulen förenkla detta – genom att konstruera en räknare – som är en ordbok över objekt och deras antal i sekvensen.

Under de kommande minuterna kommer du att lära dig följande:

Använd Pythons motobjekt
Skapa en Python-ordbok för att lagra räkningsvärden för objekt i en iterabel
Skriv om ordboken med Pythons räknare med en förenklad syntax
Utför operationer som att uppdatera och subtrahera element, hitta skärningspunkten mellan två räknarobjekt
Få de vanligaste objekten i disken med metoden most_common()

Låt oss börja!

Innehållsförteckning

Python Collections Modul och Counter Class

Du kommer ofta att använda en Python-ordbok för att lagra objekten och deras antal i en iterabel. Föremålen och antalet lagras som nycklar respektive värden.

Eftersom Counter-klassen är en del av Pythons inbyggda samlingsmodul kan du importera den i ditt Python-skript så här:

from collections import Counter

Efter att ha importerat Counter-klassen som nämnts kan du instansiera ett räknarobjekt enligt bilden:

<counter_object> = Counter(iterable)

Här:

iterable är vilken som helst giltig Python iterabel som Python-lista, sträng eller tupel.
Objekten i iterablen ska vara hashbara.

Nu när vi vet hur man använder Counter för att skapa räknarobjekt från vilken Python som helst, låt oss börja koda.

Exemplen som används i denna handledning finns i denna GitHub-uppgift.

Hur man skapar ett motobjekt från Python Iterables

Låt oss skapa en Python-sträng, säg ”renässans” och kalla det ord.

>>> word = "renaissance"

Vårt mål är att skapa en ordbok där varje bokstav i ordsträngen mappas till antalet gånger den förekommer i strängen. Ett tillvägagångssätt är att använda för loopar som visas:

>>> 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 analysera vad kodavsnittet ovan gör:

Initierar letter_count till en tom Python-ordbok.
Slingor genom ordsträngen.
Kontrollerar om bokstav finns i ordboken letter_count.
Om bokstaven inte finns lägger den till den med värdet 0 och ökar sedan värdet med 1.
För varje förekomst av bokstav i ord, ökas värdet som motsvarar bokstaven med 1.
Detta fortsätter tills vi loopar igenom hela strängen.

Vi konstruerade ordboken letter_count – på egen hand – med hjälp av för loop till loop genom strängordet.

Låt oss nu använda Counter-klassen från samlingsmodulen. Vi behöver bara skicka in ordsträngen till Counter() för att få letter_count utan att behöva gå igenom 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})

Räknarobjektet är också en Python-ordbok. Vi kan använda den inbyggda isinstance()-funktionen för att verifiera detta:

>>> isinstance(letter_count,dict)
True

Som sett returnerar isinstance(letter_count, dict) True vilket indikerar att räknarobjektet letter_count är en instans av Python dict-klassen.

Modifiera motobjektet

Hittills har vi lärt oss att skapa motobjekt från Python-strängar.

Du kan också modifiera motobjekt genom att uppdatera dem med element från en annan iterabel eller subtrahera en annan iterabel från dem.

Uppdatera en räknare med element från Another Iterable

Låt oss initiera en annan sträng another_word:

>>> another_word = "effervescence"

Anta att vi skulle vilja uppdatera räknarobjektet letter_count med objekten från another_word-strängen.

Vi kan använda metoden update() på räknarobjektet 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 utgången ser vi att räknarobjektet har uppdaterats för att även inkludera bokstäverna och deras antal förekomster från another_word.

Subtrahera element från en annan iterabel

Låt oss nu subtrahera värdet av another_word från objektet letter_count. För att göra det kan vi använda subtract()-metoden. Att använda .subtract() subtraherar värdena som motsvarar objekt i från .

Låt oss subtrahera ett annat_ord från bokstavsantal.

>>> 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 värdena som motsvarar bokstäverna i ett annat_ord har subtraherats, men de tillagda nycklarna ’f’ och ’v’ tas inte bort. De mappar nu till värdet 0.

Notera: Här har vi skickat in another_word, en Python-sträng, till subtract() metodanropet. Vi kan också skicka in ett Python-räkneobjekt eller något annat iterabelt.

Skärning mellan två motobjekt i Python

Du kanske ibland vill hitta skärningspunkten mellan två Python-räkneobjekt för att identifiera vilka nycklar som är gemensamma mellan de två.

Låt oss skapa ett motobjekt, säg, letter_count_2, från another_word-strängen ’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 simple & för att hitta skärningspunkten mellan bokstav_antal och bokstav_antal_2.

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

Lägg märke till hur du får nycklarna och antalet förekomster som är gemensamma för de två orden. Både ’renässans’ och ’brusande’ innehåller två förekomster av ’e’ och en förekomst vardera av ’r’, ’n’, ’s’ och ’c’ gemensamt.

Hitta de vanligaste objekten med most_common

En annan vanlig operation på Python-räkneobjektet ä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å räknarobjektet. 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 ’renässans’.

Detta är särskilt användbart om räknaren innehåller ett stort antal poster och du är intresserad av att arbeta med de vanligaste nycklarna.

Slutsats

Här är en snabb genomgång av vad vi har lärt oss i handledningen:

Klassen Counter från Pythons inbyggda samlingsmodul kan användas för att få en ordbok med räknevärden för alla objekt i valfri iterabel. Du bör se till att alla objekt i iterablen är hashbara.
Du kan uppdatera innehållet i ett Python-räkneobjekt med innehåll från ett annat räknarobjekt eller något annat iterbart med metoden update() med syntaxen: counter1.update(counter2). Observera att du kan använda vilken iterabel som helst i stället för räknare2.
Om du vill ta bort innehållet i en av de iterbara från den uppdaterade räknaren kan du använda subtract()-metoden: counter1.subtract(counter2).
För att hitta de gemensamma elementen mellan två räknarobjekt kan du använda operatorn &. Givet två räknare räknare1 och räknare2, returnerar räknare1 och räknare2 skärningspunkten mellan dessa två räknareobjekt.
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 respektive antal.

Lär dig sedan hur du använder standard dict, en annan klass i samlingsmodulen. Du kan använda standarddikt istället för en vanlig Python-ordbok för att hantera saknade nycklar.