In questo tutorial imparerai come utilizzare l’oggetto contatore dal modulo di raccolta di Python.
Quando lavori con lunghe sequenze in Python, ad esempio elenchi o stringhe Python, a volte potresti dover memorizzare gli elementi che appaiono nella sequenza e il numero di volte in cui appaiono.
Un dizionario Python è una struttura dati incorporata adatta per tali applicazioni. Tuttavia, la classe Counter di Python dal modulo collections può semplificare questo, costruendo un contatore, che è un dizionario di elementi e il loro conteggio nella sequenza.
Nei prossimi minuti imparerai quanto segue:
- Usa l’oggetto contatore di Python
- Crea un dizionario Python per archiviare i valori di conteggio degli elementi in un iterabile
- Riscrivi il dizionario usando il contatore di Python con una sintassi semplificata
- Eseguire operazioni come l’aggiornamento e la sottrazione di elementi, trovare l’intersezione tra due oggetti contatore
- Ottieni gli elementi più frequenti nel contatore utilizzando il metodo most_common()
Iniziamo!
Sommario:
Modulo delle raccolte Python e classe contatore
Utilizzerai spesso un dizionario Python per archiviare gli elementi e il loro conteggio in un iterabile. Gli elementi e il conteggio vengono archiviati rispettivamente come chiavi e valori.
Poiché la classe Counter fa parte del modulo delle collezioni integrato di Python, puoi importarla nel tuo script Python in questo modo:
from collections import Counter
Dopo aver importato la classe Counter come menzionato, puoi istanziare un oggetto contatore come mostrato:
<counter_object> = Counter(iterable)
Qui:
- iterable è qualsiasi iterabile Python valido come elenco, stringa o tupla Python.
- Gli elementi nell’iterabile dovrebbero essere hashable.
Ora che sappiamo come utilizzare Counter per creare oggetti contatore da qualsiasi iterabile Python, iniziamo a scrivere codice.
Gli esempi usati in questo tutorial possono essere trovati in questo GitHub Gist.
Come creare un oggetto contatore da Python Iterables
Creiamo una stringa Python, diciamo, “rinascimento” e chiamiamola parola.
>>> word = "renaissance"
Il nostro obiettivo è creare un dizionario in cui ogni lettera nella stringa di parole sia mappata al numero di volte che ricorre nella stringa. Un approccio consiste nell’usare i cicli for come mostrato:
>>> 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}
Analizziamo cosa fa lo snippet di codice sopra:
- Inizializza letter_count su un dizionario Python vuoto.
- Scorre la stringa di parole.
- Controlla se letter è presente nel dizionario letter_count.
- Se la lettera non è presente, la aggiunge con un valore pari a 0 e successivamente incrementa il valore di 1.
- Per ogni occorrenza di lettera in parola, il valore corrispondente a lettera viene incrementato di 1.
- Questo continua fino a quando non eseguiamo il loop dell’intera stringa.
Abbiamo costruito il dizionario letter_count, da soli, usando for loop per scorrere la parola stringa.
Ora usiamo la classe Counter dal modulo Collections. Abbiamo solo bisogno di passare la stringa di parole a Counter() per ottenere letter_count senza dover scorrere gli iterabili.
>>> 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})
L’oggetto contatore è anche un dizionario Python. Possiamo usare la funzione integrata isinstance() per verificarlo:
>>> isinstance(letter_count,dict) True
Come visto, isinstance(letter_count, dict) restituisce True indicando che l’oggetto counter letter_count è un’istanza della classe Python dict.
Modifica dell’oggetto contatore
Finora abbiamo imparato a creare oggetti contatore dalle stringhe Python.
È inoltre possibile modificare gli oggetti contatore aggiornandoli con elementi di un altro iterabile o sottraendo da essi un altro iterabile.
Aggiornamento di un contatore con elementi di un altro iterabile
Inizializziamo un’altra stringa another_word:
>>> another_word = "effervescence"
Supponiamo di voler aggiornare l’oggetto contatore letter_count con gli elementi della stringa another_word.
Possiamo usare il metodo update() sull’oggetto contatore 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})
Nell’output, vediamo che l’oggetto counter è stato aggiornato per includere anche le lettere e il loro numero di occorrenze da another_word.
Sottrarre elementi da un altro iterabile
Ora sottraiamo il valore di another_word dall’oggetto letter_count. Per fare ciò, possiamo usare il metodo subtract(). L’utilizzo di
Sottraiamo another_word da 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})
Vediamo che i valori corrispondenti alle lettere in un’altra_parola sono stati sottratti, ma le chiavi aggiunte ‘f’ e ‘v’ non sono state rimosse. Ora vengono mappati a un valore pari a 0.
Nota: qui abbiamo passato un’altra_parola, una stringa Python, alla chiamata al metodo subtract(). Possiamo anche passare un oggetto contatore Python o un altro iterabile.
Intersezione tra due oggetti contatore in Python
A volte potresti voler trovare l’intersezione tra due oggetti contatore Python per identificare quali chiavi sono comuni tra i due.
Creiamo un oggetto contatore, ad esempio letter_count_2, dalla stringa another_word ‘effervescenza’.
>>> 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})
Possiamo usare il semplice & operatore per trovare l’intersezione tra letter_count e letter_count_2.
>>> letter_count & letter_count_2
Counter({'e': 2, 'r': 1, 'n': 1, 's': 1, 'c': 1})
Nota come ottieni le chiavi e il numero di occorrenze comuni alle due parole. Sia ‘rinascita’ che ‘effervescenza’ contengono due occorrenze di ‘e’ e un’occorrenza ciascuna di ‘r’, ‘n’, ‘s’ e ‘c’ in comune.
Trova gli elementi più frequenti utilizzando most_common
Un’altra operazione comune sull’oggetto contatore Python è trovare gli elementi che si verificano più di frequente.
Per ottenere i primi k elementi più comuni nel contatore, puoi utilizzare il metodo most_common() sull’oggetto contatore. Qui chiamiamo most_common() su letter_count per trovare le tre lettere che ricorrono più di frequente.
>>> letter_count.most_common(3)
[('e', 2), ('n', 2), ('a', 2)]
Vediamo che le lettere ‘e’, ’n’ e ‘a’ ricorrono due volte nella parola ‘rinascimento’.
Ciò è particolarmente utile se il contatore contiene un gran numero di voci e sei interessato a lavorare con le chiavi più comuni.
Conclusione
Ecco una rapida rassegna di ciò che abbiamo imparato nel tutorial:
- La classe Counter del modulo delle raccolte integrato di Python può essere utilizzata per ottenere un dizionario dei valori di conteggio di tutti gli elementi in qualsiasi iterabile. Dovresti assicurarti che tutti gli elementi nell’iterabile siano hashable.
- Puoi aggiornare il contenuto di un oggetto contatore Python con il contenuto di un altro oggetto contatore o qualsiasi altro oggetto iterabile usando il metodo update() con la sintassi: counter1.update(counter2). Si noti che è possibile utilizzare qualsiasi iterabile al posto di counter2.
- Se vuoi rimuovere il contenuto di uno degli iterabili dal contatore aggiornato, puoi usare il metodo subtract(): counter1.subtract(counter2).
- Per trovare gli elementi comuni tra due oggetti contatore, puoi utilizzare l’operatore &. Dati due contatori contatore1 e contatore2, contatore1 e contatore2 restituiscono l’intersezione di questi due oggetti contatore.
- Per ottenere i k elementi più frequenti in un contatore, puoi utilizzare il metodo most_common(). counter.most_common(k) fornisce i k elementi più comuni e i rispettivi conteggi.
Successivamente, scopri come utilizzare il dict predefinito, un’altra classe nel modulo delle raccolte. Puoi usare il dict predefinito invece di un normale dizionario Python per gestire le chiavi mancanti.