Python 2.7 Comptage du nombre d'éléments dans le dictionnaire avec la valeur donnée

première question ici, alors je vais aller droit au but:

à l'aide de python 2.7

J'ai un dictionnaire d'objets, les touches sont d'une coordonnée x,y représenté comme un tuple: (x,y) et toutes les valeurs sont des valeurs Booléennes.

Je suis à essayer de comprendre un rapide et propre méthode pour obtenir un compte de la façon dont de nombreux éléments ont une valeur donnée. Je n'ai PAS besoin de savoir quelles sont les touches qui ont de la valeur donnée, combien de.

il y a un poste similaire ici:
Combien d'articles dans un dictionnaire partagent la même valeur en Python, cependant je n'ai pas besoin d'un dictionnaire retourné, juste un entier.

Ma première pensée est d'itérer sur les éléments et de tester chacun tout en gardant un total de chaque valeur Vraie ou quelque chose. Je me demandais simplement, car je suis encore nouveau pour python et ne connais pas toutes les bibliothèques, si il y a un mieux/plus rapide/plus simple façon de le faire.

merci d'avance.

InformationsquelleAutor jguerra | 2012-11-19
  1. 33

    Cette première partie est surtout pour s'amuser, je n'aurais probablement pas l'utiliser dans mon code. 

    sum(d.values())

    obtiendrez le nombre de True valeurs. (Bien sûr, vous pouvez obtenir le nombre de False valeurs par len(d) - sum(d.values())).

    Légèrement plus généralement, vous pouvez faire quelque chose comme:

    sum(1 for x in d.values() if some_condition(x))

    Dans ce cas, if x fonctionne très bien à la place de if some_condition(x) et est ce que la plupart des gens seraient d'utilisation dans le monde réel code)

    DES TROIS SOLUTIONS QUE J'AI POSTÉ ICI, LE CI-DESSUS EST LA PLUS IDIOMATIQUE ET EST CELUI QUE JE RECOMMANDE

    Enfin, je suppose que cela pourrait être écrit un peu plus intelligemment:

    sum( x == chosen_value for x in d.values() )

    C'est dans la même veine que mon premier (de plaisir), la solution repose sur le fait que True + True == 2. Intelligent n'est pas toujours le meilleur. Je pense que la plupart des gens considèrent cette version à être un peu plus obscur que celui ci-dessus (et donc le pire).

    • grand. c'est exactement ce que je voulais. je upvote mais je ne peux pas parce que ses mon premier post et je n'ai pas de rep. je pense que j'ai marqué la réponse utile bien 🙂
    • vous avez eu une réponse valable, mais - vous d'avoir quitté il 🙂
    • Je préfère encore sum(1 for i in something if i) si... (et que faites-vous avec ==True @mgilson) !?
    • juste par curiosité, pourquoi n'utilisez-vous pas le premier exemple: sum(d.les valeurs()) dans votre code?
    • J'étais en train de penser à un moyen de le rendre un peu différents, je vais reposter avec un être inférieur (mais légèrement différent!) approche 🙂
    • Il ne fait pas de généralisation à d'autres conditions. Il a aussi vraiment les limites de vos valeurs à des valeurs booléennes ou 1 et 0 qui est unpythonic.
    • Désolé, je jouais un peu, 0:^) - j'ai ajouté (heureusement très clairement), la version à laquelle je pense est le meilleur. D'autre part, bien que je ne pense que c'est la meilleure réponse il y a, je n'ai jamais vraiment aimé le sum(1 for _ in ... if ...) idiome. On dirait que c'est trop, mais c'est certainement la plus commune.
    • qu'est-ce que le broyage est if i == True 🙁 soit i is True ou i 🙂
    • Oh, je vois ce que vous dites maintenant ... eh bien, je voulais mettre quelque chose là-bas qui permettrait de généraliser bien à l'arbitraire des expressions conditionnelles pour le bénéfice de l'OP. Vous avez tout à fait raison que le == True est complètement inutile pour cet exemple.

    InformationsquelleAutor mgilson
  2. 10

    Si vous voulez une structure de données que vous pouvez rapidement accéder à vérifier le compte, vous pouvez essayer d'utiliser un Compteur (comme @mgilson points, cela s'appuie sur les valeurs elles-mêmes être hashable):

    >>> from collections import Counter
>>> d = {(1, 2): 2, (3, 1): 2, (4, 4): 1, (5, 6): 4}
>>> Counter(d.values())
Counter({2: 2, 1: 1, 4: 1})

    Vous pouvez ensuite brancher une valeur et d'obtenir le nombre de fois où il est apparu:

    >>> c = Counter(d.values())
>>> c[2]
2
>>> c[4]
1
    InformationsquelleAutor RocketDonkey