web-dev-qa-db-fra.com

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

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

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

sortie->

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

Aussi je veux enlever les doublons d'un

a = [1,2,3,4,5]
pythoncounterfrequencycounting
166
Bruce

Puisque la liste est ordonnée, vous pouvez faire ceci:

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

Sortie:

[4, 4, 2, 1, 2]
107
Nadia Alramli

En 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 plus ancienne, vous pouvez le télécharger ici . 

419
unutbu

Python 2.7+ introduit la compréhension du dictionnaire. La construction du dictionnaire à partir de la liste vous permettra d'obtenir le décompte et de supprimer les 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]
90
Amjith

Pour compter le nombre de comparutions:

from collections import defaultdict

appearances = defaultdict(int)

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

Pour supprimer les doublons:

a = set(a)
42
Idan K

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))
21
lindelof

Dans Python 2.7+, vous pouvez utiliser collections.Counter 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]
18
YOU

Voici une autre alternative succint utilisant itertools.groupby qui fonctionne également pour les entrées non ordonnées:

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}
7
rbento
seta = set(a)
b = [a.count(el) for el in seta]
a = list(seta) #Only if you really want it.
7
Lakshman Prasad
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'])
6
Anirban Lahiri

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)

Sortie:

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

Le premier tableau est constitué de valeurs et le deuxième tableau est constitué du nombre d'éléments contenant ces valeurs.

Donc, si vous voulez juste avoir un tableau avec les nombres, vous devriez utiliser ceci:

np.unique(a, return_counts=True)[1]
6
Evgenii Pavlov
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
4
user2422819

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

4
user2757762

Pour votre première question, parcourez la liste et utilisez un dictionnaire pour garder trace de la présence d'éléments. 

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

3
t3rse

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}
3
Corey Richey

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

produira ceci ..

Freq  [4, 4, 2, 1, 2]
number[1, 2, 3, 4, 5]
2
jax
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 de jeux n'autorise pas les doublons, le fait de passer une liste au constructeur set () donnera une liste d'objets uniques. La fonction count () renvoie un nombre entier lorsqu'un objet figurant dans une liste est transmis. Avec cela les objets uniques sont comptés et chaque valeur de comptage est stockée en ajoutant à une sortie de liste vide
  2. le constructeur list () est utilisé pour convertir l’ensemble (a) en liste et est référé par la même variable un

Sortie

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

j'utilise Counter pour générer un freq. dict de mots de fichier texte dans 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])
1
roberto
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]
1
Pradam
#!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()
0
amrutha

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

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]
0
Namrata Tolani

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 des 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 liste acc vide;
  • si l'élément suivant e de L est inférieur à la taille de acc, nous mettons simplement à jour cet élément: v+(i==e) signifie v+1 si l'index i de acc est l'élément actuel e, sinon la valeur précédente v;
  • si l'élément suivant e of L est supérieur ou égal à la taille de acc, nous devons développer acc pour héberger le nouveau 1.

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

0
jferard

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
0
Reza Abtin
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
0
AMITH M S

Solution simple en utilisant 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]))
0
oshaiken

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! X D

0
Varun Shaandhesh
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)
0
chandan anand