python在if语句中相当于&&(逻辑与)


Python's equivalent of && (logical-and) in an if-statement

以下是我的代码：

1
2
3
4
5
6
7
def front_back(a, b):
  # +++your code here+++
  if len(a) % 2 == 0 && len(b) % 2 == 0:
    return a[:(len(a)/2)] + b[:(len(b)/2)] + a[(len(a)/2):] + b[(len(b)/2):]
  else:
    #todo! Not yet done. :P
  return

我在if条件中得到一个错误。我做错什么了？

相关讨论

你想要的是and，而不是&&。

相关讨论

python使用and和or条件。

即

1
2
if foo == 'abc' and bar == 'bac' or zoo == '123':
  # do something
相关讨论

两个评论：

  • 在python中使用and和or进行逻辑操作。
  • 使用4个空格来缩进，而不是2个。稍后您将感谢自己，因为您的代码看起来与其他人的代码几乎相同。更多详情请参见PEP 8。

I'm getting an error in the IF conditional. What am I doing wrong?

Ok.

之所以得到SyntaxError是因为python中没有&&操作符。同样，||和!不是有效的python运算符。好的。

在python中，您可能从其他语言中知道的一些操作符有不同的名称。逻辑运算符&&和||实际上称为and和or。同样，逻辑否定算子!称为not。好的。

所以你可以写：好的。

1
if len(a) % 2 == 0 and len(b) % 2 == 0:

甚至：好的。

1
if not (len(a) % 2 or len(b) % 2):

一些附加信息(可能很有用)：

我总结了下表中的"等效"运算符：好的。

1
2
3
4
5
6
7
8
9
+------------------------------+---------------------+
|  Operator (other languages)  |  Operator (Python)  |
+==============================+=====================+
|              &&              |         and         |
+------------------------------+---------------------+
|              ||              |         or          |
+------------------------------+---------------------+
|              !               |         not         |
+------------------------------+---------------------+

另请参见python文档：6.11。布尔运算。好的。

除了逻辑运算符之外，python还具有位/二进制运算符：好的。

1
2
3
4
5
6
7
+--------------------+--------------------+
|  Logical operator  |  Bitwise operator  |
+====================+====================+
|        and         |         &          |
+--------------------+--------------------+
|         or         |         |          |
+--------------------+--------------------+

python中没有按位求反(只使用按位求反的操作符~，但它不等同于not。好的。

也见6.6。一元算术和位/二进制运算以及6.7。二进制算术运算。好的。

逻辑运算符(与许多其他语言一样)的优点是它们是短路的。这意味着，如果第一个操作数已经定义了结果，那么第二个操作数就不会被计算出来。好的。

为了证明这一点，我使用了一个函数，它只获取一个值，打印它并再次返回它。这很方便看到底是什么由于打印语句而评估：好的。

1
2
3
4
5
6
>>> def print_and_return(value):
...     print(value)
...     return value

>>> res = print_and_return(False) and print_and_return(True)
False

正如您所看到的，只执行了一条print语句，所以python甚至没有查看正确的操作数。好的。

这不是二进制运算符的情况。它们总是同时计算两个操作数：好的。

1
2
3
>>> res = print_and_return(False) & print_and_return(True);
False
True

但是，如果第一个操作数不够，那么当然要计算第二个操作数：好的。

1
2
3
>>> res = print_and_return(True) and print_and_return(False);
True
False

要总结这一点，这里有另一个表：好的。

1
2
3
4
5
6
7
8
9
10
11
+-----------------+-------------------------+
|   Expression    |  Right side evaluated?  |
+=================+=========================+
| `True` and ...  |           Yes           |
+-----------------+-------------------------+
| `False` and ... |           No            |
+-----------------+-------------------------+
|  `True` or ...  |           No            |
+-----------------+-------------------------+
| `False` or ...  |           Yes           |
+-----------------+-------------------------+

True和False代表bool(left-hand-side)返回的内容，它们不必是True或False，只要在bool被调用时返回True或False。好的。

所以在伪代码中(！)and和or功能的工作方式如下：好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
def and(expr1, expr2):
    left = evaluate(expr1)
    if bool(left):
        return evaluate(expr2)
    else:
        return left

def or(expr1, expr2):
    left = evaluate(expr1)
    if bool(left):
        return left
    else:
        return evaluate(expr2)

请注意，这是伪代码，而不是Python代码。在python中，不能创建名为and或or的函数，因为它们是关键字。此外，您不应使用"评估"或if bool(...)。好的。自定义自己类的行为

这个隐式的bool调用可用于自定义类在and、or和not中的行为。好的。

为了展示如何定制，我使用这个类，它也是print用来跟踪正在发生的事情：好的。

1
2
3
4
5
6
7
8
9
10
11
12
class Test(object):
    def __init__(self, value):
        self.value = value

    def __bool__(self):
        print('__bool__ called on {!r}'.format(self))
        return bool(self.value)

    __nonzero__ = __bool__  # Python 2 compatibility

    def __repr__(self):
        return"{self.__class__.__name__}({self.value})".format(self=self)

那么让我们看看这个类与这些操作符组合后会发生什么：好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> if Test(True) and Test(False):
...     pass
__bool__ called on Test(True)
__bool__ called on Test(False)

>>> if Test(False) or Test(False):
...     pass
__bool__ called on Test(False)
__bool__ called on Test(False)

>>> if not Test(True):
...     pass
__bool__ called on Test(True)

如果没有__bool__方法，那么python还会检查对象是否有__len__方法，以及是否返回大于零的值。在创建序列容器的情况下，了解这一点可能很有用。好的。

也见4.1。真值测试。好的。numpy数组和子类

可能有点超出了原始问题的范围，但如果您处理的是numpy数组或子类(如pandas系列或数据帧)，则隐式bool调用将引起恐惧的ValueError：好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> import numpy as np
>>> arr = np.array([1,2,3])
>>> bool(arr)
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
>>> arr and arr
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

>>> import pandas as pd
>>> s = pd.Series([1,2,3])
>>> bool(s)
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
>>> s and s
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

在这些情况下，可以使用numpy的逻辑和函数，该函数执行元素导向的and或or：好的。

1
2
3
4
>>> np.logical_and(np.array([False,False,True,True]), np.array([True, False, True, False]))
array([False, False,  True, False])
>>> np.logical_or(np.array([False,False,True,True]), np.array([True, False, True, False]))
array([ True, False,  True,  True])

如果只处理布尔数组，也可以使用带numpy的二进制运算符，这些运算符执行元素(但也执行二进制)比较：好的。

1
2
3
4
>>> np.array([False,False,True,True]) & np.array([True, False, True, False])
array([False, False,  True, False])
>>> np.array([False,False,True,True]) | np.array([True, False, True, False])
array([ True, False,  True,  True])

(1)好的。

对操作数的bool调用必须返回True或False不是完全正确的。它只是第一个操作数，需要在它的__bool__方法中返回一个布尔值：好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Test(object):
    def __init__(self, value):
        self.value = value

    def __bool__(self):
        return self.value

    __nonzero__ = __bool__  # Python 2 compatibility

    def __repr__(self):
        return"{self.__class__.__name__}({self.value})".format(self=self)

>>> x = Test(10) and Test(10)
TypeError: __bool__ should return bool, returned int
>>> x1 = Test(True) and Test(10)
>>> x2 = Test(False) and Test(10)

这是因为，如果第一个操作数的计算结果为False，则and实际返回第一个操作数；如果第一个操作数的计算结果为True，则返回第二个操作数：好的。字母名称(P)类人猿为EDOCX1的英文字母0，但只是其他的方式周围：好的，好的。字母名称(P)然而，如果你使用他们在一个EDOCX1中的一个音节中的话，So these finder points may not be relevant for you.好的，好的。好吧。

相关讨论

我用了一个简单的数学解：

1
2
def front_back(a, b):
  return a[:(len(a)+1)//2]+b[:(len(b)+1)//2]+a[(len(a)+1)//2:]+b[(len(b)+1)//2:]
相关讨论

您使用EDCOX1 0和EDCOX1 3来执行逻辑操作，如C、C++。就像字面上的and是&&，or是||。

看看这个有趣的例子，

假设您想在python中构建逻辑门：

1
2
3
4
5
def AND(a,b):
    return (a and b) #using and operator

def OR(a,b):
    return (a or b)  #using or operator

现在试着给他们打电话：

1
2
print AND(False, False)
print OR(True, False)

这将输出：

1
2
False
True

希望这有帮助！

这可能不是此任务的最佳代码，但正在工作-

1
2
3
4
5
6
7
8
9
10
11
12
13
def front_back(a, b):

 if len(a) % 2 == 0 and len(b) % 2 == 0:
    print a[:(len(a)/2)] + b[:(len(b)/2)] + a[(len(a)/2):] + b[(len(b)/2):]

 elif len(a) % 2 == 1 and len(b) % 2 == 0:
    print a[:(len(a)/2)+1] + b[:(len(b)/2)] + a[(len(a)/2)+1:] + b[(len(b)/2):]

 elif len(a) % 2 == 0 and len(b) % 2 == 1:
     print a[:(len(a)/2)] + b[:(len(b)/2)+1] + a[(len(a)/2):] + b[(len(b)/2)+1:]

 else :
     print a[:(len(a)/2)+1] + b[:(len(b)/2)+1] + a[(len(a)/2)+1:] + b[(len(b)/2)+1:]

一个单一的&(不是双&&)就足够了，或者正如上面的答案所建议的那样，你可以使用'and'。我在熊猫身上也发现了这个

1
2
cities['Is wide and has saint name'] = (cities['Population'] > 1000000)
& cities['City name'].apply(lambda name: name.startswith('San'))

如果我们用"and"替换"&；"，它将不起作用。

相关讨论

有条件地使用"和"。在Jupyter笔记本中导入时，我经常使用：

1
2
3
4
5
6
7
8
9
10
def find_local_py_scripts():
    import os # does not cost if already imported
    for entry in os.scandir('.'):
        # find files ending with .py
        if entry.is_file() and entry.name.endswith(".py") :
            print("-", entry.name)
find_local_py_scripts()

-  googlenet_custom_layers.py
-  GoogLeNet_Inception_v1.py
相关讨论

也许与&；相反，%更快速，更容易阅读。

其他测试偶数/奇数

X是偶数？x% 2＝0

X是奇怪的？不是x% 2＝＝0

可能更清楚的是位和1

X是奇怪的？X＆P；1

X是偶数？非X&1(非奇数)

1
2
3
4
5
6
7
def front_back(a, b):
    # +++your code here+++
    if not len(a) & 1 and not len(b) & 1:
        return a[:(len(a)/2)] + b[:(len(b)/2)] + a[(len(a)/2):] + b[(len(b)/2):]
    else:
        #todo! Not yet done. :P
    return