En Python, 𝐚𝐥𝐥() vérifie si tous les éléments d’un itérable, comme une liste ou un tuple, sont vrais, tandis que 𝐚𝐧𝐲() vérifie si un élément est vrai.
- Fonctions intégrées – all() — Documentation Python 3.12.1
- Fonctions intégrées – any() — Documentation Python 3.12.1
Test de la valeur de vérité en Python
Python utilise le type 𝐛𝐨𝐨𝐥 ( T𝐫𝐮𝐞 et F𝐚𝐥𝐬𝐞 ), mais il pèse également d’autres types, tels que les nombres et les chaînes, comme vrais ou faux dans des conditions telles que les mode d’emploi 𝐢𝐟 .
Les objets suivants sont considérés comme faux, comme dans la documentation officielle ci-dessus.
- Constantes définies comme fausses : N𝐨𝐧𝐞 et F𝐚𝐥𝐬𝐞 .
- Zéro de tout type numérique : 0 , 0,0 , 0𝐣 , D𝐞𝐜𝐢𝐦𝐚𝐥(0) , F𝐫𝐚𝐜𝐭𝐢𝐨𝐧(0, 1)
- Séquences et collections vidéos : » , () , [] , {} , 𝐬𝐞𝐭() , 𝐫𝐚𝐧𝐠𝐞(0)
Tous les autres objets sont considérés comme vrais.
Pour plus de détails, voir l’article suivant.
Les règles ci-dessus s’appliquent également à la détermination des valeurs de vérité dans 𝐚𝐥𝐥() et 𝐚𝐧𝐲() .
𝐚𝐥𝐥() vérifier si tous les éléments sont vrais
𝐚𝐥𝐥() renvoie T𝐫𝐮𝐞 si tous les éléments de l’itérable donné sont vrais. Si même un seul est faux, elle renvoie F𝐚𝐥𝐬𝐞 .
print(all([True, True, True])) # True print(all([True, False, True])) # False Il peut accepter différents types itérables comme arguments, notamment des listes, des tuples et des ensembles.
print(all((True, True, True))) # True print(all({True, True, True})) # True Les objets de types autres que 𝐛𝐨𝐨𝐥 sont également évalués, comme mentionné ci-dessus. Par exemple, une chaîne vide ou 0 est réalisée comme fausse, tandis que toutes les autres chaînes ou nombres sont évalués comme vrais.
print(all(['aaa', 'bbb', 'ccc'])) # True print(all(['aaa', 'bbb', 'ccc', ''])) # False print(all([1, 2, 3])) # True print(all([0, 1, 2, 3])) # False 𝐚𝐥𝐥() est équivalent au code suivant :
def all(iterable): for element in iterable: if not element: return False return True Ainsi, il renvoie T𝐫𝐮𝐞 pour un vide itérable.
print(all([])) # True 𝐚𝐧𝐲() vérifier si un élément est vrai
𝐚𝐧𝐲() renvoie T𝐫𝐮𝐞 si au moins un élément de l’itérable donné est vrai. Si tous sont faux, elle renvoie F𝐚𝐥𝐬𝐞 .
print(any([True, False, False])) # True print(any([False, False, False])) # False Il peut accepter différents types itérables comme arguments, notamment des listes, des tuples et des ensembles.
print(any((True, False, False))) # True print(any({True, False, False})) # True Les objets de types autres que 𝐛𝐨𝐨𝐥 sont également évalués, comme mentionné ci-dessus.
print(any(['aaa', 'bbb', 'ccc', ''])) # True print(any(['', '', '', ''])) # False print(any([0, 1, 2, 3])) # True print(any([0, 0, 0, 0])) # False 𝐚𝐧𝐲() est équivalent au code suivant :
def any(iterable): for element in iterable: if element: return True return False Ainsi, il renvoie F𝐚𝐥𝐬𝐞 pour un objet itérable vide.
print(any([])) # False 𝐧𝐨𝐭 𝐚𝐧𝐲() vérifier si tous les éléments sont faux
Étant donné que 𝐚𝐧𝐲() renvoie T𝐫𝐮𝐞 lorsqu’un élément est vrai et F𝐚𝐥𝐬𝐞 lorsque tous sont faux, 𝐧𝐨𝐭 𝐚𝐧𝐲() vérifiez que tous les éléments sont faux.
print(not any([False, False, False])) # True print(not any([True, False, False])) # False 𝐚𝐥𝐥() et 𝐚𝐧𝐲() avec conditions
Appliquer 𝐚𝐥𝐥() et 𝐚𝐧𝐲() aux compréhensions de listes et aux expressions génératrices
Alors que les exemples précédents évaluaient directement les éléments d’un itérable donné comme vrais ou faux, l’utilisation de compréhensions permet d’appliquer 𝐚𝐥𝐥() ou 𝐚𝐧𝐲() avec des conditions spécifiques.
Par exemple, vous pouvez vérifier si tous les éléments correspondent à une certaine condition.
Vous pouvez obtenir les résultats de l’évaluation des conditions pour chaque élément d’un itérable en utilisant des compréhensions de liste comme suit :
l = [0, 1, 2, 3, 4] print([i > 2 for i in l]) # [False, False, False, True, True] En transmettant ce résultat à 𝐚𝐥𝐥() ou 𝐚𝐧𝐲(), on détermine si tous les éléments ou certains d’entre eux répondent à la condition.
print(all([i > 2 for i in l])) # False print(any([i > 2 for i in l])) # True Changer [] en () en fait une expression de générateur, qui renvoie un générateur au lieu d’une liste.
print(type([i > 2 for i in l])) # <class 'list'> print(type((i > 2 for i in l))) # <class 'generator'> Lors de l’appel d’une fonction avec une expression de générateur comme seul argument, vous pouvez omettre les parenthèses () .
print(type(i > 2 for i in l)) # <class 'generator'> Ceci peut être utilisé comme argument pour 𝐚𝐥𝐥() et 𝐚𝐧𝐲() .
print(all(i > 2 for i in l)) # False print(any(i > 2 for i in l)) # True Avantages des expressions génératrices
Les générateurs, contrairement aux listes, sont traités de manière séquentielle, offrant l’avantage d’un temps de traitement et d’une utilisation de la mémoire réduite.
Prenons comme exemple une liste de 100 000 nombres consécutifs.
l = list(range(100000)) print(l[:5]) # [0, 1, 2, 3, 4] print(l[-5:]) # [99995, 99996, 99997, 99998, 99999] print(len(l)) # 100000 Comparons le temps de traitement de la compréhension de liste et de l’expression du générateur avec 𝐚𝐥𝐥() et 𝐚𝐧𝐲() en utilisant la commande magique %%𝐭𝐢𝐦𝐞𝐢𝐭 du Carnet Jupyter. Notez que ceux-ci ne fonctionneront pas s’ils sont exécutés en tant que scripts Python.
Pour 𝐚𝐥𝐥() , le résultat est déterminé comme étant F𝐚𝐥𝐬𝐞 s’il existe même un seul F𝐚𝐥𝐬𝐞 .
Une compréhension de liste importante l’expression (dans l’exemple, 𝐢 < 0 ) pour tous les éléments, crée une liste et la transmettre à 𝐚𝐥𝐥() ou 𝐚𝐧𝐲() . Cependant, une expression génératrice traite les éléments de manière séquentielle depuis le début. Étant donné que le résultat de 𝐚𝐥𝐥() est déterminé dès qu’un F𝐚𝐥𝐬𝐞 est rencontré, si le premier élément est F𝐚𝐥𝐬𝐞 , une expression génératrice peut être beaucoup plus rapide.
%%timeit all([i < 0 for i in l]) # 4.15 ms ± 117 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) %%timeit all(i < 0 for i in l) # 469 ns ± 6.12 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) Si tous les éléments sont T𝐫𝐮𝐞 (le résultat de 𝐚𝐥𝐥() est T𝐫𝐮𝐞 ), une expression génératrice n’est pas plus rapide car elle doit traiter tous les éléments jusqu’à la fin. Dans l’exemple, elle peut même être plus lente.
%%timeit all([i >= 0 for i in l]) # 4.5 ms ± 57.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) %%timeit all(i >= 0 for i in l) # 5.49 ms ± 255 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) Ainsi, le temps de traitement des expressions génératrices varie en fonction de l’emplacement du premier F𝐚𝐥𝐬𝐞 . Si l’élément du milieu est déterminé comme étant F𝐚𝐥𝐬𝐞 , le temps de traitement peut être divisé par deux.
%%timeit all(i < 50000 for i in l) # 2.73 ms ± 37.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) Il en va de même pour 𝐚𝐧𝐲() . Le résultat est déterminé comme étant T𝐫𝐮𝐞 s’il existe au moins un T𝐫𝐮𝐞 . Dans le cas d’expressions génératrices, le traitement se termine dès que T𝐫𝐮𝐞 est rencontré.
%%timeit any([i >= 0 for i in l]) # 4.2 ms ± 183 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) %%timeit any(i >= 0 for i in l) # 468 ns ± 4.8 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each) %%timeit any([i < 0 for i in l]) # 4.56 ms ± 180 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) %%timeit any(i < 0 for i in l) # 5.33 ms ± 45.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) %%timeit any(i > 50000 for i in l) # 2.78 ms ± 120 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) Compter les éléments répondant à une condition
Étant donné que T𝐫𝐮𝐞 est traité comme 1 et F𝐚𝐥𝐬𝐞 comme 0 , vous pouvez utiliser 𝐬𝐮𝐦() pour compter T𝐫𝐮𝐞 , c’est-à-dire les éléments répondant à une condition.
print(sum(i > 2 for i in l)) # 2 Pour compter le nombre de F𝐚𝐥𝐬𝐞 , utilisez 𝐧𝐨𝐭 .
print(sum(not (i > 2) for i in l)) # 3