Je lis sur les booléens dans mon livre, et il dit:

X et y ------------ Si x est faux, retourne x. Sinon, retournez y.

X ou y -------------- Si x est vrai, retournez x. Sinon, retournez y.

Cela n'a pas de sens pour moi de l'utilisation quotidienne de "ou" et "et" Pour moi, cela aurait du sens s'il disait:

X et y ------------ Si x est faux, ne faites rien. Si y est faux, ne faites rien. Si x et y sont vrais, retournez x et y

X ou y -------------- Si x est vrai, retournez x. Si x est faux, cochez y. Si y est faux, ne faites rien. Si y est vrai, retournez y

Dois-je simplement accepter aveuglément les définitions réelles, ou puis-je les comprendre parce qu'elles ont un sens.

0
Ovi 15 juil. 2015 à 00:01

8 réponses

Meilleure réponse

Le comportement peut sembler étrange, mais considérez les exemples hypothétiques suivants. En commençant par quelque chose d'évident,

>>> True and False
False
>>> False and True
False

C'est vraiment facile à comprendre car nous avons affaire à des valeurs booléennes. Souvenez-vous de cet exemple, car tout autre exemple peut être pensé de cette façon.

Considérez maintenant si les opérateurs and et or devaient convertir chaque objet en booléen avant de comparer. Par exemple, une chaîne vide ou une liste vide serait False, et des chaînes non vides seraient True. Cela ressemblerait à ceci ( évidemment ce n'est pas à quoi il ressemble réellement )

>>> "vanilla" and ""
False
>>> "" and "vanilla"
False

Cela est parfaitement logique. Après tout, bool("vanilla") and bool("") serait la même chose que True and False que nous savons déjà être False

Au lieu de les convertir réellement en True ou False, cependant, il peut faire la comparaison sans jamais les convertir. Par conséquent, vous n'en avez pas vraiment besoin pour renvoyer True ou False. Il peut simplement renvoyer l'objet réel qu'il a testé.

>>> "vanilla" and ""
""
>>> "" and "vanilla"
""

À des fins de test de vérité, le retour de "" revient au même que le retour de False, il n'est donc pas nécessaire de le convertir en booléen. C'est pourquoi il retourne toujours un objet dont la valeur de vérité est la même que le résultat de l'opérateur.

1
mehtunguh 14 juil. 2015 à 22:00

C'est probablement plus facile si vous y pensez dans chaque cas littéral

x et y ------------ Si x est faux, retourne x. Sinon, retournez y.

x ou y -------------- Si x est vrai, retournez x. Sinon, retournez y.


CAS 1: x = vrai, y = vrai

"si x est faux, retourne x. Sinon, retourne y."

Ensuite, cela renverra y, ce qui est vrai. Cela a du sens car x et y sont tous deux vrais.

(vrai et vrai == vrai)

"Si x est vrai, retourne x. Sinon, retourne y."

Cela retournera x, ce qui est vrai. Cela a du sens car l'un des x ou y est vrai.

(vrai ou vrai == vrai)


CAS 2: x = faux, y = vrai

"si x est faux, retourne x. Sinon, retourne y."

Ensuite, cela retournera x qui est faux. Cela a du sens car x et y ne sont pas tous les deux vrais.

(faux et vrai == faux)

"Si x est vrai, retourne x. Sinon, retourne y." Cela retournera y. Cela a du sens car l'un des x ou y est vrai.

(faux ou vrai == vrai)


CAS 3: x = vrai, y = faux

"si x est faux, retourne x. Sinon, retourne y."

Ensuite, cela retournera y qui est faux. Cela a du sens car x et y ne sont pas tous les deux vrais.

(vrai et faux == faux)

"Si x est vrai, retourne x. Sinon, retourne y."

Ensuite, cela renverra x, ce qui est vrai. Cela a du sens parce que x ou y est vrai

(vrai ou faux == vrai)


CAS 4: x = faux, y = faux

"si x est faux, retourne x. Sinon, retourne y."

Ensuite, cela retournera x qui est faux. Cela a du sens car x et y ne sont pas tous les deux vrais.

(faux et faux == faux)

"Si x est vrai, retourne x. Sinon, retourne y."

Ceci retournera y ce qui est faux. Cela a du sens car ni x ni y n'est vrai.

(faux ou faux == faux)

0
Lottamus 14 juil. 2015 à 21:49

Le premier ensemble de descriptions sont des raccourcis: les suivre vous donnera exactement les mêmes résultats que les "définitions habituelles" de vrai et faux.

Mais vos propres descriptions n'ont pas beaucoup de sens. Vous ne pouvez pas "ne rien faire"; vous devez renvoyer une valeur d'une comparaison, vraie ou fausse. Et vous ne pouvez pas non plus renvoyer a et b: encore une fois, le résultat d'une comparaison booléenne doit être un booléen, pas une paire de booléens.

0
Daniel Roseman 14 juil. 2015 à 21:09

De nombreux langages de programmation (la plupart?), Y compris Python, implémentent court-circuitant dans leurs opérateurs booléens and et or. Ils évaluent donc leurs opérandes de gauche à droite et s'arrêtent dès que le résultat final peut être déterminé.

Puisque x and y and z and ... est garanti faux si un opérande est faux, il arrête d'évaluer les opérandes dès qu'il en rencontre un faux. Et x or y or z or ... est garanti pour être vrai si un opérande est vrai, donc il s'arrête dès qu'il atteint un vrai opérande. Dans les deux cas, s'ils parviennent jusqu'au dernier opérande, ils renvoient sa valeur.

Dans certaines langues, les opérateurs booléens renvoient simplement un résultat booléen strict, soit true ou false (dans certaines langues, ils sont représentés comme 1 et 0). Mais en Python (et certains autres, comme Javascript et Common Lisp), ils renvoient la valeur du dernier opérande évalué, qui a déterminé le résultat final. Ceci est souvent plus utile que la simple valeur de vérité de l'expression.

Lorsque vous assemblez ces fonctionnalités, cela permet des idiomes succincts, par exemple

quotient = b != 0 && a/b

Au lieu de

if b != 0:
    quotient = false
else:
    quotient = a/b
1
Barmar 14 juil. 2015 à 21:16

Bien que le livre le présente d'une manière légèrement confuse, il est correct. La logique booléenne doit être évaluée à vrai ou faux.

Pour X et Y afin de retourner vrai, ils doivent tous les deux être vrais, si X est faux alors il retourne faux. Si X est vrai, il renvoie Y qui est vrai ou faux et aussi la bonne réponse.

Pour que X ou Y retournent faux, les deux doivent être faux. Si X est vrai, il peut retourner vrai (X). Si X est faux, il renvoie quelle que soit la valeur de Y.

1
bentup 14 juil. 2015 à 21:12

Votre livre a raison - voir la documentation . Cela peut ne pas être intuitif au début, mais ce comportement (appelé court-circuitage ) est extrêmement utile. Dans un cas simple, cela vous permet de gagner beaucoup de temps lors de la vérification de certaines conditions. Dans cet exemple, où la fonction f prend 10 secondes à évaluer, vous pouvez certainement voir une utilisation:

if f(foo) or f(bar) or f(baz):

Si f(foo) est True, il n'est pas nécessaire d'évaluer f(bar) ou f(baz), car la totalité de l'instruction if sera True. Ces valeurs sont inutiles et vous perdrez simplement votre temps à les calculer.

Une autre utilisation extrêmement courante de ce comportement est la vérification de null (ou pour python None). Il permet une utilisation sûre des fonctions sur une seule ligne:

if obj != None and obj.foo():

Si obj est None, l'instruction if est garantie d'être False, et il n'est donc pas nécessaire de vérifier (ni même d'évaluer) obj.foo(), ce qui est bien, car cela provoquerait une exception.

Le court-circuitage est très courant dans de nombreux langages de programmation et est très utile une fois que vous comprenez parfaitement comment l'utiliser.

1
Brien 14 juil. 2015 à 21:10

Contrairement à certaines autres langues, vous pouvez utiliser any objet comme opérandes d'opérations booléennes. Tout ce que dit votre livre, c'est que vous pouvez utiliser des opérateurs booléens comme un "filtre" rapide de valeurs.

Par exemple, supposons que vous souhaitiez choisir une liste non vide entre deux listes. Ce qui suit est une manière valide (et plus Pythonique) de le faire:

>>> [] or ['something', 'here']
['something', 'here']

Contrairement à (ne pas utiliser les idiomes Python en Python):

if len(l1) != 0:
  return l1
else:
  return l2
1
skytreader 14 juil. 2015 à 21:07

"Ne rien faire" n'est pas une option. L'expression mathématique x or y doit avoir une valeur (ce qui est vrai si x, y ou les deux sont vrais). Et x and y doit avoir une valeur (qui est vraie si et seulement si x et y sont tous les deux vrais).

La façon dont votre livre les définit est mathématiquement correcte, mais déroutante (jusqu'à ce que vous entriez dans des choses comme l'évaluation des courts-circuits).

4
Lee Daniel Crocker 14 juil. 2015 à 21:06