Wie zähle ich die Häufigkeit der Elemente in einer ungeordneten Liste?

Ich muss die Häufigkeit von Elementen in einer ungeordneten Liste finden

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

Ausgabe->

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

Außerdem möchte ich die Duplikate von a entfernen

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

Hinweis: Sie sollten die Liste vor der Verwendung sortieren groupby.

Sie können groupbyaus itertoolsPaket verwenden, wenn die Liste eine geordnete Liste ist.

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

Ausgabe:

[4, 4, 2, 1, 2]

In Python 2.7 (oder neuer) können Sie Folgendes verwenden 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)]

Wenn Sie Python 2.6 oder älter verwenden, können Sie es hier herunterladen .

Python 2.7+ führt das Wörterbuchverständnis ein. Wenn Sie das Wörterbuch aus der Liste erstellen, erhalten Sie die Anzahl und können Duplikate entfernen.

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

So zählen Sie die Anzahl der Auftritte:

from collections import defaultdict

appearances = defaultdict(int)

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

So entfernen Sie Duplikate:

a = set(a) 

In Python 2.7+ können Sie Sammlungen verwenden. Zähler zum Zählen von Elementen

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

Das Zählen der Häufigkeit von Elementen erfolgt wahrscheinlich am besten mit einem Wörterbuch:

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

Verwenden Sie einen Satz, um die Duplikate zu entfernen:

a = list(set(a))

Hier ist eine weitere Alternative, itertools.groupbydie auch für ungeordnete Eingaben funktioniert:

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

Ergebnisse

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

Du kannst das:

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

Ausgabe:

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

Das erste Array ist Werte, und das zweite Array ist die Anzahl der Elemente mit diesen Werten.

Wenn Sie also nur ein Array mit den Zahlen erhalten möchten, sollten Sie Folgendes verwenden:

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.

Ich würde scipy.stats.itemfreq einfach folgendermaßen verwenden:

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]

Sie können die Dokumentation hier überprüfen: http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.stats.itemfreq.html

Wiederholen Sie bei Ihrer ersten Frage die Liste und verwenden Sie ein Wörterbuch, um das Vorhandensein von Elementen zu verfolgen.

Verwenden Sie für Ihre zweite Frage einfach den Set-Operator.

Diese Antwort ist expliziter

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

Ich bin ziemlich spät dran, aber das wird auch funktionieren und anderen helfen:

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

wird dies produzieren ..

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. Die Set-Auflistung erlaubt keine Duplikate. Wenn Sie eine Liste an den set () -Konstruktor übergeben, erhalten Sie eine Iteration von völlig eindeutigen Objekten. Die Funktion count () gibt eine Ganzzahl zurück, wenn ein Objekt in einer Liste übergeben wird. Damit werden die eindeutigen Objekte gezählt und jeder Zählwert durch Anhängen an eine leere Listenausgabe gespeichert
2. Der Konstruktor list () wird verwendet, um die Menge (a) in list umzuwandeln und von derselben Variablen a referenziert zu werden

Ausgabe

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

Einfache Lösung mit einem Wörterbuch.

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]

So entfernen Sie Duplikate und pflegen die Reihenfolge:

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

Ich benutze Counter, um eine Frequenz zu generieren. Diktieren Sie aus Textdatei-Wörtern in 1 Codezeile

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

Ein anderer Ansatz, wenn auch mit einer schwereren, aber leistungsstarken Bibliothek - NLTK.

import nltk

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

Noch eine Lösung mit einem anderen Algorithmus ohne Verwendung von Sammlungen:

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

Sie können die in Python integrierte Funktion verwenden

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

Der obige Code entfernt automatisch Duplikate in einer Liste und druckt auch die Häufigkeit jedes Elements in der ursprünglichen Liste und der Liste ohne Duplikate.

Zwei Fliegen für einen Schuss! XD

Dieser Ansatz kann ausprobiert werden, wenn Sie keine Bibliothek verwenden und diese einfach und kurz halten möchten!

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]

Für die Aufzeichnung eine funktionale Antwort:

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

Es ist sauberer, wenn Sie auch Nullen zählen:

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

Eine Erklärung:

• wir beginnen mit einer leeren accListe;
• Wenn das nächste Element evon Lkleiner als die Größe von ist acc, aktualisieren wir nur dieses Element: v+(i==e)bedeutet, v+1wenn der Index ivon accdas aktuelle Element ist e, andernfalls der vorherige Wertv ;
• Wenn das nächste Element evon Lgrößer oder gleich der Größe von ist acc, müssen wir es erweitern acc, um das neue zu hosten 1.

Die Elemente müssen nicht sortiert werden ( itertools.groupby). Sie erhalten seltsame Ergebnisse, wenn Sie negative Zahlen haben.

Ich habe einen anderen Weg gefunden, dies mit Sets zu tun.

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

So finden Sie eindeutige Elemente in der Liste

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

Ermitteln der Anzahl eindeutiger Elemente in einem sortierten Array mithilfe des Wörterbuchs

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)

Referenz GeeksforGeeks

Eine weitere Möglichkeit besteht darin, ein Wörterbuch und die Liste.count zu verwenden, unter einer naiven Möglichkeit, dies zu tun.

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