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

你的问题是在Python中是否有一个逻辑运算符，简单的答案是否：The docs列出布尔运算，而Python根本就没有这样的东西。

显然，正如Juampi's answer指出的那样，逻辑等效的操作稍微短一些，但没有单独的操作符。

Answer 3

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

Answer 4

有一个反向蕴涵算子：

if y ** x:
  do_sth()

这是：如果x暗示y。

致https://github.com/cosmologicon/pywat

的信用

Answer 5

基于我在这里和那里找到的内容，我正在寻找一个蕴涵运算符的其他细节：你可以使用一个聪明的黑客来定义自己的运算符。这是一个运行示例，注释了使用这些结果的源代码。

#!/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)

Answer 6

我认为更可读的单行将是

x_implies_y = y if x else True

在您的原始示例中：

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

Answer 7

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

 container: {
        flex: 1,
        alignItems: 'center',
        paddingHorizontal: 20,
        alignItems: 'flex-end'
        margin-top: 10%;
      },

由于xor（^）1等于不等于A

Answer 8

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

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

python中有一个蕴涵逻辑运算符吗？

8 个答案: