¿Cómo contar la frecuencia de los elementos en una lista?

Necesito encontrar la frecuencia de los elementos en una lista

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

salida->

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

También quiero eliminar los duplicados de una

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

Como la lista está ordenada puedes hacer esto:

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

Salida:

 [4, 4, 2, 1, 2] 

En Python 2.7 (o más reciente), puedes usar 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 está utilizando Python 2.6 o una versión anterior, puede descargarlo aquí .

Python 2.7+ introduce la comprensión del diccionario. Construyendo el diccionario de la lista obtendrá el recuento, así como deshacerse de los duplicados.

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

Para contar el número de apariciones:

 from collections import defaultdict appearances = defaultdict(int) for curr in a: appearances[curr] += 1 

Para eliminar duplicados:

 a = set(a) 

El conteo de la frecuencia de los elementos probablemente se hace mejor con un diccionario:

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

Para eliminar los duplicados, use un conjunto:

 a = list(set(a)) 

En Python 2.7+, puedes usar colecciones. Contador para contar artículos

 >>> 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] 
 seta = set(a) b = [a.count(el) for el in seta] a = list(seta) #Only if you really want it. 

Puedes hacerlo:

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

Salida:

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

La primera matriz es valores, y la segunda matriz es el número de elementos con estos valores.

Entonces, si quieres obtener una matriz con los números, debes usar esto:

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

Simplemente usaría scipy.stats.itemfreq de la siguiente manera:

 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] 

Puede consultar la documentación aquí: http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.stats.itemfreq.html

 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 

Para su primera pregunta, repita la lista y use un diccionario para realizar un seguimiento de la existencia de un elemento.

Para su segunda pregunta, solo use el operador del set.

Esta respuesta es más explícita.

 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} 

Llego bastante tarde, pero esto también funcionará y ayudará a otros:

 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 

producirá esto ..

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

Aquí hay otra alternativa de itertools.groupby que usa itertools.groupby que también funciona para entradas desordenadas:

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

resultados

 {1: 4, 2: 4, 3: 2, 4: 1, 5: 2} 
 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] 

Para eliminar duplicados y mantener el orden:

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

Estoy usando Contador para generar una frecuencia. dict de palabras de archivo de texto en 1 línea de código

 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]) 
 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 colección de conjuntos no permite duplicados, al pasar una lista al constructor de set () se obtendrá un iterable de objetos totalmente únicos. La función count () devuelve un conteo entero cuando se pasa un objeto que está en una lista. Con eso, los objetos únicos se cuentan y cada valor de cuenta se almacena añadiéndolos a una salida de lista vacía
  2. El constructor list () se utiliza para convertir el conjunto (a) en lista y se refiere a la misma variable a

Salida

 D:\MLrec\venv\Scripts\python.exe D:/MLrec/listgroup.py [4, 4, 2, 1, 2] [1, 2, 3, 4, 5] 
 #!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() 

Otra solución más con otro algoritmo sin usar colecciones:

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

Puedes usar la función incorporada que se proporciona 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]) 

El código anterior elimina automáticamente los duplicados en una lista y también imprime la frecuencia de cada elemento en la lista original y la lista sin duplicados.

¡Dos pájaros de un tiro! XD

Este enfoque puede intentarse si no desea utilizar ninguna biblioteca y, si lo desea, sea simple y 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) 

o / p

 [4, 4, 2, 1, 2] 
 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 

Para el registro, una respuesta funcional:

 >>> 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 más limpio si cuentas los ceros también:

 >>> functools.reduce(lambda acc, e: [v+(i==e) for i, v in enumerate(acc)] if e 

Una explicación:

  • comenzamos con una lista de acc vacía;
  • si el siguiente elemento e de L es menor que el tamaño de acc , solo actualizaremos este elemento: v+(i==e) significa v+1 si el índice i de acc es el elemento actual e , de lo contrario, el valor anterior v ;
  • Si el siguiente elemento e de L es mayor o igual al tamaño de acc , tenemos que expandir acc para alojar el nuevo 1 .

Los elementos no tienen que ser ordenados ( itertools.groupby ). Obtendrás resultados extraños si tienes números negativos.

Una forma más es usar un diccionario y la lista.cuenta, debajo de una forma ingenua de hacerlo.

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