O que é Python Counter?
Contador Python é um contêiner que manterá a contagem de cada um dos elementos presentes no contêiner. O contador é uma subclasse disponível dentro da classe de dicionário.
O contador é uma subclasse disponível dentro da classe de dicionário. Usando a ferramenta Python Counter, você pode contar os pares de valores-chave em um objeto, também chamado de objeto de tabela hash.
Por que usar o Python Counter?
Aqui estão os principais motivos para usar o Contador Python 3:
- O contador mantém os dados em uma coleção não ordenada, assim como os objetos hashtable. Os elementos aqui representam as chaves e contam como valores.
- Ele permite que você conte os itens em uma lista iterável.
- Operações aritméticas como adição, subtração, interseção e união podem ser facilmente realizadas em um contador.
- Um contador também pode contar elementos de outro contador
Neste tutorial Python, você aprenderá:
- O que é Python Counter?
- Por que usar o Python Counter?
- Introdução ao contador Python
- Contador com corda
- Contador com lista
- Contador com Dicionário
- Contador com Tupla
- Acessando, inicializando e atualizando contadores
- Excluindo um Elemento do Contador
- Operação aritmética no contador Python
- Métodos disponíveis no contador Python
- Reatribuindo contagens em Python
- Obtenha e defina a contagem de elementos usando o contador
Introdução ao contador Python
O Python Counter recebe como entrada uma lista, tupla, dicionário, string, que são todos objetos iteráveis, e fornecerá a saída que terá a contagem de cada elemento.
Sintaxe:
Counter(list)
Considere que você tem a seguinte lista:
list1 = ['x','y','z','x','x','x','y', 'z']
A lista possui os elementos x, y e z. Quando você usa o Contador nesta lista, ele contará quantas vezes x, y e z estão presentes. A saída se o contador for usado na lista1 deve ser algo como:
Counter({'x': 4, 'y': 2, 'z': 2})
Portanto, temos a contagem de x como 4, y como 2 e z como 2.
Para fazer uso do Contador, precisamos importá-lo primeiro, conforme mostrado no exemplo abaixo:
from collections import Counter
Aqui está um exemplo simples, que mostra o funcionamento do módulo Contador.
from collections import Counterlist1 = ['x','y','z','x','x','x','y', 'z']print(Counter(list1))
Resultado:
Counter({'x': 4, 'y': 2, 'z': 2})
Contador com corda
Em Python, tudo é um objeto e string também é um objeto. A string Python pode ser criada simplesmente colocando os caracteres entre aspas duplas. Python não oferece suporte a um tipo de caractere. Eles são tratados como strings de comprimento um, também considerados como substring.
No exemplo abaixo, uma string é passada para Counter. Ele retorna o formato de dicionário, com par chave / valor em que a chave é o elemento e o valor é a contagem. Ele também considera o espaço como um elemento e fornece a contagem de espaços na string.
Exemplo:
from collections import Countermy_str = "Welcome to Guru99 Tutorials!"print(Counter(my_str))
Resultado:
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})
Contador com lista
Uma lista é um objeto iterável que possui seus elementos entre colchetes.
Os elementos da lista quando fornecidos ao Contador serão convertidos em objetos hashtable em que os elementos se tornarão chaves e os valores serão a contagem dos elementos da lista fornecida.
Por exemplo ['x', 'y', 'z', 'x', 'x', 'x', 'y', 'z']. Depois de fornecer o Contador à lista, ele fornecerá a contagem de cada elemento da lista.
from collections import Counterlist1 = ['x','y','z','x','x','x','y','z']print(Counter(list1))
Resultado:
Counter({'x': 4, 'y': 2, 'z': 2})
Contador com Dicionário
Um dicionário possui elementos como par chave / valor e eles são escritos entre chaves.
Uma vez que o dicionário é dado ao Contador, ele será convertido em objetos hashtable onde os elementos se tornarão chaves, e os valores serão a contagem dos elementos do dicionário fornecido.
Por exemplo: {'x': 4, 'y': 2, 'z': 2, 'z': 2}. A função Contador tentará encontrar a contagem de cada uma das chaves no dicionário fornecido.
from collections import Counterdict1 = {'x': 4, 'y': 2, 'z': 2, 'z': 2}print(Counter(dict1))
Resultado:
Counter({'x': 4, 'y': 2, 'z': 2})
Contador com Tupla
Tupla é uma coleção de objetos separados por vírgulas entre colchetes. Counter dará a você a contagem de cada um dos elementos na tupla fornecida.
Uma vez que a tupla é fornecida ao Contador, ela será convertida em um objeto hashtable onde os elementos se tornarão chaves e os valores serão a contagem dos elementos da tupla fornecida.
from collections import Countertuple1 = ('x','y','z','x','x','x','y','z')print(Counter(tuple1))
Resultado:
Counter({'x': 4, 'y': 2, 'z': 2})
Acessando, inicializando e atualizando contadores
Inicializando o contador
Um contador pode ser inicializado passando um valor de string, lista, dicionário ou tupla, conforme mostrado abaixo:
from collections import Counterprint(Counter("Welcome to Guru99 Tutorials!")) #using stringprint(Counter(['x','y','z','x','x','x','y', 'z'])) #using listprint(Counter({'x': 4, 'y': 2, 'z': 2})) #using dictionaryprint(Counter(('x','y','z','x','x','x','y', 'z'))) #using tuple
Você também pode inicializar um Contador vazio conforme mostrado abaixo:
from collections import Counter_count = Counter()
Atualizando Contador
Você pode adicionar valores ao Contador usando o método update ().
_count.update('Welcome to Guru99 Tutorials!')
O código final é:
from collections import Counter_count = Counter()_count.update('Welcome to Guru99 Tutorials!')print(_count)
O resultado é:
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})
Acessando o contador
Para obter os valores do Contador, você pode fazer o seguinte:
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]))
Resultado:
u : 3G : 1u : 3r : 2u : 3
Excluindo um Elemento do Contador
Para excluir um elemento do Contador, você pode usar del, conforme mostrado no exemplo abaixo:
Exemplo:
from collections import Counterdict1 = {'x': 4, 'y': 2, 'z': 2}del dict1["x"]print(Counter(dict1))
Resultado:
Counter({'y': 2, 'z': 2})
Operação aritmética no contador Python
Operações aritméticas como adição, subtração, interseção e união podem ser feitas em um Contador, conforme mostrado no exemplo abaixo:
Exemplo:
from collections import Countercounter1 = Counter({'x': 4, 'y': 2, 'z': -2})counter2 = Counter({'x1': -12, 'y': 5, 'z':4 })#Additioncounter3 = counter1 + counter2 # only the values that are positive will be returned.print(counter3)#Subtractioncounter4 = 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 outputprint(counter4)#Intersectioncounter5 = counter1 & counter2 # it will give all common positive minimum values from counter1 and counter2print(counter5)#Unioncounter6 = counter1 | counter2 # it will give positive max values from counter1 and counter2print(counter6)
Resultado:
Counter({'y': 7, 'x': 4, 'z': 2})Counter({'x1': 12, 'x': 4})Counter({'y': 2})Counter({'y': 5, 'x': 4, 'z': 4})
Métodos disponíveis no contador Python
Existem alguns métodos importantes disponíveis com o Contador, aqui está a lista dos mesmos:
- elements () : este método retornará todos os elementos com contagem> 0. Elementos com contagem 0 ou -1 não serão retornados.
- most_common (value): Este método retornará os elementos mais comuns da lista de contadores.
- subtract (): Este método é usado para deduzir os elementos de outro Contador.
- update (): Este método é usado para atualizar os elementos de outro Contador.
Exemplo: elementos ()
from collections import Countercounter1 = Counter({'x': 5, 'y': 2, 'z': -2, 'x1':0})_elements = counter1.elements() # will give you all elements with positive value and count>0for a in _elements:print(a)
Resultado:
xxxxxyy
Exemplo: most_common (valor)
from collections import Countercounter1 = 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)
Resultado:
[('y', 12), ('x', 5)][('y', 12), ('x', 5), ('x1', 0), ('z', -2)]
Exemplo: subtract ()
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter2 = Counter({'x': 2, 'y':5})counter1.subtract(counter2)print(counter1)
Resultado:
Counter({'y': 7, 'x': 3, 'x1': 0, 'z': -2})
Exemplo: update ()
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter2 = Counter({'x': 2, 'y':5})counter1.update(counter2)print(counter1)
Resultado:
Counter({'y': 17, 'x': 7, 'x1': 0, 'z': -2})
Reatribuindo contagens em Python
Você pode reatribuir contagens de Contador conforme mostrado abaixo:
Considere que você tem um dicionário como: {'x': 5, 'y': 12, 'z': -2, 'x1': 0}
Você pode alterar a contagem do elemento conforme mostrado abaixo:
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})counter1['y'] = 20print(counter1)
Resultado: Após a execução, você verá que a contagem de y foi alterada de 12 para 20
Counter({'y': 20, 'x': 5, 'x1': 0, 'z': -2})
Obtenha e defina a contagem de elementos usando o contador
Para obter a contagem de um elemento usando o Contador, você pode fazer o seguinte:
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})print(counter1['y']) # this will give you the count of element 'y'
Resultado:
12
Para definir a contagem do elemento, você pode fazer o seguinte:
from collections import Countercounter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})print(counter1['y'])counter1['y'] = 20counter1['y1'] = 10print(counter1)
Resultado:
12Counter({'y': 20, 'y1': 10, 'x': 5, 'x1': 0, 'z': -2})
Resumo:
- Contador é um contêiner que conterá a contagem de cada um dos elementos presentes no contêiner.
- Counter é uma subclasse disponível dentro da classe de dicionário.
- Usando a ferramenta Python Counter, você pode contar os pares de valores-chave em um objeto, também chamado de objeto hashtable.
- O contador mantém os dados em uma coleção não ordenada, assim como os objetos hashtable. Os elementos aqui representam as chaves e contam como valores.
- Ele permite que você conte os itens em uma lista iterável.
- Operações aritméticas como adição, subtração, interseção e união podem ser facilmente realizadas em um contador.
- Um contador também pode contar elementos de outro contador.
- Os métodos importantes disponíveis em um Contador são elements (), most_common (value), subtract () e update ().
- Um contador pode ser usado em uma string, lista, dicionário e tupla.