Contador Python em coleções com exemplo
O que é Python Counter?
Python Counter é um container que conterá a contagem de cada um dos elementos presentes no container. O contador é uma subclasse disponível dentro da classe do dicionário.
O contador é uma subclasse disponível dentro da classe do dicionário. Usando a ferramenta Python Counter, você pode contar os pares chave-valor em um objeto, também chamado de objeto de tabela de hash.
Por que usar o Python Counter?
Aqui estão os principais motivos para usar o Python 3 Counter:
- O Counter mantém os dados em uma coleção não ordenada, assim como os objetos hashtable. Os elementos aqui representam as chaves e a contagem como valores.
- Permite contar os itens em uma lista iterável.
- Operações aritméticas como adição, subtração, interseção e união podem ser facilmente executadas em um contador.
- Um contador também pode contar elementos de outro contador
Neste tutorial Python você aprenderá:
- O que é o contador Python?
- Por que usar o Python Counter?
- Introdução ao Python Counter
- Contador com string
- Contador com lista
- Contador com dicionário
- Contador com Tupla
- Acessar, inicializar e atualizar contadores
- Excluindo um elemento do contador
- Operação aritmética no contador Python
- Métodos disponíveis no Python Counter
- Reatribuindo contagens em Python
- Obtenha e defina a contagem de elementos usando o contador
Introdução ao Python Counter
O Python Counter recebe como entrada uma lista, tupla, dicionário, string, que são todos objetos iteráveis, e fornecerá uma saída que terá a contagem de cada elemento.
Sintaxe:
Counter(list)
Considere que você tem uma lista a seguir:
list1 = ['x','y','z','x','x','x','y', 'z']
A lista tem os elementos x , y e z. Quando você usa Counter nesta lista , ele contará quantas vezes x , yez está presente. A saída se o contador for usado na lista1 deve ser algo como:
Counter({'x': 4, 'y': 2, 'z': 2})
Então temos a contagem de x como 4, y como 2 e z como 2.
Para fazer uso do Counter, 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 Counter.
from collections import Counter list1 = ['x','y','z','x','x','x','y', 'z'] print(Counter(list1))
Resultado:
Counter({'x': 4, 'y': 2, 'z': 2})
Contador com String
Em Python, tudo é um objeto e string também é um objeto. A string Python pode ser criada simplesmente colocando caracteres entre aspas duplas. Python não suporta um tipo de caractere. Elas são tratadas como strings de comprimento um, também consideradas como substring.
No exemplo abaixo, uma string é passada para Counter. Retorna o formato de dicionário, com par chave/valor onde 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 Counter my_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 tem seus elementos entre colchetes.
Os elementos da lista quando fornecidos ao Counter serão convertidos em objetos hashtable onde 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']. Uma vez que você der o contador à lista, ele lhe dará a contagem de cada elemento na lista.
from collections import Counter list1 = ['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 tem elementos como um par chave/valor, e eles são escritos entre colchetes.
Uma vez que o dicionário é dado ao Counter, 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 dado.
Por exemplo:{'x':4, 'y':2, 'z':2, 'z':2}. A função Counter tentará encontrar a contagem de cada chave no dicionário fornecido.
from collections import Counter
dict1 = {'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 dentro de colchetes. Counter lhe dará a contagem de cada um dos elementos na tupla dada.
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 Counter
tuple1 = ('x','y','z','x','x','x','y','z')
print(Counter(tuple1))
Resultado:
Counter({'x': 4, 'y': 2, 'z': 2})
Acessar, inicializar e atualizar contadores
Inicializando o contador
Um contador pode ser inicializado passando valor de string, lista, dicionário ou tupla conforme mostrado abaixo:
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
Você também pode inicializar um contador vazio conforme mostrado abaixo:
from collections import Counter _count = Counter()
Atualizando o contador
Você pode adicionar valores ao Counter 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)
A saída é:
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 : 3 G : 1 u : 3 r : 2 u : 3
Excluindo um elemento do contador
Para deletar um elemento do Counter você pode usar del , como mostra o exemplo abaixo:
Exemplo:
from collections import Counter
dict1 = {'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 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)
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 Python Counter
Existem alguns métodos importantes disponíveis com o Counter, aqui está a lista deles:
- elementos() :Este método retornará todos os elementos com contagem> 0. Elementos com contagem 0 ou -1 não serão retornados.
- most_common(valor): Este método retornará os elementos mais comuns da lista Counter.
- subtrair(): Este método é usado para deduzir os elementos de outro contador.
- atualizar(): Este método é usado para atualizar os elementos de outro contador.
Exemplo:elementos()
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)
Resultado:
x x x x x y y
Exemplo:most_common(valor)
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)
Resultado:
[('y', 12), ('x', 5)]
[('y', 12), ('x', 5), ('x1', 0), ('z', -2)]
Exemplo:subtrair()
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)
Resultado:
Counter({'y': 7, 'x': 3, 'x1': 0, 'z': -2})
Exemplo:atualizar()
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)
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 Counter
counter1 = Counter({'x': 5, 'y': 12, 'z': -2, 'x1':0})
counter1['y'] = 20
print(counter1)
Saída:Após a execução, você verá que a contagem 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 Counter você pode fazer o seguinte:
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'
Resultado:
12
Para definir a contagem do elemento, você pode fazer o seguinte:
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)
Resultado:
12
Counter({'y': 20, 'y1': 10, 'x': 5, 'x1': 0, 'z': -2})
Resumo:
- Counter é um contêiner que conterá a contagem de cada um dos elementos presentes no contêiner.
- Counter é uma subclasse disponível dentro da classe do dicionário.
- Usando a ferramenta Python Counter, você pode contar os pares chave-valor em um objeto, também chamado de objeto hashtable.
- O Counter mantém os dados em uma coleção não ordenada, assim como os objetos hashtable. Os elementos aqui representam as chaves e a contagem como valores.
- Permite contar os itens em uma lista iterável.
- Operações aritméticas como adição, subtração, interseção e união podem ser facilmente executadas 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), subtrair() e update().
- Um contador pode ser usado em uma string, lista, dicionário e tupla.
python
- Função Python String strip () com EXEMPLO
- Python String count() com EXEMPLOS
- Python String format() Explique com EXEMPLOS
- Comprimento da string do Python | Exemplo do método len()
- Método Python String find() com exemplos
- Funções do Python Lambda com EXEMPLOS
- Função Python round() com EXEMPLOS
- Função Python map() com EXEMPLOS
- Python Timeit() com exemplos
- Python List count() com EXEMPLOS