Существует ли логический оператор импликации в python?

Question

Я хотел бы написать заявление на python с логическим подтекстом. Что-то вроде:

if x => y:
  do_sth()

Конечно, я знаю, что мог бы использовать:

if (x and y) or not x:
  do_sth()

Но есть ли логический оператор для этого в Python?

Answer 1

p => q такой же как not(p) or qтак что вы можете попробовать это!

Answer 2

Просто потому, что это смешно: х => у может быть bool(x) <= bool(y) в питоне.

Answer 3

Существует обратный имплицитный оператор:

if y ** x:
  do_sth()

Это гласит: если у подразумевается х.

Кредиты для https://github.com/cosmologicon/pywat

Answer 4

Ваш вопрос спрашивает, есть ли в Python один логический оператор для этого, простой ответ - нет: булевы операции со списком документов, а в Python просто нет ничего подобного.

Очевидно, как указывает ответ Джуампи, есть логически эквивалентные операции, которые немного короче, но нет ни одного оператора, как вы просили.

Answer 5

Я бы сказал, что более читаемая однострочная

x_implies_y = y if x else True

В вашем оригинальном примере:

if (y if x else True): do_sth()

Answer 6

Дополнительные сведения основаны на том, что я нашел здесь и там, когда искал оператор импликации: вы можете использовать хитрый хак для определения ваших собственных операторов. Вот бегущий пример, снабженный источниками, ведущими меня к этому результату.

#!/usr/bin/python

# From http://code.activestate.com/recipes/384122/ (via http://stackru.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://stackru.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)

Answer 7

Вы можете использовать оператор сравнения <=чтобы получить импликацию для двух переменных.Примеры:

      A   B   A <- B  A <= B
0   0   1       1
0   1   1       1
1   0   0       0
1   1   1       1

Answer 8

Я нашел XOR хорошим решением. вы можете изменить A подразумевает B на не A или B. Затем вы используете xor, чтобы отрицать A, как это

A^1 or B

Поскольку A xor(^) 1 не равно A