Compter le nombre de mots-clés dans un dictionnaire en python

234

J'ai une liste de mots dans un dictionnaire avec la valeur = la répétition du mot-clé mais je veux seulement une liste de mots distincts donc je voulais compter le nombre de mots-clés. Existe-t-il un moyen de compter le nombre de mots clés ou existe-t-il une autre façon de rechercher des mots distincts?

— Dan
source

410

len(yourdict.keys())

ou juste

len(yourdict)

Si vous aimez compter des mots uniques dans le fichier, vous pouvez simplement utiliser setet faire comme

len(set(open(yourdictfile).read().split()))

— TU
source

4

Je sais que ce post est ancien, mais j'étais curieux. Est-ce la méthode la plus rapide? Ou: est-ce une méthode assez rapide pour les grands dictionnaires?

— theJollySin

2

Les deux len(yourdict.keys())et len(yourdict)sont O (1). Ce dernier est légèrement plus rapide. Voir mes tests ci-dessous.

— Chih-Hsuan Yen

5

Je voudrais noter que vous pouvez également opter pour les valeurs (je sais que la question ne l'a pas posée) aveclen(yourdict.values())

— ntk4

29

Le nombre de mots distincts (c'est-à-dire le nombre d'entrées dans le dictionnaire) peut être trouvé en utilisant la len()fonction.

> a = {'foo':42, 'bar':69}
> len(a)
2

Pour obtenir tous les mots distincts (c'est-à-dire les clés), utilisez la .keys()méthode.

> list(a.keys())
['foo', 'bar']

— kennytm
source

5

Appeler len()directement sur votre dictionnaire fonctionne et est plus rapide que de construire un itérateur d.keys()et de l'appeler len(), mais la vitesse de l'un ou l'autre sera négligeable par rapport à tout ce que fait votre programme.

d = {x: x**2 for x in range(1000)}

len(d)
# 1000

len(d.keys())
# 1000

%timeit len(d)
# 41.9 ns ± 0.244 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

%timeit len(d.keys())
# 83.3 ns ± 0.41 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

— UnderwaterKremlin
source

2

Si la question concerne le comptage du nombre de mots clés, je recommanderais quelque chose comme

def countoccurrences(store, value):
    try:
        store[value] = store[value] + 1
    except KeyError as e:
        store[value] = 1
    return

dans la fonction principale ont quelque chose qui boucle dans les données et transmet les valeurs à la fonction countoccurrences

if __name__ == "__main__":
    store = {}
    list = ('a', 'a', 'b', 'c', 'c')
    for data in list:
        countoccurrences(store, data)
    for k, v in store.iteritems():
        print "Key " + k + " has occurred "  + str(v) + " times"

Les sorties de code

Key a has occurred 2 times
Key c has occurred 2 times
Key b has occurred 1 times

— David
source

2

Les conventions de dénomination PEP 8 dictent que cela countoccurrences()devrait être le cas count_occurrences(). En outre, si vous importez collections.Counter, il y a une meilleure façon de le faire: from collections import Counter; store = Counter(); for data in list: store[list] += 1.

— Graham

0

Certaines modifications ont été apportées à la réponse publiée UnderWaterKremlin pour la rendre compatible avec Python3. Un résultat surprenant ci-dessous comme réponse.

Spécifications du système:

python = 3.7.4,
conda = 4.8.0
3,6 GHz, 8 cœurs, 16 Go.

import timeit

d = {x: x**2 for x in range(1000)}
#print (d)
print (len(d))
# 1000

print (len(d.keys()))
# 1000

print (timeit.timeit('len({x: x**2 for x in range(1000)})', number=100000))        # 1

print (timeit.timeit('len({x: x**2 for x in range(1000)}.keys())', number=100000)) # 2

Résultat:

1) = 37,0100378

2) = 37,002148899999995

Il semble donc que ce len(d.keys())soit actuellement plus rapide que la simple utilisation len().

— ZF007
source