Meilleure façon de tour liste de mots en fréquence dict

Quel est le meilleur moyen de convertir une liste ou un tuple dans un dictionnaire dont les clés sont les valeurs distinctes de la liste et les valeurs sont les fréquences de ces valeurs distinctes?

En d'autres termes:

['a', 'b', 'b', 'a', 'b', 'c']
--> 
{'a': 2, 'b': 3, 'c': 1}

(J'ai dû faire quelque chose comme ci-dessus de nombreuses fois, il n'y a rien dans la lib standard qui le fait pour vous?)

EDIT:

Jacob Gabrielson points là-bas est quelque chose à venir dans la lib standard pour les 2,7/3.1 branche

Peut-être définir ce que vous entendez par mieux? Plus efficace? Moins de code? Les plus faciles à comprendre?

InformationsquelleAutor | 2009-04-06

python

Genre de

from collections import defaultdict
fq= defaultdict( int )
for w in words:
    fq[w] += 1

Qui fonctionne généralement bien.

InformationsquelleAutor S.Lott

29

Je trouve que le plus facile à comprendre (bien que peut-être pas le plus efficace) est de faire:
```
{i:words.count(i) for i in set(words)}
```
- +1: j'Ai pour me faire des de que Python 3.0 sucre syntaxique.
- C'est assez chaud
- Belle Python!
- raison pour laquelle j'aime Python!
- dict interprétations ont été introduites en 2.7, 3.0 pas .
- très élégant... mais en pire (mais la vie réelle) des cas, près de coût quadratique. doit être utilisé avec précaution.
InformationsquelleAutor SilentGhost
9

Juste une remarque, en commençant avec Python 2.7/3.1, cette fonctionnalité sera intégrée dans le collections module, voir ce bug pour plus d'informations. Voici l'exemple de la notes de version:
```
>>> from collections import Counter
>>> c=Counter()
>>> for letter in 'here is a sample of english text':
...   c[letter] += 1
...
>>> c
Counter({' ': 6, 'e': 5, 's': 3, 'a': 2, 'i': 2, 'h': 2,
'l': 2, 't': 2, 'g': 1, 'f': 1, 'm': 1, 'o': 1, 'n': 1,
'p': 1, 'r': 1, 'x': 1})
>>> c['e']
5
>>> c['z']
0
```
- l'air encore plus simple, vous pouvez simplement passer la chaîne à la Contre le constructeur et il le fait pour vous
- Vous pouvez simplement faire Counter(word_list).
InformationsquelleAutor Jacob Gabrielson
2

C'est une abomination, mais:
```
from itertools import groupby
dict((k, len(list(xs))) for k, xs in groupby(sorted(items)))
```
Je ne peux pas penser à une raison de choisir cette méthode sur S. Lott, mais si quelqu'un va le montrer, il pourrait aussi bien être moi. 🙂
- points pour l'astuce
- Je dois dire que je viens de dire cela et testé pour la performance (je suis à la recherche de comptage des listes avec littéralement des millions d'objets) et pensé que ce devait être plus rapide qu'à plusieurs reprises d'obtenir/réglage de hachage-cartes... Mais il s'avère que cela prend 4x autant de temps PROCESSEUR pour mes tests, quand il a pour trier la liste, ou 2x lorsque la liste est déjà triée. Intéressant. Il est très intelligent mais.
- Si vous êtes à la manipulation des millions d'objets, vous êtes mieux à l'aide d'une sorte de toute façon (ou de déchargement de la sorte pour le moteur de données où votre entrée provient, si possible). Le sort words.txt | uniq -c de la châtaigne dans le shell est dur à battre.
InformationsquelleAutor Steven Huwig

En fait, la réponse de Compteur a déjà été mentionné, mais nous pouvons encore faire mieux (plus facile)!

from collections import Counter
my_list = ['a', 'b', 'b', 'a', 'b', 'c']
Counter(my_list)  # returns a Counter, dict-like object
>> Counter({'b': 3, 'a': 2, 'c': 1})

InformationsquelleAutor YardenR

Je dois partager intéressant mais un peu ridicule façon de faire que je suis juste venu avec:

>>> class myfreq(dict):
...     def __init__(self, arr):
...         for k in arr:
...             self[k] = 1
...     def __setitem__(self, k, v):
...         dict.__setitem__(self, k, self.get(k, 0) + v)
... 
>>> myfreq(['a', 'b', 'b', 'a', 'b', 'c'])
{'a': 2, 'c': 1, 'b': 3}

(l'auto.get(k) ou 0) peut être mieux écrit que soi.get(k, 0)

InformationsquelleAutor ʞɔıu

J'ai décidé d'aller de l'avant et de tester les versions suggéré, j'ai trouvé le collections.Counter comme suggéré par Jacob Gabrielson pour être le plus rapide, suivi par le defaultdict version par SLott.

Voici mes codes :
à partir de collections d'importation defaultdict
à partir de collections d'importation Contre

import random

# using default dict
def counter_default_dict(list):
    count=defaultdict(int)
    for i in list:
        count[i]+=1
    return count

# using normal dict
def counter_dict(list):
    count={}
    for i in list:
        count.update({i:count.get(i,0)+1})
    return count

# using count and dict
def counter_count(list):
    count={i:list.count(i) for i in set(list)}
    return count

# using count and dict
def counter_counter(list):
    count = Counter(list)
    return count

list=sorted([random.randint(0,250) for i in range(300)])


if __name__=='__main__':
    from timeit import timeit
    print("collections.Defaultdict ",timeit("counter_default_dict(list)", setup="from __main__ import counter_default_dict,list", number=1000))
    print("Dict",timeit("counter_dict(list)",setup="from __main__ import counter_dict,list",number=1000))
    print("list.count ",timeit("counter_count(list)", setup="from __main__ import counter_count,list", number=1000))
    print("collections.Counter.count "timeit("counter_counter(list)", setup="from __main__ import counter_counter,list", number=1000))

Et mes résultats:

collections.Defaultdict 
0.06787874956330614
Dict
 0.15979115872995675
list.count 
 1.199258431219126
collections.Counter.count
 0.025896202538920665

Ne laissez-moi savoir Comment je peux améliorer l'analyse.

InformationsquelleAutor user8338

0

Je pense que l'utilisation de la collection de la bibliothèque est le moyen le plus facile de l'obtenir. Mais Si vous voulez obtenir la fréquence dictionnaire sans l'utiliser ensuite c'est une autre façon,
```
l = [1,4,2,1,2,6,8,2,2]
d ={}
for i in l:
    if i in d.keys():
        d[i] = 1 + d[i]
    else:
        d[i] = 1
print (d)
```
op:
```
{1: 2, 4: 1, 2: 4, 6: 1, 8: 1}
```
InformationsquelleAutor user3832590

Vous devez vous connecter pour publier un commentaire.