Python相当于if语句中的&&（logical-and）

这行不通：

if cond1 && cond2:
2736389 次浏览
小开
最佳答案

使用and而不是&&。

小开

Python使用and和or条件。

即

if foo == 'abc' and bar == 'bac' or zoo == '123':# do something
小开

两点评论：

  • 在Python中使用and和or进行逻辑操作。
  • 使用4个空格而不是2缩进。您稍后会感谢自己，因为您的代码看起来与其他人的代码几乎相同。有关更多详细信息，请参阅PEP 8。
小开

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

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:]
小开

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

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:]
小开

您使用#0和#1来执行逻辑操作，就像在C、C++中一样。就像字面上的#0是#3，#1是#5。

看看这个有趣的例子，

假设你想用Python构建逻辑门： 

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

现在试着打电话给他们： 

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

这将输出：

FalseTrue

希望这有帮助！

小开

在条件中使用“和”。我经常在Jupyter Notebook中导入时使用它：

def find_local_py_scripts():import os # does not cost if already importedfor entry in os.scandir('.'):# find files ending with .pyif entry.is_file() and entry.name.endswith(".py") :print("- ", entry.name)find_local_py_scripts()
-  googlenet_custom_layers.py-  GoogLeNet_Inception_v1.py
小开

一个&（不是两个&&）就足够了，或者正如上面的答案所建议的那样，你可以使用“和”。我也在熊猫身上找到了这个

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

如果我们将“&”替换为“and”，它将不起作用。

小开

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

你得到SyntaxError的原因是Python中没有&&运算符。同样，||和!是无效 Python运算符。

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

所以你可以写：

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

甚至：

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

一些额外的信息（可能会派上用场）：

我总结了这个表中的运算符“等价物”：

+------------------------------+---------------------+|  Operator (other languages)  |  Operator (Python)  |+==============================+=====================+|              &&              |         and         |+------------------------------+---------------------+|              ||              |         or          |+------------------------------+---------------------+|              !               |         not         |+------------------------------+---------------------+

另见Python留档： 6.11.布尔运算。

除了逻辑运算符之外，Python还有按位/二进制运算符：

+--------------------+--------------------+|  Logical operator  |  Bitwise operator  |+====================+====================+|        and         |         &          |+--------------------+--------------------+|         or         |         |          |+--------------------+--------------------+

Python中没有按位否定（只有按位逆运算符~-但这是没有等价于not）。

请参阅6.6.一元算术和按位/二进制运算和6.7.二进制算术运算。

逻辑运算符（与许多其他语言一样）的优点是它们是短路的。这意味着如果第一个操作数已经定义了结果，则根本不计算第二个操作符。

为了显示这一点，我使用了一个函数，它只是接受一个值，打印它并再次返回它。这很方便查看实际是什么由于print语句而计算：

>>> def print_and_return(value):...     print(value)...     return value
>>> res = print_and_return(False) and print_and_return(True)False

正如你所看到的，只有一个print语句被执行，所以Python实际上甚至没有看正确的操作数。

二元运算符并非如此。它们总是评估两个操作数：

>>> res = print_and_return(False) & print_and_return(True);FalseTrue

但是，如果第一个操作数不够，那么当然会评估第二个运算符：

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

总结一下，这里是另一个表格：

+-----------------+-------------------------+|   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（1）。

所以在Pseudo-Code（！）中，and和or函数的工作方式如下：

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 leftelse:return evaluate(expr2)

请注意，这是伪代码而不是Python代码。在Python中，您不能创建名为and或or的函数，因为这些是关键字。你也不应该使用“评估”或if bool(...)。

自定义您自己的类的行为

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

为了展示如何自定义，我使用这个类来跟踪正在发生的事情：

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)

因此，让我们看看该类与这些运算符组合会发生什么：

>>> 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 Series或DataFrames），那么隐式bool调用将提高可怕的ValueError：

>>> 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 arrValueError: 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 sValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

在这些情况下，您可以使用NumPy中的逻辑和函数，它执行元素and（或or）：

>>> 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的二进制运算符，这些运算符确实执行元素（但也是二进制）比较：

>>> 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__方法中返回布尔值的操作数：

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)

这是因为and实际上返回第一个操作数，如果第一个操作数的计算结果为False，如果它的计算结果为True，则它返回第二个操作数：

>>> x1Test(10)>>> x2Test(False)

类似于or，但正好相反：

>>> Test(True) or Test(10)Test(True)>>> Test(False) or Test(10)Test(10)

但是，如果您在if语句中使用它们，if也会隐式调用结果的bool。所以这些细微之处可能与您无关。


提交答案