Вот мой код:
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 условные обозначения.
то есть.
if foo == 'abc' and bar == 'bac' or zoo == '123':
# do something
Два комментария:
and и or для логических операций в Python.Я получаю ошибку в условном 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. Бинарные арифметические операции.
Логические операторы (как и во многих других языках) имеют то преимущество, что они закорочены. Это означает, что если первый операнд уже определяет результат, то второй оператор вообще не оценивается.
Чтобы показать это, я использую функцию, которая просто принимает значение, печатает его и возвращает снова. Это удобно, чтобы увидеть, что на самом деле оценивается из-за операторов печати:
>>> 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, они просто должны возвращать True или False когда bool вызывается для них (1).
Таким образом, в псевдокоде (!) Функции 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 left
else:
return evaluate(expr2)
Обратите внимание, что это псевдокод, а не код Python. В Python вы не можете создавать функции, вызываемые 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)
Если у вас нет метода __bool__ тогда Python также проверяет, есть ли у объекта метод __len__ и возвращает ли оно значение больше нуля. Это может быть полезно знать, если вы создаете контейнер последовательности.
Смотрите также 4.1. Проверка Истинного Значения.
Возможно, это немного выходит за рамки исходного вопроса, но в случае, если вы имеете дело с массивами или подклассами 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 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):
>>> 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 то он возвращает второй операнд:
>>> x1
Test(10)
>>> x2
Test(False)
Точно так же для or только наоборот:
>>> Test(True) or Test(10)
Test(True)
>>> Test(False) or Test(10)
Test(10)
Однако, если вы используете их в операторе if if также неявно вызовет bool для результата. Так что эти тонкие моменты могут не иметь отношения к вам.
Я пошел с изрядно математическим решением:
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:]
Вы используете and и or для выполнения логических операций, например, в 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
Надеюсь, это поможет!
Возможно, это не лучший код для этой задачи, но работает -
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:]
В "операторе If" в Python вы должны использовать и, или, нет, и они эквивалентны &&, ||,! логические операторы, которые используются в других языках программирования
Использование "и" в условном выражении. Я часто использую это при импорте в 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
Достаточно одного & (не двойного &&) или, как показывает верхний ответ, вы можете использовать "и". Я также нашел это в пандах
cities['Is wide and has saint name'] = (cities['Population'] > 1000000)
& cities['City name'].apply(lambda name: name.startswith('San'))
если мы заменим "&" на "и", это не сработает.
возможно, и вместо этого% быстрее и удобнее читать
другие тесты четные/нечетные
x четно? x% 2 == 0
x нечетно? не x% 2 == 0
может быть более понятным с поразрядным и 1
x нечетно? x и 1
x четно? не x и 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