这是我的代码：
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条件中遇到错误。我做错了什么？
答案 0 :(得分：1265)
您需要and代替&&。
答案 1 :(得分：205)
Python使用and和or条件。
即
if foo == 'abc' and bar == 'bac' or zoo == '123':
# do something
答案 2 :(得分：35)
两条评论：
and和or进行Python中的逻辑操作。答案 3 :(得分：24)
我在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 documentation: 6.11. Boolean operations。
除了逻辑运算符外，Python还具有按位/二进制运算符：
+--------------------+--------------------+
| Logical operator | Bitwise operator |
+====================+====================+
| and | & |
+--------------------+--------------------+
| or | | |
+--------------------+--------------------+
Python中没有按位取反（只是按位逆运算符~-不不等同于not）。
另请参阅6.6. Unary arithmetic and bitwise/binary operations和6.7. Binary arithmetic operations。
逻辑运算符（像许多其他语言一样）具有使它们短路的优点。 这意味着，如果第一个操作数已经定义了结果，则根本不会评估第二个运算符。
为了显示这一点，我使用了一个简单地使用值，将其打印并再次返回的函数。方便查看实际情况 由于打印语句而被评估：
>>> 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);
False
True
但是，如果第一个操作数不够用，那么第二个运算符当然会被求值：
>>> res = print_and_return(True) and print_and_return(False);
True
False
总结一下，这是另一个表：
+-----------------+-------------------------+
| Expression | Right side evaluated? |
+=================+=========================+
| `True` and ... | Yes |
+-----------------+-------------------------+
| `False` and ... | No |
+-----------------+-------------------------+
| `True` or ... | No |
+-----------------+-------------------------+
| `False` or ... | Yes |
+-----------------+-------------------------+
True和False代表bool(left-hand-side)返回的内容，它们不必是True或False，它们只需要返回{{ 1}}或True，当它们被调用False时（1）。
因此在伪代码（！）中，bool和and函数的工作方式如下：
or请注意，这是伪代码，而不是Python代码。在Python中，您无法创建名为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)
或and的函数，因为它们是关键字。
另外，您永远不要使用“评估”或or。
此隐式if bool(...)调用可用于自定义类在bool，and和or中的行为。
为了展示如何进行自定义，我使用了该类，它再次not提供一些信息来跟踪正在发生的事情：
print因此，让我们看看该类与这些运算符结合会发生什么：
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)
方法，Python还将检查对象是否具有__bool__方法，以及它是否返回大于零的值。
如果您创建了序列容器，可能会很有用。
可能超出了原始问题的范围，但是如果您要处理NumPy数组或子类（例如Pandas Series或DataFrames），则将进行隐式__len__调用
将引发可怕的bool：
ValueError在这些情况下，您可以使用NumPy的逻辑和函数，它们执行逐元素的>>> 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().
（或and）：
or如果仅处理布尔数组，则还可以将二进制运算符与NumPy一起使用，它们确实会执行逐元素比较（也可以是二进制）：
>>> 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])
（1）
对操作数的>>> 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])
调用必须返回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与>>> x1
Test(10)
>>> x2
Test(False)
类似，但相反：
or但是，如果您在>>> Test(True) or Test(10)
Test(True)
>>> Test(False) or Test(10)
Test(10)
语句中使用它们，则if也会隐式地对结果调用if。因此，这些要点可能与您无关。
答案 4 :(得分：10)
我选择了一个简单的数学解决方案：
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:]
答案 5 :(得分：8)
您使用 and和or 来执行C，C ++等逻辑操作。就像字面意思 and是&&而or是|| 。
假设您想在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)
False
True
希望这有帮助！
答案 6 :(得分：5)
这可能不是此任务的最佳代码，但正在运行 -
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:]
答案 7 :(得分：0)
在Python的“ If语句”中，您将使用和/或不，这些等效于 &&，||，！逻辑运算符，其他编程语言
答案 8 :(得分：-1)
使用＆＃34;和＆＃34;有条件的。我在Jupyter Notebook中导入时经常使用它：
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
答案 9 :(得分：-1)
单个&（不是双&&）就足够了，或者最佳答案建议你可以使用'和'。
我也在熊猫中找到了这个
cities['Is wide and has saint name'] = (cities['Population'] > 1000000)
& cities['City name'].apply(lambda name: name.startswith('San'))
如果我们更换“＆amp;”与“和”，它将无法正常工作。
答案 10 :(得分：-2)
也许与＆amp;相反，％更快，保持可读性
其他测试偶数/奇数
x甚至是？ x％2 == 0x是奇数？不是x％2 == 0
也许用bitwise和1
更清楚x是奇数？ x＆amp; 1
x甚至是？不是x＆amp; 1（不奇怪）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