19

我想用python写一个具有逻辑含义的语句。就像是：

if x => y:
  do_sth()

当然，我知道我可以使用：

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

但是在 python 中有一个逻辑运算符吗？

4

8 回答 8

31

p => q是一样的not(p) or q，所以你可以试试！

于 2013-05-06T19:37:33.827 回答
13

只是因为它很有趣：x => y 可能bool(x) <= bool(y)在 python 中。

于 2015-10-07T15:27:44.073 回答
7

有一个逆蕴涵运算符：

if y ** x:
  do_sth()

内容为：如果 y 被 x 隐含。

归功于https://github.com/cosmologicon/pywat

于 2015-11-17T23:04:35.943 回答
6

您的问题询问 Python 中是否有一个逻辑运算符，简单的答案是否定的：文档列出布尔运算，而 Python 根本没有类似的东西。

显然，正如Juampi 的回答所指出的那样，有一些逻辑上等效的操作要短一些，但没有你问的单个操作符。

于 2013-05-06T19:38:34.830 回答
2

基于我在这里和那里找到的其他详细信息，因为我正在寻找一个隐含运算符：您可以使用巧妙的技巧来定义自己的运算符。这是一个运行示例，其中注释了导致我得出此结果的来源。

#!/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)
于 2014-03-28T16:32:18.757 回答
1

我认为更易读的单行将是

x_implies_y = y if x else True

在您的原始示例中：

if (y if x else True): do_sth()
于 2017-05-02T04:21:41.857 回答
0

您可以使用比较运算符<=来获得两个变量的含义。 例子：

A   B   A <- B  A <= B
0   0   1       1
0   1   1       1
1   0   0       0
1   1   1       1
于 2020-12-22T08:27:56.700 回答
0

我发现 XOR 是一个很好的解决方案。您可以将 A 隐含 B 更改为不是 A 或 B。然后您使用 xor 来否定 A 像这样

A^1 or B

因为 A xor(^) 1 等于 not A

于 2020-11-13T08:31:19.153 回答