Python Contador em coleções com exemplo

O que é o Python Contador?

Python Contador é um contêiner que conterá a contagem de cada um dos elementos presentes no contêiner. 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 o Python Com a ferramenta Contador, você pode contar os pares de valores-chave em um objeto, também chamado de objeto de tabela hash.

Por que usar Python Contador?

Aqui estão as principais razões para usar Python 3 Contador:

• 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 a contagem como valores.
• Ele 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 realizadas em um contador.
• Um contador também pode contar elementos de outro contador

Introduction to Python Contador

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 a seguinte lista:

list1 = ['x','y','z','x','x','x','y', 'z']

A lista possui os elementos x , y e z. Quando você usa Counter 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 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))

Saída:

Counter({'x': 4, 'y': 2, 'z': 2})

Contador com String

In Python, tudo é um objeto e string também é um objeto. Python corda pode ser criado 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 uma substring.

No exemplo abaixo, uma string é passada para Counter. Retorna formato de dicionário, com par chave/valor onde a chave é o elemento e o valor é a contagem. 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))

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})

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 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']. Depois de fornecer o contador à lista, ele fornecerá a contagem de cada elemento da lista.

from collections import Counter
list1 = ['x','y','z','x','x','x','y','z']
print(Counter(list1))

Saída:

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 colchetes.

Assim que o dicionário for fornecido 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 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))

Saída:

Counter({'x': 4, 'y': 2, 'z': 2})

Contador com Tupla

Tupla é uma coleção de objetos separados por vírgulas entre colchetes. Counter fornecerá a contagem de cada um dos elementos da tupla fornecida.

Assim que a tupla for 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))

Saída:

Counter({'x': 4, 'y': 2, 'z': 2})

Acessando, Inicializando e Atualizando Contadores

Inicializando contador

Um contador pode ser inicializado passando um 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 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)

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]))

Saída:

u : 3

G : 1
u : 3
r : 2
u : 3

Excluindo um elemento do contador

Para excluir um elemento do Counter você pode usar del , conforme mostrado no exemplo abaixo:

Exemplo:

from collections import Counter
dict1 =  {'x': 4, 'y': 2, 'z': 2}
del dict1["x"]
print(Counter(dict1))

Saída:

Counter({'y': 2, 'z': 2})

Operação aritmética em Python Contador

Operações aritméticas como adição, subtração, intersecçã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)

Saída:

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 em Python Contador

Existem alguns métodos importantes disponíveis com Counter, aqui está a lista dos mesmos:

• 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 de contadores.
• 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)

Saída:

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)

Saída:

 [('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)

Saída:

Counter({'y': 7, 'x': 3, 'x1': 0, 'z': -2})

Exemplo: atualização()

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)

Saída:

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 de y mudou de 12 para 20

Counter({'y': 20, 'x': 5, 'x1': 0, 'z': -2})

Obtenha e defina a contagem de elementos usando Counter

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'

Saída:

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)

Saída:

12
Counter({'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 do dicionário.
• Com o Python Com a ferramenta Contador, 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 a contagem como valores.
• Ele 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 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.