Я хотел бы написать инструкцию в python с логической импликацией. Что-то вроде:Есть ли логический оператор implication в python?
if x => y:
do_sth()
Конечно, я знаю, что я мог бы использовать:
if (x and y) or not x:
do_sth()
Но есть логический оператор для этого в Python?
p => q такое же, как not(p) or q, так что вы можете попробовать это!
В этом вопросе спрашивается, существует ли в Python один логический оператор, простой ответ - нет: The docs список логических операций, а Python просто не имеет ничего подобного.
Очевидно, что, как указывает Juampi's answer, существуют логически эквивалентные операции, которые немного короче, но не один оператор, как вы просили.
Пожалуйста, взгляните на [это] (http://stackoverflow.com/questions/16405892/is-there-an-implication-logical-operator-in-python/33768787#33768787) ответ. Похоже, что не все можно найти в [docs] (http://docs.python.org/3.3/reference/expressions.html#boolean-operations). –
@ running.t Это не в документах, потому что этот ответ неверен - такого оператора нет, вместо этого это злоупотребление другим оператором, который приводит к тому же результату. Конечным результатом использования этого будет ужасно нечеткий, неэффективный код, который может привести к ошибкам. –
Дополнительная информация, основанная на том, что я нашел здесь и там, когда искал оператор импликации: вы можете использовать умный хак для определения своих собственных операторов. Вот пример выполнения, аннотированный источниками, приводящими меня к этому результату.
#!/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)
Просто потому, что это забавно: х => у может быть в питоне bool(x) <= bool(y).
И это (наконец) убедительное доказательство того, что 'True' должно быть' -1', а 'False' должно быть' 0' для булевых! (Вместо текущего соглашения Python от 'True == 1'.) Потому что тогда у нас будет' x => y' соответствие 'y <= x' (что похоже на импликацию справа налево) для booleans. –
Существует обратная импликация оператор:
if y ** x:
do_sth()
Это гласит: Если у вытекает х.
Да. Это именно то, что я искал. И похоже, что эта обратная импликация недокументирована, поэтому ответ @Latty в основном неверен. –
@running.t Это то, что имеет тот же эффект, что и 'x => y', но не является оператором для этой цели. Это оператор мощности и не является логическим оператором, а является числовым. Он не возвращает «True» или «False», а число. Это медленнее и потенциально может привести к ошибкам, не говоря уже о невероятно неясном и трудном для чтения. Я бы * настоятельно рекомендовал против этого делать, а вместо этого использовал бы 'not (p) или q' в соответствии с ответом [Juampi] (http://stackoverflow.com/a/16405931/722121). –
я бы поспорил более читаемым Однострочник бы
x_implies_y = y if x else True
В оригинальном примере:
if (y if x else True): do_sth()
И это проще, чем (х и у) или нет x. Спасибо –
TTL согласен - но это не обязательно так легко увидеть в коде, хотя и проще оригинала. Функция - то есть «подразумевает (x, y)» - может помочь с большей передачей идеи, если такая конструкция происходит достаточно часто, чтобы гарантировать имя. – user2246674
@ user2246674 Согласен, я рекомендовал бы сделать это функцией для ясности. –