Bonjour à tous,
Dans la documentation Python, j'ai lu que le "or" équivalait à la barre verticale "|". Or, quand je teste les deux, ça ne me sort pas le même résultat...
>>> 6==6 or 0==1
True
>>> 6==6 | 0==1
False
Merci d'avance de votre aide !
Cordialement,
Latinus.
C'est parce que tu confonds l'opérateur OU logique (or) qui agit sur des booléens avec le OU bit à bit (| = bitwise or) qui effectue des ou sur les bits de même rang de données numériques
Bonsoir,
Cette question provoque la question fondamentale : pourquoi l'informatique, à quoi ça sert, pourquoi tel langage etc.
Bien-sûr, je pose la question aux informaticiens. Pour référence un exercice que j'ai lu, il s'agissait d'un code où il manquait une ligne, l'exercice consistait à trouver cette ligne manquante.
J'ai l'impression qu'on a complètement oublié le schéma normal : problème_posé --> algorithme --> code. Il me semble qu'on suit le schéma inverse.
Bonjour
Après ce hors sujet de fin de soirée (quel est le lien avec la question posée ? ), revenons à la question sur le | en python.
Je vais compléter la réponse de Jack car il me semble qu'il y a une précision importante à donner : c'est le lien de "priorité" des opérations avec le | par rapport à == :
Précisément, 6==6 | 0==1 s'exécute comme 6== (6 | 0) ==1 (qui donne False),
et pas ce que nous penserions naïvement (6==6) | (0==1) (qui donne True).
6 == 6|0 donne True : il s'agit de 6 == (6|0) donc de 6 == 6 donc True
(6 == 6) | 0 donne 1...
etc.
95 == 91 | 14 donne True : il s'agit de 95 == (91 | 14) sachant que 91 | 14 = 95 (le "ou" bit à bit)
Tu as bien fait de compléter pour une réponse plus complète.
Pour le message précédent, je cherche également le lien avec la discussion ouverte.
Bonjour,
Chercher ce qui n'existe pas est voué à l'échec.Envoyé par Jack
Et sur la couleur des claviers, vous avez une opinion ?
bonjour,
à mon avis, tu as (mal) interprété ou bien ce n'est pas LA doc python que tu as lu.
Pour mieux répondre, il faudrait avoir la citation ou le lien qui t'as induit en erreur.Code:>>> 1 or 2 1 >>> 1 | 2 3 >>> (1 or 2) == (1 | 2) False
Jusqu'ici tout va bien...
Bonjour,
Je ne connais pas Python, mais imaginons que 'OR' soit le connecteur logique bit à bit, alors Latinus n'a pas mal lu, et ne s'est pas trompé, mais il a fait des tests de syntaxe sans préciser ce qu'il voulait faire.
@ Bluedeep, je n'ai pas d'idée particulière sur la couleur des claviers, par contre, je sais que si on apprend l'informatique en commençant par la fin, alors on se brûle les doigts, et on ne peut plus taper sur un clavier.
Suite de mon message précédent.
En Python les opérateurs logiques AND et OR ont un sens tout à fait particulier, d'ailleurs pas très différent de '&' et '|'.
A part, vérifier la syntaxe, on ne sait toujours pas ce que voulait faire Latinus.
Justement, le OR n'est pas cela : le message de Polo974 montre que "1 OR 2" donne 1 .
Justement, ils ont un sens tout à fait habituel sur les booléens. Ils sont d'ailleurs "optimisés/dissymétriques" dans le sens où :
<< False and T >> donnera False sans évaluer T ;
<< True or T >> donnera True sans évaluer T .
<< T and False >> et << T or True >> évaluerons T ...
Ce qui explique des choses.
Les opérateurs AND et OR sont un peu particuliers.
Soit une série de variables a, b, c, tous non vides.
Si on veut le premier non vide, alors un écrira return a OR b OR c et la valeur retournée sera a.
Si on veut vérifier que tous sont non vides, alors on écrira a AND b AND c et la valeur retournée sera c.
Le point commun avec les opérateurs est que cette opération retourne une valeur, et non un booléen.
Par exemple 2 OR 1 retourne 2 et non pas TRUE ou 1.
Oui, c'est vrai.
Avec les valeurs numériques, il faut comprendre que 0 est géré comme False, et les autres nombres non nuls comme True (comme souvent dans d'autres langages).
Du coup :
"2 or T" donnera automatiquement "2" (sans aucune évaluation de T), exactement comme "True or T" donne automatiquement "True".
"0 and T" donnera automatiquement "0" (sans aucune évaluation de T), exactement comme "False and T" donne automatiquement "False".
"0 or T" redonne la valeur de T, exactement comme le fait "False or T".
"2 and T" redonne la valeur de T, exactement comme le fait "True and T".
Tout cela est en fait assez formel.
Presque toujours mais pas toujours : si a = 0 ou a = False, alors la valeur retournée est celle de "b or c" (qui dépendra des valeurs de b et c).
Presque... Par exemple, si a = 0 ou a = False, la valeur retournée est automatiquement a (sans évaluation de b et c).
Bonjour,
Qu'il ne fasse pas la conversion de type lorsqu'il n'évalue pas, je trouve ça un peu limite bug, mais bon, c'est un opinion
Bonjour,
Voici quelques résultats, j'en comprends certains, pas d'autres:
Code:>>> 1 or 2 1 <- ok il n'évalue pas >>> 2 or 1 2 <- ok, il n'évalue pas >>> 2 and 1 1 <- là il faut qu'il évalue, il devrait donc trouver True et pas 1 >>> 1 and 2 2 <- là je ne comprends pas >>> 1 & 2 0 <- ok >>> 2 and True True <- ok >>> 1 and True True <- ok >>> 0 and True 0 <- ok, il n'évalue pas >>> 0 and False 0 <- idem >>> True and 1 1 <- là, il évalue, il devrait trouver True et pas 1
Dernière modification par CM63 ; 03/11/2016 à 18h42.
C'est simplement la définition de ce qui est vrai ou faux pour Python, 0, False, une collection vide, etc et de ce qui est vrai.
Ensuite :
x and y renvoie x si x est faux et y sinon.
http://www.thomas-cokelaer.info/tuto...n/boolean.html
Ca marche bien et c'est efficace.
Bon apparemment, je n'ai pas été assez clair.
Cette ligne (opération et non test) ne renvoie pas VRAI ou FAUX ou TRUE ou FALSE.
Dans le cas de OR, Python renvoie la première valeur existante (pourquoi pas 0), c'est à dire non vide, dans le cas de AND, renvoie la dernière valeur [aucune n'est] non-vide. Donc, en gros, rien à voir avec True ou False.
L'évaluation, s'il y a lieu, se fait de gauche à droite.
De toute façon, je suis bien d'accord, c'est un peu tordu.
D'après mes lectures, c'est utilisé pour faire une alternative (ersatz) à l'instruction C Truc ? Machin : Chose.
@ CM63, à mon avis, dans tes essais, True et False sont des valeurs non vides et non pas des booléens vrais ou faux.
Je réponds à CM63 dans le texte :
Merci, maintenant c'est clair, je ne connaissais pas ces généralisations :
x and y donne x si x est faux, y si x est vrai
x or y donne y si x est faux, x si x est vrai
...Tout ça est un peu tordu, en effet.
Reprenons la documentation de Python ! confer le message pm42.
True et False désignent les booléens Vrai et Faux : "not 0" et "not False" donnent True ; "not 1" et "not True" donnent False.
En Python, tout objet possède une valeur booléenne :
- False, 0, une collection vide, possèdent la valeur booléenne False ;
- True, les nombres non nuls, les collections non vides, possèdent la valeur booléenne True.
Compte tenu de cela,
OR renvoie le premier objet considéré comme Vrai (si possible, sinon renvoie le dernier argument).
AND renvoie le premier objet considéré comme Faux (si possible, sinon renvoie le dernier argument).
Si cela tout à voir avec True et False, c'est simplement la définition de ceux ci en Python qui est plus large que dans les langages qui n'utilisent que des booléens. On est ici avec des classes d'équivalence.
Python n'est pas le seul à procéder comme ça. C et Perl par exemple ont une logique proche.
Pas du tout, c'est parfaitement logique, utilisé depuis longtemps. Il faut juste comprendre.
Absolument pas. C'est utilisé parce que c'est cohérent, que cela permet une implémentation rapide et un codage concis et puissant.
Plus haut, tu disais ne pas connaitre Python. Est tu sur que continuer à expliquer ce que tu ne comprends pas est une bonne idée ?
Bonjour,
Comme dit plus haut, je ne connais pas Python, d'où mes lectures. Alors, voilà la copie de ma source d'information. J'ai bien cru comprendre que le test portait sur l'existence d'une variable et non sa valeur. C'est d'ailleurs bien ce que veut dire le terme anglais "empty" dans le tuto cité.
Ceci dit, au risque de me répéter, on ne sait toujours pas ce qu'on veut faire, par contre on cherche à savoir comment le faire.
Je vais essayer de faire des essais.En Python, and et or appliquent la logique booléenne comme vous pourriez l’attendre, mais ils ne retournent pas de valeurs booléennes, ils retournent une des valeurs comparées.
Exemple 4.15. Présentation de and
>>> 'a' and 'b' 1
'b'
>>> '' and 'b' 2
''
>>> 'a' and 'b' and 'c' 3
'c'
1 Lorsqu’on utilise and les valeurs sont évaluées dans un contexte booléen de gauche à droite. 0, '', [], (), {} et None valent faux dans ce contexte, tout le reste vaut vrai.[1]Si toutes les valeurs valent vrai dans un contexte booléen, and retourne la dernière valeur. Ici and évalue 'a', qui vaut vrai, puis 'b', qui vaut vrai et retourne 'b'.
2 Si une des valeurs vaut faux and retourne la première valeur fausse. Ici '' est la première valeur fausse.
3 Toutes les valeurs sont vrai, donc and retourne la dernière valeur, 'c'.
Exemple 4.16. Présentation de or
>>> 'a' or 'b' 1
'a'
>>> '' or 'b' 2
'b'
>>> '' or [] or {} 3
{}
>>> def sidefx():
... print "in sidefx()"
... return 1
>>> 'a' or sidefx() 4
'a'
1 Lorsqu’on utilise or, les valeurs sont évaluées dans un contexte booléen de gauche à droite, comme pour and. Si une des valeurs vaut vrai, or la retourne immédiatement. Dans ce cas 'a' est la première valeur vraie.
2 or évalue '', qui vaut faux, puis 'b', qui vaut vrai et retourne 'b'.
3 Si toutes les valeurs valent faux, or retourne la dernière valeur. or évalue '', qui vaut faux, puis [], qui vaut faux, puis {}, qui vaut faux et retourne {}.
4 Notez que or continue l’évaluation seulement jusqu’à ce qu’il trouve une valeur vraie, le reste est ignoré. C’est important si certaines valeurs peuvent avoir un effet de bord. Ici, la fonction sidefx n’est jamais appelée, car or évalue 'a', qui vaut vrai et retourne 'a' immédiatement.
Si vous êtes un programmeur C, vous êtes certainement familier de l’expression ternaire bool ? a : b, qui s’évalue à a si bool vaut vrai et à b dans le cas contraire. Le fonctionnement de and et or en Python vous permet d’accomplir la même chose.
4.6.1. Utilisation de l'astuce and-or
Exemple 4.17. Présentation de l’astuce and-or
>>> a = "first"
>>> b = "second"
>>> 1 and a or b 1
'first'
>>> 0 and a or b 2
'second'
1 Cette syntaxe ressemble à celle de l’expression ternaire bool ? a : b de C. L’expression est évaluée de gauche à droite, donc le and est évalué en premier. 1 and 'first' s’évalue à 'first', puis 'first' or 'second' s’évalue à 'first'.
2 0 and 'first' s’évalue à 0, puis 0 or 'second' s’évalue à 'second'.
Cependant, puisque cette expression en Python est simplement de la logique booléenne et non un dispositif spécial du langage, il y a une différence très, très importante entre l’astuce and-or en Python et la syntaxe bool ? a : b en C. Si a vaut faux, l’expression ne fonctionnera pas comme vous vous y attendez. (Vous devinez que cela m’a déjà joué des tours. Et plus d’une fois !)
Exemple 4.18. Quand l’astuce and-or échoue
>>> a = ""
>>> b = "second"
>>> 1 and a or b 1
'second'
1 Puisque a est une chaîne vide, ce que Python évalue à faux dans un contexte booléen, 1 and '' s’évalue à '', puis '' or 'second' s’évalue à 'second'. Zut ! Ce n’est pas ce que nous voulions.
L’astuce and-or, bool and a or b, ne fonctionne pas comme l’expression ternaire de C bool ? a : b quand a s’évalue à faux dans un contexte booléen.
La véritable astuce cachée derrière l’astuce and-or, c’est de s’assurer que a ne vaut jamais faux. Une manière habituelle de le faire est de changer a en [a] et b en [b] et de prendre le premier élément de la liste retournée, qui sera soit a soit b.
Exemple 4.19. L’astuce and-or en toute sécurité
>>> a = ""
>>> b = "second"
>>> (1 and [a] or [b])[0] 1
''
1 Puisque [a] est une liste non-vide, il ne vaut jamais faux. Même si a est 0 ou '' ou une autre valeur fausse, la liste [a] vaut vrai puisqu’elle a un élément.
On peut penser que cette astuce apporte plus de complication que d’avantages. Après tout, on peut obtenir le même résultat avec une instruction if, alors pourquoi s’embarasser de tout ces problèmes ? Mais dans de nombreux cas, le choix se fait entre deux valeurs constantes et donc vous pouvez utiliser cette syntaxe plus simple sans vous inquiéter puisque vous savez que a vaudra toujours vrai. Et même si vous devez utiliser la version sûre plus complexe, il y a parfois de bonnes raisons de le faire, il y a des cas en Python où les instructions if ne sont pas autorisées, comme dans les fonctions lambda.
Pour en savoir plus sur l'astuce and-or
Le Python Cookbook traite des alternatives à l’astuce and-or.
Footnotes
[1] Presque tout, en fait. Par défaut, les instances de classes valent vrai dans un contexte booléen mais vous pouvez définir des méthodes spéciales de votre classe pour faire qu’une instance vale faux. Vous apprendrez tout sur les classes et les méthodes spéciales au Chapitre 5.
D'une part, "empty" signifie "vide" , et pas "existence".
D'autre part, le test porte bien sur la valeur booléenne True / False de tous les objets (valeur définie dans le tuto, ou ci-dessus).
C'est exactement ce que j'ai écrit : AND renvoie le premier objet considéré comme Faux (si possible, sinon renvoie le dernier argument).2 Si une des valeurs vaut faux, AND retourne la première valeur fausse.
3 Toutes les valeurs sont vrai, donc AND retourne la dernière valeur
Même remarque en ce qui concerne OR.
Oui, très bonne idée : lis bien les doc et expérimente un peu avant d'affirmer tes conclusions sur le fonctionnement de OR, AND, les booléens, l'existence de variable, etc.
Pourquoi nous avoir infligé le copier/coller d'une page web entière ? Je n'en vois pas l'intérêt... Il suffisait peut-être de donner simplement un lien : http://python.developpez.com/cours/D...hp#ftn.d0e9827 ou http://python.developpez.com/cours/p...on/?page=page4
Pareil. Je ne vois pas non plus l'intérêt de s'obstiner à répéter en boucle des trucs pas compris sans même rebondir sur les réponses...
Bon, j'ai commencé à faire des essais.
Il y a deux étapes différentes :
1- le test des valeurs.
D'abord, contrairement à ce que je pensais, une variable non déclarée, non seulement n'existe pas, ça c'est normal, mais provoque une erreur. Ca c'est plutôt un bon point.
Si je déclare une variable, puis que je la mette à 0 (int ou float) alors, elle équivaut à False. Ca c'est moins bien. Il y a un monde entre une variable qui vaut 0 et un booléen qui vaut False.
2- la valeur renvoyée :
A l'évidence, si il y a une variable nulle ou false dans la liste décrite avec 'and' la valeur renvoyée sera 0 ou False.
Mais dans le cas ou il y a une réponse non nulle, s'il y a l'opérateur 'or', c'est la première valeur non nulle qui est renvoyée.
Dans le cas de 'and' et pas de valeur nulle, c'est la dernière valeur qui est renvoyée.
Dans la doc, il est noté le terme 'empty' qui veut dire vide. Par erreur, j'avais interprété cet adjectif par "non renseigné" ou "non défini", mais certainement pas comme valant zéro, surtout en flottant.
Avec un blanc, c'est plus logique " " ou ' ' est non vide, alors que "" est vide.
Pas tout à fait (voir message #11 !) :
l'instruction "P and False" provoque en effet une erreur si P n'est pas déclarée (idem pour "P or True)", mais
l'instruction "False and P" ne provoque aucune erreur, même si P n'est pas déclarée (idem pour "True or P").
Et pourtant, bien d'autres langages (comme C et ses déclinaisons) ont adopté cette convention.
Oui, si on utilise uniquement des nombres.
De manière générale, OR renvoie le premier objet considéré comme Vrai (si possible, sinon renvoie le dernier argument).
Oui, si on utilise uniquement des nombres.
De manière générale, AND renvoie le premier objet considéré comme Faux (si possible, sinon renvoie le dernier argument).
Oui ce qui a déjà été dit au dessus, est précisé dans les docs dont les liens ont été donnés, etc.
J'abandonne, on a quelqu'un qui "fait des essais" pour retrouver exactement les résultats déjà décrits ici plusieurs fois et qui se permet de juger ce qui est bien ou pas...
pour remplacer le :
condition ? result_si_vrai: result_si_faux
du C, il y a le (pas beau) :
result_si_vrai if condition else result_si_faux
(ok, le "pas beau" n'est qu'un point de vue, mais si on est avare de retour à la ligne, ça existe...)
mais SURTOUT ne jamais utiliser la pseudo astuce and-or ! ! !
il suffit de mettre :
a= ''
pour s'en convaincre :
>>> a = "first"
>>> b = "second"
>>> 1 and a or b
'first'
>>> 0 and a or b
'second'
>>># jusqu'ici tout va bien... sauf que :
>>> a=''
>>> 1 and a or b
'second'
OUPS...
c'est du bricolage innommable ! ! !
(comme dirait quelqu'un: "on en a fusillé pour moins que ça")
Jusqu'ici tout va bien...
Bonjour,
Bof ...
J'étais intervenu sur ce sujet uniquement pour conseiller de bien savoir ce qu'on voulait faire avant de trouver la meilleure méthode pour le faire.
On a jugé que c'était hors-sujet.
La suite a montré que les choses n'étaient pas si simples et que les avis sont partagés.
En tout cas merci à pm42 pour son aide.
