Le test « key in d » vérifie la présence d'une clé dans un dictionnaire.
Soit maintenant une liste de plusieurs clés keys=[key1, key2, ... keyn].
Quelle serait la façon la plus économique pour vérifier que toutes les clés
listées dans keys sont présentes dans le dictionnaire d ? Je n'ai pas besoin
de savoir précisément quelles clés sont présentes, je voudrais juste un test
qui me réponde True si tous les élements de keys sont bien des clés dans d,
False si au moins un élément de keys n'est pas une clé dans d.
Le test « key in d » vérifie la présence d'une clé dans un dictionnaire.
Soit maintenant une liste de plusieurs clés keys=[key1, key2, ... keyn].
Quelle serait la façon la plus économique pour vérifier que toutes les clés
listées dans keys sont présentes dans le dictionnaire d ? Je n'ai pas besoin
de savoir précisément quelles clés sont présentes, je voudrais juste un test
qui me réponde True si tous les élements de keys sont bien des clés dans d,
False si au moins un élément de keys n'est pas une clé dans d.
Le test « key in d » vérifie la présence d'une clé dans un dictionnaire.
Soit maintenant une liste de plusieurs clés keys=[key1, key2, ... keyn].
Quelle serait la façon la plus économique pour vérifier que toutes les clés
listées dans keys sont présentes dans le dictionnaire d ? Je n'ai pas besoin
de savoir précisément quelles clés sont présentes, je voudrais juste un test
qui me réponde True si tous les élements de keys sont bien des clés dans d,
False si au moins un élément de keys n'est pas une clé dans d.
Je réponds Í moi-même, je crois que j'ai trouvé...
Le 25/04/2022 23:56, Olivier Miakinen a écrit :Le test « key in d » vérifie la présence d'une clé dans un dictionnaire.
Soit maintenant une liste de plusieurs clés keys=[key1, key2, ... keyn].
Quelle serait la façon la plus économique pour vérifier que toutes les clés
listées dans keys sont présentes dans le dictionnaire d ? Je n'ai pas besoin
de savoir précisément quelles clés sont présentes, je voudrais juste un test
qui me réponde True si tous les élements de keys sont bien des clés dans d,
False si au moins un élément de keys n'est pas une clé dans d.
Ceci devrait faire l'affaire :
not (keys - d.keys())
Sauf erreur de ma part, ça répondra True si la différence entre mon tableau
de clés et les vraies clés du dictionnaire est un ensemble vide, False si
la différence contient au moins une clé (présente donc dans keys et pas dans
d.keys())
Je réponds Í moi-même, je crois que j'ai trouvé...
Le 25/04/2022 23:56, Olivier Miakinen a écrit :
Le test « key in d » vérifie la présence d'une clé dans un dictionnaire.
Soit maintenant une liste de plusieurs clés keys=[key1, key2, ... keyn].
Quelle serait la façon la plus économique pour vérifier que toutes les clés
listées dans keys sont présentes dans le dictionnaire d ? Je n'ai pas besoin
de savoir précisément quelles clés sont présentes, je voudrais juste un test
qui me réponde True si tous les élements de keys sont bien des clés dans d,
False si au moins un élément de keys n'est pas une clé dans d.
Ceci devrait faire l'affaire :
not (keys - d.keys())
Sauf erreur de ma part, ça répondra True si la différence entre mon tableau
de clés et les vraies clés du dictionnaire est un ensemble vide, False si
la différence contient au moins une clé (présente donc dans keys et pas dans
d.keys())
Je réponds Í moi-même, je crois que j'ai trouvé...
Le 25/04/2022 23:56, Olivier Miakinen a écrit :Le test « key in d » vérifie la présence d'une clé dans un dictionnaire.
Soit maintenant une liste de plusieurs clés keys=[key1, key2, ... keyn].
Quelle serait la façon la plus économique pour vérifier que toutes les clés
listées dans keys sont présentes dans le dictionnaire d ? Je n'ai pas besoin
de savoir précisément quelles clés sont présentes, je voudrais juste un test
qui me réponde True si tous les élements de keys sont bien des clés dans d,
False si au moins un élément de keys n'est pas une clé dans d.
Ceci devrait faire l'affaire :
not (keys - d.keys())
Sauf erreur de ma part, ça répondra True si la différence entre mon tableau
de clés et les vraies clés du dictionnaire est un ensemble vide, False si
la différence contient au moins une clé (présente donc dans keys et pas dans
d.keys())
Soit maintenant une liste de plusieurs clés keys=[key1, key2, ... keyn].
Quelle serait la façon la plus économique pour vérifier que toutes les clés
listées dans keys sont présentes dans le dictionnaire d ? Je n'ai pas besoin
de savoir précisément quelles clés sont présentes, je voudrais juste un test
qui me réponde True si tous les élements de keys sont bien des clés dans d,
False si au moins un élément de keys n'est pas une clé dans d.
Ceci devrait faire l'affaire :
not (keys - d.keys())
Sauf erreur de ma part, ça répondra True si la différence entre mon tableau
de clés et les vraies clés du dictionnaire est un ensemble vide, False si
la différence contient au moins une clé (présente donc dans keys et pas dans
d.keys())
Soit maintenant une liste de plusieurs clés keys=[key1, key2, ... keyn].
Quelle serait la façon la plus économique pour vérifier que toutes les clés
listées dans keys sont présentes dans le dictionnaire d ? Je n'ai pas besoin
de savoir précisément quelles clés sont présentes, je voudrais juste un test
qui me réponde True si tous les élements de keys sont bien des clés dans d,
False si au moins un élément de keys n'est pas une clé dans d.
Ceci devrait faire l'affaire :
not (keys - d.keys())
Sauf erreur de ma part, ça répondra True si la différence entre mon tableau
de clés et les vraies clés du dictionnaire est un ensemble vide, False si
la différence contient au moins une clé (présente donc dans keys et pas dans
d.keys())
Soit maintenant une liste de plusieurs clés keys=[key1, key2, ... keyn].
Quelle serait la façon la plus économique pour vérifier que toutes les clés
listées dans keys sont présentes dans le dictionnaire d ? Je n'ai pas besoin
de savoir précisément quelles clés sont présentes, je voudrais juste un test
qui me réponde True si tous les élements de keys sont bien des clés dans d,
False si au moins un élément de keys n'est pas une clé dans d.
Ceci devrait faire l'affaire :
not (keys - d.keys())
Sauf erreur de ma part, ça répondra True si la différence entre mon tableau
de clés et les vraies clés du dictionnaire est un ensemble vide, False si
la différence contient au moins une clé (présente donc dans keys et pas dans
d.keys())
not (keys - d.keys())
Je m'interroge sur cette façon de faire... keys est une liste, d.keys()
une "vue", je ne vois pas bien de quel opérateur - il s'agit (le
résultat est un set, en tout cas). Bref, cela fait bien ce que tu veux
apparemment.
Si le dictionnaire est volumineux et la liste courte, il vaut peut-être
mieux faire quelque chose comme
all (k in d for k in keys)
cela évitera la création explicite d'un set dans le seul but de tester
s'il est vide, et j'imagine que cela arrête la recherche au premier
False, ce que semble confirmer la doc de all.
(Difficile d'en dire plus parce que toutes ces opérations ont une
complexité --voire un comportement -- mal documentée.)
not (keys - d.keys())
Je m'interroge sur cette façon de faire... keys est une liste, d.keys()
une "vue", je ne vois pas bien de quel opérateur - il s'agit (le
résultat est un set, en tout cas). Bref, cela fait bien ce que tu veux
apparemment.
Si le dictionnaire est volumineux et la liste courte, il vaut peut-être
mieux faire quelque chose comme
all (k in d for k in keys)
cela évitera la création explicite d'un set dans le seul but de tester
s'il est vide, et j'imagine que cela arrête la recherche au premier
False, ce que semble confirmer la doc de all.
(Difficile d'en dire plus parce que toutes ces opérations ont une
complexité --voire un comportement -- mal documentée.)
not (keys - d.keys())
Je m'interroge sur cette façon de faire... keys est une liste, d.keys()
une "vue", je ne vois pas bien de quel opérateur - il s'agit (le
résultat est un set, en tout cas). Bref, cela fait bien ce que tu veux
apparemment.
Si le dictionnaire est volumineux et la liste courte, il vaut peut-être
mieux faire quelque chose comme
all (k in d for k in keys)
cela évitera la création explicite d'un set dans le seul but de tester
s'il est vide, et j'imagine que cela arrête la recherche au premier
False, ce que semble confirmer la doc de all.
(Difficile d'en dire plus parce que toutes ces opérations ont une
complexité --voire un comportement -- mal documentée.)
not (keys - d.keys())
<https://docs.python.org/fr/3.8/library/stdtypes.html#frozenset.difference>
§
Remarque : Les méthodes union(), intersection(), difference(), et
symmetric_difference(), issubset(), et issuperset() acceptent n'importe
quel itérable comme argument, contrairement aux opérateurs équivalents
qui n'acceptent que des sets.
§
En lisant cette remarque, j'ai cru Í tort qu'elle disait que « - »
acceptait n'importe quel itérable Í gauche et Í droite, alors qu'au
ça ne vaut pour « difference() », et encore, seulement pour son
argument !
Bon, il se trouve que ça marche (et que ça retourne effectivement un
set) mais je suis bien sͻr preneur d'une meilleure solution.
all (k in d for k in keys)
Ni le dictionnaire ni la liste ne sont très gros (moins de 20 entrées
pour le dictionnaire, et entre 3 et 6 pour la liste), mais ta solution
présente surtout l'intérêt d'être plus lisible. Cette commande 'all'
est vraiment ce qu'il me faut !
not (keys - d.keys())
<https://docs.python.org/fr/3.8/library/stdtypes.html#frozenset.difference>
§
Remarque : Les méthodes union(), intersection(), difference(), et
symmetric_difference(), issubset(), et issuperset() acceptent n'importe
quel itérable comme argument, contrairement aux opérateurs équivalents
qui n'acceptent que des sets.
§
En lisant cette remarque, j'ai cru Í tort qu'elle disait que « - »
acceptait n'importe quel itérable Í gauche et Í droite, alors qu'au
ça ne vaut pour « difference() », et encore, seulement pour son
argument !
Bon, il se trouve que ça marche (et que ça retourne effectivement un
set) mais je suis bien sͻr preneur d'une meilleure solution.
all (k in d for k in keys)
Ni le dictionnaire ni la liste ne sont très gros (moins de 20 entrées
pour le dictionnaire, et entre 3 et 6 pour la liste), mais ta solution
présente surtout l'intérêt d'être plus lisible. Cette commande 'all'
est vraiment ce qu'il me faut !
not (keys - d.keys())
<https://docs.python.org/fr/3.8/library/stdtypes.html#frozenset.difference>
§
Remarque : Les méthodes union(), intersection(), difference(), et
symmetric_difference(), issubset(), et issuperset() acceptent n'importe
quel itérable comme argument, contrairement aux opérateurs équivalents
qui n'acceptent que des sets.
§
En lisant cette remarque, j'ai cru Í tort qu'elle disait que « - »
acceptait n'importe quel itérable Í gauche et Í droite, alors qu'au
ça ne vaut pour « difference() », et encore, seulement pour son
argument !
Bon, il se trouve que ça marche (et que ça retourne effectivement un
set) mais je suis bien sͻr preneur d'une meilleure solution.
all (k in d for k in keys)
Ni le dictionnaire ni la liste ne sont très gros (moins de 20 entrées
pour le dictionnaire, et entre 3 et 6 pour la liste), mais ta solution
présente surtout l'intérêt d'être plus lisible. Cette commande 'all'
est vraiment ce qu'il me faut !
Oui, mais je pense que ça marche grÍ¢ce aux "reflected/swapped operands",
qui fait si il n'y a pas de __sub__ sur list, la méthode __rsub__ de set
(ou ce que renvoie keys()) est utilisée...
https://docs.python.org/3/reference/datamodel.html#object.__radd__
all (k in d for k in keys)[...] ta solution
présente surtout l'intérêt d'être plus lisible. [...]
Dans ce cas, "beauty is in the eye of the beholder", choisis ce que tu
comprendras le plus facilement quand tu reliras le code dans 3
semaines/mois/années/.
Oui, mais je pense que ça marche grÍ¢ce aux "reflected/swapped operands",
qui fait si il n'y a pas de __sub__ sur list, la méthode __rsub__ de set
(ou ce que renvoie keys()) est utilisée...
https://docs.python.org/3/reference/datamodel.html#object.__radd__
all (k in d for k in keys)
[...] ta solution
présente surtout l'intérêt d'être plus lisible. [...]
Dans ce cas, "beauty is in the eye of the beholder", choisis ce que tu
comprendras le plus facilement quand tu reliras le code dans 3
semaines/mois/années/.
Oui, mais je pense que ça marche grÍ¢ce aux "reflected/swapped operands",
qui fait si il n'y a pas de __sub__ sur list, la méthode __rsub__ de set
(ou ce que renvoie keys()) est utilisée...
https://docs.python.org/3/reference/datamodel.html#object.__radd__
all (k in d for k in keys)[...] ta solution
présente surtout l'intérêt d'être plus lisible. [...]
Dans ce cas, "beauty is in the eye of the beholder", choisis ce que tu
comprendras le plus facilement quand tu reliras le code dans 3
semaines/mois/années/.
all (k in d for k in keys)
all (k in d for k in keys)
all (k in d for k in keys)
Soit maintenant une liste de plusieurs clés keys=[key1, key2, ... keyn].
Quelle serait la façon la plus économique pour vérifier que toutes les clés
listées dans keys sont présentes dans le dictionnaire d ? Je n'ai pas besoin
de savoir précisément quelles clés sont présentes, je voudrais juste un test
qui me réponde True si tous les élements de keys sont bien des clés dans d,
False si au moins un élément de keys n'est pas une clé dans d.
Ceci devrait faire l'affaire :
not (keys - d.keys())
Soit maintenant une liste de plusieurs clés keys=[key1, key2, ... keyn].
Quelle serait la façon la plus économique pour vérifier que toutes les clés
listées dans keys sont présentes dans le dictionnaire d ? Je n'ai pas besoin
de savoir précisément quelles clés sont présentes, je voudrais juste un test
qui me réponde True si tous les élements de keys sont bien des clés dans d,
False si au moins un élément de keys n'est pas une clé dans d.
Ceci devrait faire l'affaire :
not (keys - d.keys())
Soit maintenant une liste de plusieurs clés keys=[key1, key2, ... keyn].
Quelle serait la façon la plus économique pour vérifier que toutes les clés
listées dans keys sont présentes dans le dictionnaire d ? Je n'ai pas besoin
de savoir précisément quelles clés sont présentes, je voudrais juste un test
qui me réponde True si tous les élements de keys sont bien des clés dans d,
False si au moins un élément de keys n'est pas une clé dans d.
Ceci devrait faire l'affaire :
not (keys - d.keys())