Python Contatore nelle raccolte con esempio
Logan Young
Che cos'è la Python Contatore?
Python Il contatore è un contenitore che manterrà il conteggio di ciascuno degli elementi presenti nel contenitore. Il contatore è una sottoclasse disponibile all'interno della classe dizionario.
Il contatore è una sottoclasse disponibile all'interno della classe dizionario. Utilizzando il Python Strumento contatore, puoi contare le coppie chiave-valore in un oggetto, chiamato anche oggetto tabella hash.
Perché usare Python Contatore?
Ecco i principali motivi per l'utilizzo Python 3 Contatore:
- Il contatore conserva i dati in una raccolta non ordinata, proprio come gli oggetti hashtable. Gli elementi qui rappresentano le chiavi e il conteggio come valori.
- Ti consente di contare gli elementi in un elenco iterabile.
- Operazioni aritmetiche come addizione, sottrazione, intersezione e unione possono essere facilmente eseguite su un contatore.
- Un contatore può anche contare elementi di un altro contatore
Introduzione alla Python contatore
Python Counter accetta in input una lista, una tupla, un dizionario, una stringa, che sono tutti oggetti iterabili, e ti darà un output che avrà il conteggio di ciascun elemento.
Sintassi:
Counter(list)
Considera di avere la seguente lista:
list1 = ['x','y','z','x','x','x','y', 'z']
L'elenco ha elementi x, y e z. Quando usi Contatore in questo elenco, conterà quante volte x, y e z sono presenti. L'output se il contatore viene utilizzato su list1 dovrebbe essere qualcosa del tipo:
Counter({'x': 4, 'y': 2, 'z': 2})
Quindi abbiamo il conteggio di x come 4, y come 2 e z come 2.
Per utilizzare Counter dobbiamo prima importarlo come mostrato nell'esempio seguente:
from collections import Counter
Ecco un semplice esempio che mostra il funzionamento del modulo Counter.
from collections import Counter list1 = ['x','y','z','x','x','x','y', 'z'] print(Counter(list1))
Produzione:
Counter({'x': 4, 'y': 2, 'z': 2})
Contatore con stringa
In Python, tutto è un oggetto e anche la stringa è un oggetto. Python stringa può essere creato semplicemente racchiudendo i caratteri tra virgolette doppie. Python non supporta un tipo di carattere. Queste vengono trattate come stringhe di lunghezza uno, considerate anche come sottostringa.
Nell'esempio seguente, una stringa viene passata a Counter. Restituisce il formato dizionario, con coppia chiave/valore dove la chiave è l'elemento e il valore è il conteggio. Considera anche lo spazio come un elemento e fornisce il conteggio degli spazi nella stringa.
Esempio:
from collections import Counter my_str = "Welcome to Guru99 Tutorials!" print(Counter(my_str))
Produzione:
Counter({'o': 3, ' ': 3, 'u': 3, 'e': 2, 'l': 2, 't': 2, 'r': 2, '9': 2, 'W': 1,
'c': 1, 'm': 1, 'G': 1, 'T': 1, 'i': 1, 'a': 1, 's': 1, '!': 1})
Contatore con elenco
Un elenco è un oggetto iterabile i cui elementi sono racchiusi tra parentesi quadre.
Gli elementi nell'elenco quando forniti al contatore verranno convertiti in oggetti hashtable in cui gli elementi diventeranno chiavi e i valori saranno il conteggio degli elementi dall'elenco fornito.
Ad esempio ['x','y','z','x','x','x','y','z']. Una volta assegnato il contatore all'elenco, ti verrà fornito il conteggio di ciascun elemento nell'elenco.
from collections import Counter list1 = ['x','y','z','x','x','x','y','z'] print(Counter(list1))
Produzione:
Counter({'x': 4, 'y': 2, 'z': 2})
Contatore con dizionario
Un dizionario ha elementi come coppie chiave/valore e sono scritti tra parentesi graffe.
Una volta assegnato il dizionario al contatore, verrà convertito in oggetti hashtable in cui gli elementi diventeranno chiavi e i valori saranno il conteggio degli elementi del dizionario fornito.
Ad esempio: {'x': 4, 'y': 2, 'z': 2, 'z': 2}. La funzione Contatore proverà a trovare il conteggio di ciascuna chiave nel dizionario fornito.
from collections import Counter
dict1 = {'x': 4, 'y': 2, 'z': 2, 'z': 2}
print(Counter(dict1))
Produzione:
Counter({'x': 4, 'y': 2, 'z': 2})
Contatore con tupla
Tuple è una raccolta di oggetti separati da virgole all'interno di parentesi tonde. Counter ti darà il conteggio di ciascuno degli elementi nella tupla data.
Una volta fornita la tupla al contatore, verrà convertita in un oggetto hashtable in cui gli elementi diventeranno chiavi e i valori saranno il conteggio degli elementi della tupla fornita.
from collections import Counter
tuple1 = ('x','y','z','x','x','x','y','z')
print(Counter(tuple1))
Produzione:
Counter({'x': 4, 'y': 2, 'z': 2})
Accesso, inizializzazione e aggiornamento dei contatori
Inizializzazione del contatore
Un contatore può essere inizializzato passando un valore di stringa, un elenco, un dizionario o una tupla come mostrato di seguito:
from collections import Counter
print(Counter("Welcome to Guru99 Tutorials!")) #using string
print(Counter(['x','y','z','x','x','x','y', 'z'])) #using list
print(Counter({'x': 4, 'y': 2, 'z': 2})) #using dictionary
print(Counter(('x','y','z','x','x','x','y', 'z'))) #using tuple
Puoi anche inizializzare un contatore vuoto come mostrato di seguito:
from collections import Counter _count = Counter()
Aggiornamento contatore
È possibile aggiungere valori al contatore utilizzando il metodo update().
_count.update('Welcome to Guru99 Tutorials!')
Il codice finale è:
from collections import Counter
_count = Counter()
_count.update('Welcome to Guru99 Tutorials!')
print(_count)
L'output è:
Counter({'o': 3, ' ': 3, 'u': 3, 'e': 2, 'l': 2, 't': 2, 'r': 2, '9': 2, 'W': 1,
'c': 1, 'm': 1, 'G': 1, 'T': 1, 'i': 1, 'a': 1, 's': 1, '!': 1})
Accesso al contatore
Per ottenere i valori dal contatore, puoi procedere come segue:
from collections import Counter
_count = Counter()
_count.update('Welcome to Guru99 Tutorials!')
print('%s : %d' % ('u', _count['u']))
print('\n')
for char in 'Guru':
print('%s : %d' % (char, _count[char]))
Produzione:
u : 3 G : 1 u : 3 r : 2 u : 3
Eliminazione di un elemento dal contatore
Per eliminare un elemento da Counter puoi utilizzare del , come mostrato nell'esempio seguente:
Esempio:
from collections import Counter
dict1 = {'x': 4, 'y': 2, 'z': 2}
del dict1["x"]
print(Counter(dict1))
Produzione:
Counter({'y': 2, 'z': 2})
Operazione aritmetica su Python contatore
Le operazioni aritmetiche come addizione, sottrazione, intersezione e unione possono essere eseguite su un contatore come mostrato nell'esempio seguente:
Esempio:
from collections import Counter
counter1 = Counter({'x': 4, 'y': 2, 'z': -2})
counter2 = Counter({'x1': -12, 'y': 5, 'z':4 })
#Addition
counter3 = counter1 + counter2 # only the values that are positive will be returned.
print(counter3)
#Subtraction
counter4 = counter1 - counter2 # all -ve numbers are excluded.For example z will be z = -2-4=-6, since it is -ve value it is not shown in the output
print(counter4)
#Intersection
counter5 = counter1 & counter2 # it will give all common positive minimum values from counter1 and counter2
print(counter5)
#Union
counter6 = counter1 | counter2 # it will give positive max values from counter1 and counter2
print(counter6)
Produzione:
Counter({'y': 7, 'x': 4, 'z': 2})
Counter({'x1': 12, 'x': 4})
Counter({'y': 2})
Counter({'y': 5, 'x': 4, 'z': 4})
Metodi disponibili su Python contatore
Ci sono alcuni metodi importanti disponibili con Counter, ecco l'elenco degli stessi:
- elementi() : Questo metodo ti restituirà tutti gli elementi con conteggio >0. Gli elementi con conteggio 0 o -1 non verranno restituiti.
- più_comune(valore): Questo metodo ti restituirà gli elementi più comuni dall'elenco dei contatori.
- sottrarre(): Questo metodo viene utilizzato per detrarre gli elementi da un altro Contatore.
- aggiornamento(): Questo metodo viene utilizzato per aggiornare gli elementi da un altro contatore.
Esempio: elementi()
from collections import Counter
counter1 = Counter({'x': 5, 'y': 2, 'z': -2, 'x1':0})
_elements = counter1.elements() # will give you all elements with positive value and count>0
for a in _elements:
print(a)
Produzione:
x x x x x y y
Esempio: most_common(valore)
from collections import Counter
counter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})
common_element = counter1.most_common(2) # The dictionary will be sorted as per the most common element first followed by next.
print(common_element)
common_element1 = counter1.most_common() # if the value is not given to most_common , it will sort the dictionary and give the most common elements from the start.The last element will be the least common element.
print(common_element1)
Produzione:
[('y', 12), ('x', 5)]
[('y', 12), ('x', 5), ('x1', 0), ('z', -2)]
Esempio: sottrai()
from collections import Counter
counter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})
counter2 = Counter({'x': 2, 'y':5})
counter1.subtract(counter2)
print(counter1)
Produzione:
Counter({'y': 7, 'x': 3, 'x1': 0, 'z': -2})
Esempio: aggiorna()
from collections import Counter
counter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})
counter2 = Counter({'x': 2, 'y':5})
counter1.update(counter2)
print(counter1)
Produzione:
Counter({'y': 17, 'x': 7, 'x1': 0, 'z': -2})
Riassegnazione dei conteggi in Python
È possibile riassegnare i conteggi del Contatore come mostrato di seguito:
Considera di avere un dizionario come: {'x': 5, 'y': 12, 'z': -2, 'x1':0}
È possibile modificare il conteggio dell'elemento come mostrato di seguito:
from collections import Counter
counter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})
counter1['y'] = 20
print(counter1)
Produzione: Dopo l'esecuzione vedrai che il conteggio y è cambiato da 12 a 20
Counter({'y': 20, 'x': 5, 'x1': 0, 'z': -2})
Ottieni e imposta il conteggio degli elementi utilizzando Contatore
Per ottenere il conteggio di un elemento utilizzando Counter puoi procedere come segue:
from collections import Counter
counter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})
print(counter1['y']) # this will give you the count of element 'y'
Produzione:
12
Per impostare il conteggio dell'elemento puoi procedere come segue:
from collections import Counter
counter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})
print(counter1['y'])
counter1['y'] = 20
counter1['y1'] = 10
print(counter1)
Produzione:
12
Counter({'y': 20, 'y1': 10, 'x': 5, 'x1': 0, 'z': -2})
Sommario
- Il contatore è un contenitore che manterrà il conteggio di ciascuno degli elementi presenti nel contenitore.
- Counter è una sottoclasse disponibile all'interno della classe dizionario.
- Usando il Python Strumento contatore, puoi contare le coppie chiave-valore in un oggetto, chiamato anche oggetto tabella hash.
- Il contatore conserva i dati in una raccolta non ordinata, proprio come gli oggetti hashtable. Gli elementi qui rappresentano le chiavi e il conteggio come valori.
- Ti consente di contare gli elementi in un elenco iterabile.
- Operazioni aritmetiche come addizione, sottrazione, intersezione e unione possono essere facilmente eseguite su un contatore.
- Un contatore può anche contare elementi di un altro contatore.
- I metodi importanti disponibili su un contatore sono elements() , most_common(value), subtract() e update().
- Un contatore può essere utilizzato su una stringa, una lista, un dizionario e una tupla.
