Comment compter la fréquence des éléments dans une liste non ordonnée?

J'ai besoin de trouver la fréquence des éléments dans une liste non ordonnée

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]

sortie->

b = [4,4,2,1,2]

Je souhaite également supprimer les doublons d'un

a = [1,2,3,4,5]

Remarque: vous devez trier la liste avant de l'utiliser groupby.

Vous pouvez utiliser à groupbypartir du itertoolspackage si la liste est une liste ordonnée.

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
from itertools import groupby
[len(list(group)) for key, group in groupby(a)]

Production:

[4, 4, 2, 1, 2]

Dans Python 2.7 (ou plus récent), vous pouvez utiliser collections.Counter:

import collections
a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
counter=collections.Counter(a)
print(counter)
# Counter({1: 4, 2: 4, 3: 2, 5: 2, 4: 1})
print(counter.values())
# [4, 4, 2, 1, 2]
print(counter.keys())
# [1, 2, 3, 4, 5]
print(counter.most_common(3))
# [(1, 4), (2, 4), (3, 2)]

Si vous utilisez Python 2.6 ou une version antérieure, vous pouvez le télécharger ici .

Python 2.7+ introduit la compréhension de dictionnaire. Construire le dictionnaire à partir de la liste vous permettra d'obtenir le décompte et de vous débarrasser des doublons.

>>> a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
>>> d = {x:a.count(x) for x in a}
>>> d
{1: 4, 2: 4, 3: 2, 4: 1, 5: 2}
>>> a, b = d.keys(), d.values()
>>> a
[1, 2, 3, 4, 5]
>>> b
[4, 4, 2, 1, 2]

Pour compter le nombre d'apparitions:

from collections import defaultdict

appearances = defaultdict(int)

for curr in a:
    appearances[curr] += 1

Pour supprimer les doublons:

a = set(a) 

Dans Python 2.7+, vous pouvez utiliser des collections. Compteur pour compter les éléments

>>> a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
>>>
>>> from collections import Counter
>>> c=Counter(a)
>>>
>>> c.values()
[4, 4, 2, 1, 2]
>>>
>>> c.keys()
[1, 2, 3, 4, 5]

Il est probablement préférable de compter la fréquence des éléments avec un dictionnaire:

b = {}
for item in a:
    b[item] = b.get(item, 0) + 1

Pour supprimer les doublons, utilisez un ensemble:

a = list(set(a))

Voici une autre alternative succint utilisant itertools.groupbyqui fonctionne également pour une entrée non ordonnée:

from itertools import groupby

items = [5, 1, 1, 2, 2, 1, 1, 2, 2, 3, 4, 3, 5]

results = {value: len(list(freq)) for value, freq in groupby(sorted(items))}

résultats

{1: 4, 2: 4, 3: 2, 4: 1, 5: 2}

Tu peux le faire:

import numpy as np
a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
np.unique(a, return_counts=True)

Production:

(array([1, 2, 3, 4, 5]), array([4, 4, 2, 1, 2], dtype=int64))

Le premier tableau est des valeurs et le second tableau est le nombre d'éléments avec ces valeurs.

Donc, si vous voulez obtenir simplement un tableau avec les nombres, vous devez utiliser ceci:

np.unique(a, return_counts=True)[1]

from collections import Counter
a=["E","D","C","G","B","A","B","F","D","D","C","A","G","A","C","B","F","C","B"]

counter=Counter(a)

kk=[list(counter.keys()),list(counter.values())]

pd.DataFrame(np.array(kk).T, columns=['Letter','Count'])

seta = set(a)
b = [a.count(el) for el in seta]
a = list(seta) #Only if you really want it.

J'utiliserais simplement scipy.stats.itemfreq de la manière suivante:

from scipy.stats import itemfreq

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]

freq = itemfreq(a)

a = freq[:,0]
b = freq[:,1]

vous pouvez consulter la documentation ici: http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.stats.itemfreq.html

Pour votre première question, parcourez la liste et utilisez un dictionnaire pour garder une trace de l'existence des éléments.

Pour votre deuxième question, utilisez simplement l'opérateur set.

Cette réponse est plus explicite

a = [1,1,1,1,2,2,2,2,3,3,3,4,4]

d = {}
for item in a:
    if item in d:
        d[item] = d.get(item)+1
    else:
        d[item] = 1

for k,v in d.items():
    print(str(k)+':'+str(v))

# output
#1:4
#2:4
#3:3
#4:2

#remove dups
d = set(a)
print(d)
#{1, 2, 3, 4}

def frequencyDistribution(data):
    return {i: data.count(i) for i in data}   

print frequencyDistribution([1,2,3,4])

...

 {1: 1, 2: 1, 3: 1, 4: 1}   # originalNumber: count

Je suis assez en retard, mais cela fonctionnera aussi et aidera les autres:

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
freq_list = []
a_l = list(set(a))

for x in a_l:
    freq_list.append(a.count(x))


print 'Freq',freq_list
print 'number',a_l

va produire cela ..

Freq  [4, 4, 2, 1, 2]
number[1, 2, 3, 4, 5]

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]

# 1. Get counts and store in another list
output = []
for i in set(a):
    output.append(a.count(i))
print(output)

# 2. Remove duplicates using set constructor
a = list(set(a))
print(a)

1. La collection d'ensemble ne permet pas les doublons, passer une liste au constructeur set () donnera un itérable d'objets totalement uniques. La fonction count () renvoie un nombre entier lorsqu'un objet qui se trouve dans une liste est passé. Avec cela, les objets uniques sont comptés et chaque valeur de comptage est stockée en l'ajoutant à une sortie de liste vide
2. Le constructeur list () est utilisé pour convertir l'ensemble (a) en liste et référencé par la même variable a

Production

D:\MLrec\venv\Scripts\python.exe D:/MLrec/listgroup.py
[4, 4, 2, 1, 2]
[1, 2, 3, 4, 5]

Solution simple à l'aide d'un dictionnaire.

def frequency(l):
     d = {}
     for i in l:
        if i in d.keys():
           d[i] += 1
        else:
           d[i] = 1

     for k, v in d.iteritems():
        if v ==max (d.values()):
           return k,d.keys()

print(frequency([10,10,10,10,20,20,20,20,40,40,50,50,30]))

#!usr/bin/python
def frq(words):
    freq = {}
    for w in words:
            if w in freq:
                    freq[w] = freq.get(w)+1
            else:
                    freq[w] =1
    return freq

fp = open("poem","r")
list = fp.read()
fp.close()
input = list.split()
print input
d = frq(input)
print "frequency of input\n: "
print d
fp1 = open("output.txt","w+")
for k,v in d.items():
fp1.write(str(k)+':'+str(v)+"\n")
fp1.close()

num=[3,2,3,5,5,3,7,6,4,6,7,2]
print ('\nelements are:\t',num)
count_dict={}
for elements in num:
    count_dict[elements]=num.count(elements)
print ('\nfrequency:\t',count_dict)

from collections import OrderedDict
a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
def get_count(lists):
    dictionary = OrderedDict()
    for val in lists:
        dictionary.setdefault(val,[]).append(1)
    return [sum(val) for val in dictionary.values()]
print(get_count(a))
>>>[4, 4, 2, 1, 2]

Pour supprimer les doublons et maintenir l'ordre:

list(dict.fromkeys(get_count(a)))
>>>[4, 2, 1]

j'utilise Counter pour générer une fréquence. dicter des mots d'un fichier texte sur 1 ligne de code

def _fileIndex(fh):
''' create a dict using Counter of a
flat list of words (re.findall(re.compile(r"[a-zA-Z]+"), lines)) in (lines in file->for lines in fh)
'''
return Counter(
    [wrd.lower() for wrdList in
     [words for words in
      [re.findall(re.compile(r'[a-zA-Z]+'), lines) for lines in fh]]
     for wrd in wrdList])

Une autre approche pour ce faire, bien qu'en utilisant une bibliothèque plus lourde mais puissante - NLTK.

import nltk

fdist = nltk.FreqDist(a)
fdist.values()
fdist.most_common()

Encore une autre solution avec un autre algorithme sans utiliser de collections:

def countFreq(A):
   n=len(A)
   count=[0]*n                     # Create a new list initialized with '0'
   for i in range(n):
      count[A[i]]+= 1              # increase occurrence for value A[i]
   return [x for x in count if x]  # return non-zero count

Vous pouvez utiliser la fonction intégrée fournie en python

l.count(l[i])


  d=[]
  for i in range(len(l)):
        if l[i] not in d:
             d.append(l[i])
             print(l.count(l[i])

Le code ci-dessus supprime automatiquement les doublons dans une liste et imprime également la fréquence de chaque élément dans la liste d'origine et la liste sans doublons.

Deux oiseaux pour un coup! XD

Cette approche peut être essayée si vous ne voulez utiliser aucune bibliothèque et la garder simple et courte!

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
marked = []
b = [(a.count(i), marked.append(i))[0] for i in a if i not in marked]
print(b)

o / p

[4, 4, 2, 1, 2]

Pour mémoire, une réponse fonctionnelle:

>>> L = [1,1,1,1,2,2,2,2,3,3,4,5,5]
>>> import functools
>>> >>> functools.reduce(lambda acc, e: [v+(i==e) for i, v in enumerate(acc,1)] if e<=len(acc) else acc+[0 for _ in range(e-len(acc)-1)]+[1], L, [])
[4, 4, 2, 1, 2]

C'est plus propre si vous comptez aussi les zéros:

>>> functools.reduce(lambda acc, e: [v+(i==e) for i, v in enumerate(acc)] if e<len(acc) else acc+[0 for _ in range(e-len(acc))]+[1], L, [])
[0, 4, 4, 2, 1, 2]

Une explication:

• nous commençons avec une accliste vide ;
• si l'élément suivant ede Lest inférieur à la taille de acc, nous mettons simplement à jour cet élément: v+(i==e)signifie v+1si l'index ide accest l'élément courant e, sinon la valeur précédente v;
• si l'élément suivant ede Lest supérieur ou égal à la taille de acc, nous devons développer accpour héberger le nouveau 1.

Les éléments n'ont pas besoin d'être triés ( itertools.groupby). Vous obtiendrez des résultats étranges si vous avez des nombres négatifs.

J'ai trouvé une autre façon de procéder en utilisant des ensembles.

#ar is the list of elements
#convert ar to set to get unique elements
sock_set = set(ar)

#create dictionary of frequency of socks
sock_dict = {}

for sock in sock_set:
    sock_dict[sock] = ar.count(sock)

Pour rechercher des éléments uniques dans la liste

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
a = list(set(a))

Pour trouver le nombre d'éléments uniques dans un tableau trié à l'aide du dictionnaire

def CountFrequency(my_list): 
# Creating an empty dictionary  
freq = {} 
for item in my_list: 
    if (item in freq): 
        freq[item] += 1
    else: 
        freq[item] = 1

for key, value in freq.items(): 
    print ("% d : % d"%(key, value))

# Driver function 
if __name__ == "__main__":  
my_list =[1, 1, 1, 5, 5, 3, 1, 3, 3, 1, 4, 4, 4, 2, 2, 2, 2] 

CountFrequency(my_list)

Référence GeeksforGeeks

Une autre façon consiste à utiliser un dictionnaire et le list.count, ci-dessous une manière naïve de le faire.

dicio = dict()

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]

b = list()

c = list()

for i in a:

   if i in dicio: continue 

   else:

      dicio[i] = a.count(i)

      b.append(a.count(i))

      c.append(i)

print (b)

print (c)

a=[1,2,3,4,5,1,2,3]
b=[0,0,0,0,0,0,0]
for i in range(0,len(a)):
    b[a[i]]+=1