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

Question

Je dois 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 supprimer les doublons d'un

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

Answer 1

Depuis la liste vous 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]

Answer 2

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

Answer 3

Python 2.7+ introduit Dictionnaire Comprehension. Construire le dictionnaire de la liste vous obtiendrez le nombre ainsi que de se 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]

Answer 4

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) 

Answer 5

Counting la fréquence des éléments est probablement mieux fait 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))

Answer 6

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

Answer 7

Voici une autre alternative en utilisant succint itertools.groupby qui fonctionne aussi pour l'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}

Answer 8

Vous pouvez faire ceci:

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 sont les valeurs, et le deuxième réseau est le nombre d'éléments avec ces valeurs.

Si vous voulez obtenir tableau juste avec les chiffres que vous devez utiliser ceci:

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

Answer 9

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

Answer 10

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

Answer 11

Je voudrais simplement utiliser 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

Answer 12

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

Answer 13

Pour votre première question, itérer la liste et d'utiliser un dictionnaire pour garder la trace d'un des éléments existsence.

Pour votre deuxième question, il suffit d'utiliser l'opérateur de jeu.

Answer 14

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}

Answer 15

Je suis assez tard, mais ce sera aussi travailler, et je aider 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 ce ..

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

Answer 16

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. Set collection ne permet pas de doublons, en passant une liste au constructeur set () donnera un itérable d'objets tout à fait unique. count () renvoie un nombre entier quand un objet qui se trouve dans une liste est transmise. Avec que les objets uniques sont comptés et chaque valeur de comptage est stockée en annexant à une sortie de liste vide
2. constructeur de liste () est utilisé pour convertir l'ensemble (a) dans la liste et renvoyée par la même variable a

Sortie

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

Answer 17

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]

Answer 18

J'utilise contre pour générer un fréq. dict de mots de fichier texte en 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])

Answer 19

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

Answer 20

#!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()

Answer 21

Encore une autre solution avec un autre algorithme sans utiliser les 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

Answer 22

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)

Answer 23

Vous pouvez utiliser la fonction en construction fourni 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 affiche également la fréquence de chaque élément dans la liste d'origine et la liste sans doublons.

Deux oiseaux pour un seul coup! X D

Answer 24

Cette approche peut être essayée si vous ne voulez pas utiliser une bibliothèque et le garder simple et court!

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]

Answer 25

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]

Il est plus propre si l'on compte 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 par une liste de acc vide;
• si le prochain e élément de L est inférieure à la taille de acc, nous mettons à jour tout cet élément: v+(i==e) signifie v+1 si l'i index de acc est le e élément courant, sinon la valeur précédente v;
• si le prochain e élément de L est supérieure ou égale à la taille de acc, nous devons développer acc d'accueillir la nouvelle 1.

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

Answer 26

Une autre façon est d'utiliser un dictionnaire et list.count, au-dessous d'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)

Answer 27

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

Answer 28

str1='the cat sat on the hat hat'
list1=str1.split();
list2=str1.split();

count=0;
m=[];

for i in range(len(list1)):
    t=list1.pop(0);
    print t
    for j in range(len(list2)):
        if(t==list2[j]):
            count=count+1;
            print count
    m.append(count)
    print m
    count=0;
#print m