Je voudrais écrire une déclaration en python avec une implication logique. Quelque chose comme:Existe-t-il un opérateur logique d'implication dans python?
if x => y:
do_sth()
Bien sûr, je sais que je pourrais utiliser:
if (x and y) or not x:
do_sth()
Mais est-il un opérateur logique pour cela en python?
p => q est le même que not(p) or q, donc vous pouvez essayer ça!
Votre question demande s'il existe un seul opérateur logique pour cela en Python, la réponse simple est non: The docs list boolean operations, et Python n'a tout simplement rien de tel. De toute évidence, comme le souligne Juampi's answer, il existe des opérations logiquement équivalentes qui sont un peu plus courtes, mais pas d'opérateurs uniques comme vous le demandiez.
S'il vous plaît jeter un oeil à [this] (http://stackoverflow.com/questions/16405892/is-there-an-implication-logical-operator-in-python/33768787#33768787) réponse. Il semble que tout ne puisse pas être trouvé dans [docs] (http://docs.python.org/3.3/reference/expressions.html#boolean-operations). –
@ running.t Il n'est pas dans les docs parce que cette réponse est fausse - il n'y a pas un tel opérateur, à la place, c'est un abus d'un autre opérateur qui arrive à produire le même résultat. Le résultat final de l'utilisation de ce serait horriblement unlcear, code inefficace qui peut introduire des bogues. –
Des détails supplémentaires basés sur ce que j'ai trouvé ici et là comme je cherchais un opérateur d'implication: vous pouvez utiliser un astucieux bidouillage pour définir vos propres opérateurs. Voici un exemple en cours annoté avec des sources qui m'amènent à ce résultat.
#!/usr/bin/python
# From http://code.activestate.com/recipes/384122/ (via http://stackoverflow.com/questions/932328/python-defining-my-own-operators)
class Infix:
def __init__(self, function):
self.function = function
def __ror__(self, other):
return Infix(lambda x, self=self, other=other: self.function(other, x))
def __rlshift__(self, other):
return Infix(lambda x, self=self, other=other: self.function(other, x))
def __or__(self, other):
return self.function(other)
def __rshift__(self, other):
return self.function(other)
def __call__(self, value1, value2):
return self.function(value1, value2)
from itertools import product
booleans = [False,True]
# http://stackoverflow.com/questions/16405892/is-there-an-implication-logical-operator-in-python
# http://jacob.jkrall.net/lost-operator/
operators=[
(Infix(lambda p,q: False), "F"),
(Infix(lambda p,q: True), "T"),
(Infix(lambda p,q: p and q), "&"),
(Infix(lambda p,q: p or q) , "V"),
(Infix(lambda p,q: p != q) , "^"),
(Infix(lambda p,q: ((not p) or not q)), "nad"),
(Infix(lambda p,q: ((not p) and not q)), "nor"),
(Infix(lambda p,q: ((not p) or q)), "=>"),
]
for op,sym in operators:
print "\nTruth tables for %s" % sym
print "\np\tq\tp %s q\tq %s p" % (sym,sym)
for p,q in product(booleans,repeat=2):
print "%d\t%d\t%d\t%d" % (p,q,p |op| q,q |op| p)
print "\np\tq\tr\tp %s q\tq %s r\t(p %s q) %s r\tp %s (q %s r)\tp %s q %s r" % (sym,sym,sym,sym,sym,sym,sym,sym)
for p,q,r in product(booleans,repeat=3):
print "%d\t%d\t%d\t%d\t%d\t%d\t\t%d\t\t%d" % (p,q,r,p |op| q,q |op| r, (p |op| q) |op| r, p |op| (q |op| r), p |op| q |op| r)
assert((p |op| q) |op| r == p |op| q |op| r)
Juste parce qu'il est drôle: x => y pourrait être bool(x) <= bool(y) en python.
Et c'est (enfin) la preuve concluante que 'True' devrait être' -1' et 'False' devrait être' 0' pour les booléens! (Au lieu de la convention Python actuelle de 'True == 1'.) Parce que alors nous aurions' x => y' correspondant 'y <= x' (qui ressemble à une implication de droite à gauche) pour les booléens. –
Il y a un opérateur contrario:
if y ** x:
do_sth()
Ce lit comme suit: Si y est sous-entendu par x.
Crédits à https://github.com/cosmologicon/pywat
Oui. Ceci est exactement ce que je cherchais. Et il semble que cette implication inverse n'est pas documentée, donc la réponse de @Latty est fondamentalement incorrecte. –
@running.t C'est quelque chose qui a le même effet que 'x => y', mais qui n'est pas un opérateur à cette fin. C'est l'opérateur de puissance, et n'est pas un opérateur logique, mais un opérateur numérique. Il ne renvoie pas "True" ou "False", mais un nombre. Ceci est plus lent, et pourrait potentiellement introduire des bogues, pour ne pas mentionner être incroyablement peu clair et difficile à lire. Je recommanderais fortement de ne jamais le faire, et j'utiliserais à la place 'not (p) ou q' selon [la réponse de Juampi] (http://stackoverflow.com/a/16405931/722121). –
Je dirais un plus facile à lire en une ligne serait
x_implies_y = y if x else True
Dans votre exemple original:
if (y if x else True): do_sth()
Et c'est plus simple que (x et y) ou pas x. Merci –
La TTL est d'accord - mais ce n'est pas nécessairement si facile à voir dans le code, bien que plus simple que l'original. Une fonction - c'est-à-dire 'implique (x, y)' - pourrait aider à transférer davantage l'idée, si une telle construction se produit assez souvent pour justifier un nom. – user2246674
@ user2246674 D'accord, je recommanderais d'en faire une fonction pour plus de clarté. –