Come contare la frequenza degli elementi in una lista?

Question

Ho bisogno di trovare la frequenza degli elementi in un elenco

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

uscita->

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

Inoltre voglio rimuovere i duplicati da a

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

Answer 1

Poiché l'elenco è ordinato, puoi farlo:

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

Produzione:

[4, 4, 2, 1, 2]

Answer 2

In Python 2.7 (o successivo), puoi usare 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)]

Se utilizzi Python 2.6 o versione precedente, puoi scaricarlo Qui.

Answer 3

Python 2.7+ introduce la comprensione del dizionario.Costruire il dizionario dall'elenco ti consentirà di contare e di eliminare i duplicati.

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

Per contare il numero di presenze:

from collections import defaultdict

appearances = defaultdict(int)

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

Per rimuovere i duplicati:

a = set(a) 

Answer 5

Probabilmente è meglio contare la frequenza degli elementi con un dizionario:

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

Per rimuovere i duplicati, utilizzare un set:

a = list(set(a))

Answer 6

In Python 2.7+, potresti usare collezioni.Contatore per contare gli oggetti

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

Ecco un'altra alternativa concisa utilizzando itertools.groupby che funziona anche per input non ordinato:

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

risultati

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

Answer 8

Puoi farlo:

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

Produzione:

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

Il primo array contiene valori e il secondo array è il numero di elementi con questi valori.

Quindi se vuoi ottenere solo un array con i numeri dovresti usare questo:

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

Vorrei semplicemente utilizzare scipy.stats.itemfreq nel modo seguente:

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]

puoi controllare la documentazione qui: 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

Per la tua prima domanda, ripeti l'elenco e utilizza un dizionario per tenere traccia dell'esistenza di un elemento.

Per la tua seconda domanda, usa semplicemente l'operatore set.

Answer 14

Questa risposta è più esplicita

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

Sono piuttosto in ritardo, ma funzionerà anche questo e aiuterà gli altri:

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

produrrà questo..

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. La raccolta di set non consente duplicati, passare un elenco al costruttore set() fornirà un iterabile di oggetti totalmente univoci.La funzione count() restituisce un conteggio intero quando viene passato un oggetto presente in un elenco.In questo modo vengono contati gli oggetti univoci e ciascun valore di conteggio viene memorizzato accodandolo a un output di elenco vuoto
2. Il costruttore list() viene utilizzato per convertire il set(a) in list e referenziato dalla stessa variabile a

Produzione

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]

Per rimuovere i duplicati e mantenere l'ordine:

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

Answer 18

sto usando Counter per generare una frequenza.dict da parole di file di testo in 1 riga di codice

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

Soluzione semplice utilizzando un dizionario.

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

Ancora un'altra soluzione con un altro algoritmo senza utilizzare le raccolte:

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

Puoi utilizzare la funzione integrata fornita in 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])

Il codice precedente rimuove automaticamente i duplicati in un elenco e stampa anche la frequenza di ciascun elemento nell'elenco originale e nell'elenco senza duplicati.

Due piccioni per uno scatto!XD

Answer 24

Questo approccio può essere provato se non vuoi utilizzare alcuna libreria e mantenerlo semplice e breve!

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)

operazione

[4, 4, 2, 1, 2]

Answer 25

Per la cronaca, una risposta funzionale:

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

È più pulito se conti anche gli zeri:

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

Una spiegazione:

• iniziamo con un vuoto acc elenco;
• se l'elemento successivo e Di L è inferiore alla dimensione di acc, aggiorniamo semplicemente questo elemento: v+(i==e) significa v+1 se l'indice i Di acc è l'elemento corrente e, altrimenti il ​​valore precedente v;
• se l'elemento successivo e Di L è maggiore o uguale alla dimensione di acc, dobbiamo espanderci acc per ospitare il nuovo 1.

Gli elementi non devono essere ordinati (itertools.groupby).Otterrai risultati strani se hai numeri negativi.

Answer 26

Un altro modo è utilizzare un dizionario e list.count, di seguito un modo ingenuo per farlo.

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