Sırasız bir listedeki öğelerin sıklığı nasıl hesaplanır?

Sıralanmamış bir listedeki öğelerin sıklığını bulmam gerekiyor

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

output->

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

Ayrıca kopyaları bir

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

Not: Kullanmadan önce listeyi sıralamanız gerekir groupby.

Sen kullanabilirsiniz groupbygelen itertoolsliste sıralı liste ise paketin.

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

Çıktı:

[4, 4, 2, 1, 2]

Python 2.7'de (veya daha yenisinde) şunları kullanabilirsiniz 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)]

Python 2.6 veya daha eski kullanıyorsanız, bunu indirebilirsiniz burada .

Python 2.7+, Sözlük Anlama'yı sunar. Sözlüğü listeden oluşturmak, sayımın yanı sıra kopyalardan kurtulmanızı sağlar.

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

Görünüş sayısını saymak için:

from collections import defaultdict

appearances = defaultdict(int)

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

Kopyaları kaldırmak için:

a = set(a) 

Python 2.7+, sen kullanabilirsiniz collections.Counter öğeleri saymak

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

Elemanların sıklığını saymak muhtemelen en iyi sözlükle yapılır:

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

Kopyaları kaldırmak için bir küme kullanın:

a = list(set(a))

itertools.groupbySırasız girdi için de çalışan başka bir kısa alternatif :

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

Sonuçlar

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

Bunu yapabilirsiniz:

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

Çıktı:

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

İlk dizi değerlerdir ve ikinci dizi bu değerlere sahip öğe sayısıdır.

Yani sadece sayılarla dizi almak istiyorsanız bunu kullanmalısınız:

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.

Ben sadece scipy.stats.itemfreq aşağıdaki şekilde kullanabilirsiniz:

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]

belgeleri buradan kontrol edebilirsiniz: http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.stats.itemfreq.html

İlk sorunuz için, listeyi tekrarlayın ve bir öğenin varlığını takip etmek için bir sözlük kullanın.

İkinci sorunuz için sadece set operatörünü kullanın.

Bu cevap daha açık

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

Oldukça geç kaldım, ama bu da işe yarayacak ve başkalarına yardımcı olacak:

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

bunu üretecek ..

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. Set koleksiyonu yinelemelere izin vermez, set () yapıcısına bir liste iletmek, tamamen benzersiz nesnelerin yinelenmesini sağlar. count () işlevi, listedeki bir nesne iletildiğinde bir tamsayı sayısı döndürür. Böylece benzersiz nesneler sayılır ve her sayım değeri boş bir liste çıktısına eklenerek saklanır
2. list () yapıcısı set (a) 'yı listeye dönüştürmek ve aynı değişken a

Çıktı

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

Bir sözlük kullanarak basit bir çözüm.

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]

Yinelenenleri kaldırmak ve siparişi korumak için:

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

Sayaç bir frekans oluşturmak için kullanıyorum. 1 satır koddaki metin dosyası kelimelerinden alıntı

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

Bunu yapmak için başka bir yaklaşım da, daha ağır ama güçlü bir kütüphane kullanarak - NLTK.

import nltk

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

Koleksiyon kullanmadan başka bir algoritmaya sahip başka bir çözüm:

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

Python'da sağlanan yerleşik işlevi kullanabilirsiniz

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

Yukarıdaki kod, bir listedeki yinelemeleri otomatik olarak kaldırır ve ayrıca orijinal listedeki her bir öğenin ve yinelemesiz listenin sıklığını yazdırır.

Bir atış için iki kuş! XD

Herhangi bir kütüphane kullanmak ve basit ve kısa tutmak istemiyorsanız bu yaklaşım denenebilir!

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]

Kayıt için işlevsel bir cevap:

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

Sıfırları da sayarsanız daha temiz:

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

Bir açıklama:

• boş bir acclisteyle başlıyoruz ;
• Bir sonraki eleman eğer ebir Lboyutundan daha düşüktür acc, biz sadece bu eleman güncelleyin: v+(i==e)araçları v+1endeksi ise ibir accakım unsurudur e, aksi önceki değeri v;
• Bir sonraki eleman eğer ebir Lbüyüktür ya büyüklüğüne eşittir acc, biz genişletmek zorunda accyeni barındırması 1.

Öğelerin sıralanması ( itertools.groupby) gerekmez . Negatif sayılarınız varsa tuhaf sonuçlar alırsınız.

Setleri kullanarak bunu yapmanın başka bir yolunu buldum.

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

Listedeki benzersiz öğeleri bulmak için

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

Sözlük kullanarak sıralanmış bir dizideki benzersiz öğelerin sayısını bulmak için

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)

Referans GeeksforGeeks

Bir başka yol da bir sözlük ve list.count, bunu yapmak için naif bir yol kullanmaktır.

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