In Python, puoi contare il numero totale di elementi in una lista o una tupla con la funzione incorporata len() e il numero di occorrenze di un elemento con il metodo count().
Inoltre, la classe Counter delle raccolte di librerie standard può essere utilizzato per contare il numero di occorrenze di ciascun elemento contemporaneamente.
In questo articolo vengono descritti i seguenti contenuti.
- Conta il numero totale di elementi:
len() - Conta il numero di occorrenze di un elemento:
count() - Come utilizzare le raccolte.Contatore
- Ottieni più elementi comuni:
most_common() - Conta elementi unici
- Contare gli elementi che soddisfano le condizioni
- Conta il numero di occorrenze di una parola in una stringa
- Conta il numero di occorrenze di un carattere in una stringa
Gli elenchi vengono utilizzati nel codice di esempio seguente, ma le tuple possono essere elaborati allo stesso modo.
Conta il numero totale di elementi:len()
Puoi contare il numero totale di elementi in un elenco con la funzione incorporata len().
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
print(len(l))
# 7
Conta il numero di occorrenze di un elemento:count()
Puoi contare il numero di occorrenze di un elemento in un elenco con il metodo count().
Se viene passato un elemento inesistente, viene restituito 0.
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
print(l.count('a'))
# 4
print(l.count('b'))
# 1
print(l.count('c'))
# 2
print(l.count('d'))
# 0
collezioni.Counter, spiegato di seguito, è utile se si desidera contare il numero di occorrenze di ciascun elemento contemporaneamente.
Come utilizzare le raccolte.Contatore
La classe Counter è fornita nelle raccolte di librerie standard.
L’oggetto contatore viene creato passando un elenco a collections.Counter().
Counter è una sottoclasse del dizionario dict, che ha elementi come chiavi ei loro conteggi come valori.
import collections
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)
print(c)
# Counter({'a': 4, 'c': 2, 'b': 1})
print(type(c))
# <class 'collections.Counter'>
print(issubclass(type(c), dict))
# True
Specificando un elemento, puoi ottenerne il conteggio. Se viene specificato un elemento inesistente, viene restituito 0.
print(c['a'])
# 4
print(c['b'])
# 1
print(c['c'])
# 2
print(c['d'])
# 0
Puoi anche usare metodi dict come keys(), values() e items().
print(c.keys())
# dict_keys(['a', 'b', 'c'])
print(c.values())
# dict_values([4, 1, 2])
print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])
Questi metodi restituiscono oggetti di tipo dict_keys, ecc. Puoi usarli così come sono se vuoi usare il ciclo for. Se vuoi convertirlo in un elenco, usa list().
Ottieni più elementi comuni:most_common()
Counter ha un metodo most_common() che riporta un elenco di tuple di (elemento, conteggio) ordinate per conteggi.
print(c.most_common())
# [('a', 4), ('c', 2), ('b', 1)]
È possibile ottenere quello con il maggior numero di occorrenze specificando l’indice come [0], quello con il più basso come [-1] e così via. Se vuoi ottenere solo gli elementi o solo il conteggio, specifica semplicemente l’indice dopo di esso.
print(c.most_common()[0])
# ('a', 4)
print(c.most_common()[-1])
# ('b', 1)
print(c.most_common()[0][0])
# a
print(c.most_common()[0][1])
# 4
Se vuoi ordinare in ordine decrescente di conteggio, usa le sezioni con l’incremento impostato su -1.
print(c.most_common()[::-1])
# [('b', 1), ('c', 2), ('a', 4)]
Se l’argomento n è specificato per il metodo most_common(), vengono restituiti solo gli n elementi con il maggior numero di occorrenze. Se viene omesso, vengono restituiti tutti gli elementi.
print(c.most_common(2))
# [('a', 4), ('c', 2)]
Se vuoi un elenco separato di elementi e il loro conteggio ordinato in base al numero di occorrenze, invece di una tupla di (elemento, conteggio), puoi fare quanto segue.
values, counts = zip(*c.most_common())
print(values)
# ('a', 'c', 'b')
print(counts)
# (4, 2, 1)
Usa la funzione incorporata zip() per trasporre un elenco 2D (in questo caso, un elenco di tuple) e decomprimerlo ed estrarlo. Vedere i seguenti articoli per i dettagli.
Conta elementi unici
Se vuoi contare elementi univoci in una lista o in una tupla, usa Counter o set().
Il numero di elementi nell’oggetto Counter è uguale al numero di elementi univoci nell’elenco originale. Può essere ottenuto con len().
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)
print(len(c))
# 3
Puoi anche usare set. Se non hai bisogno dell’oggetto Counter, è più facile usare il set.
set è un tipo di dati che non ha elementi duplicati e set() rilascia un oggetto set con valori univoci quando viene passato un elenco. Puoi ottenere il numero di elementi nel set con len().
print(set(l))
# {'a', 'c', 'b'}
print(len(set(l)))
# 3
Per ulteriori informazioni sul controllo, la rimozione e l’estrazione di elementi duplicati in un elenco, vedere gli articoli seguenti.
Contare gli elementi che soddisfano le condizioni
Per contare il numero di elementi in un elenco o tupla che soddisfano una determinata condizione, utilizzare la comprensione degli elenchi o le espressioni del generatore.
Ad esempio, conta il numero di elementi con valori negativi per l’elenco seguente.
l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
L’applicazione di un’espressione condizionale a ciascun elemento con la comprensione dell’elenco contiene un elenco i cui elementi sono di tipo bool (True, False).
Il tipo booleano bool è una sottoclasse del tipo intero int. True viene considerato come 1 e False come 0. Puoi contare il numero di True (il numero di elementi che soddisfano la condizione) per sum().
print([i < 0 for i in l])
# [True, True, True, True, True, False, False, False, False, False, False]
print(sum([i < 0 for i in l]))
# 5
Se [] nella comprensione dell’elenco viene sostituito con (), diventa un’espressione del generatore. Quando un’espressione del generatore è l’unico argomento, () può essere omesso.
print(sum((i < 0 for i in l)))
# 5
print(sum(i < 0 for i in l))
# 5
Utilizzare non se si vuole contare il numero di False (il numero di elementi che non soddisfano la condizione).
print([not (i < 0) for i in l])
# [False, False, False, False, False, True, True, True, True, True, True]
print(sum(not (i < 0) for i in l))
# 6
Ovviamente puoi modificare le condizioni.
print(sum(i >= 0 for i in l))
# 6
Alcuni altri esempi sono mostrati di seguito.
Conta il numero di elementi dispari per un elenco di numeri.
print([i % 2 == 1 for i in l])
# [True, False, True, False, True, False, True, False, True, False, True]
print(sum(i % 2 == 1 for i in l))
# 6
Esempi per un elenco di stringhe:
l = ['apple', 'orange', 'banana']
print([s.endswith('e') for s in l])
# [True, True, False]
print(sum(s.endswith('e') for s in l))
# 2
Usa collezioni.Contatore per impostare il numero di occorrenze come condizione.
Di seguito è riportato un esempio di estrazione di elementi con due o più occorrenze e conteggio del numero totale di essi. In questo esempio, ci sono quattro ae due c, quindi un totale di sei.
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)
print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])
print([i for i in l if c[i] >= 2])
# ['a', 'a', 'a', 'a', 'c', 'c']
print([i[1] for i in c.items() if i[1] >= 2])
# [4, 2]
print(sum(i[1] for i in c.items() if i[1] >= 2))
# 6
Di seguito è riportato un esempio di estrazione dei valori di elementi con due o più occorrenze e di conteggio del numero di essi. In questo esempio sono presenti due valori, ae c.
print([i[0] for i in c.items() if i[1] >= 2])
# ['a', 'c']
print([i[1] >= 2 for i in c.items()])
# [True, False, True]
print(sum(i[1] >= 2 for i in c.items()))
# 2
Conta il numero di occorrenze di una parola in una stringa
Come esempio specifico, contiamo il numero di occorrenze di parole in una stringa.
Primo, non necessario e. vengono sostituiti con una stringa vuota utilizzando il metodo replace() e rimossi. Quindi, usa il metodo split() per creare un elenco separato da spazi.
s = 'government of the people, by the people, for the people.'
s_remove = s.replace(',', '').replace('.', '')
print(s_remove)
# government of the people by the people for the people
word_list = s_remove.split()
print(word_list)
# ['government', 'of', 'the', 'people', 'by', 'the', 'people', 'for', 'the', 'people']
Se crei un elenco, puoi ottenere il numero di occorrenze, ecc. come negli esempi precedenti.
print(word_list.count('people'))
# 3
print(len(set(word_list)))
# 6
c = collections.Counter(word_list)
print(c)
# Counter({'the': 3, 'people': 3, 'government': 1, 'of': 1, 'by': 1, 'for': 1})
print(c.most_common()[0][0])
# the
Quanto sopra è un processo molto semplice, quindi per un’elaborazione del linguaggio naturale più complesso, è meglio utilizzare una libreria come NLTK.
Conta il numero di occorrenze di un carattere in una stringa
Puoi anche usare il metodo count() per le stringhe o passarlo come argomento di collections.Counter().
s = 'supercalifragilisticexpialidocious'
print(s.count('p'))
# 2
c = collections.Counter(s)
print(c)
# Counter({'i': 7, 's': 3, 'c': 3, 'a': 3, 'l': 3, 'u': 2, 'p': 2, 'e': 2, 'r': 2, 'o': 2, 'f': 1, 'g': 1, 't': 1, 'x': 1, 'd': 1})
Ottieni i primi cinque personaggi che dovrebbero essere più frequentemente.
print(c.most_common(5))
# [('i', 7), ('s', 3), ('c', 3), ('a', 3), ('l', 3)]
values, counts = zip(*c.most_common(5))
print(values)
# ('i', 's', 'c', 'a', 'l')