Вот мой код:
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.Я'м получаю сообщение об ошибке в случае, если условно. Что я делаю не так?
Есть причина, что вы получаете синтаксис ошибка
нет и усилитель; &
оператор в Python. Аналогично ||
и!
и не действует операторы языка Python.
Некоторые из операторов, которых вы можете знать из других языков имеют разные имена в Python.
Логические операторы и усилитель; &
и ||
на самом деле называется " и " и "или".
Аналогичным образом логический оператор отрицания !
называется не
.
Так что вы могли бы просто написать:
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 (просто побитовое обратный оператор ~
- но это **** не эквивалентно "не").
См. также 6.6. Унарные арифметические и побитовые/бинарные operations и 6.7. Бинарные арифметические операции.
Логические операторы (как и во многих других языках) имеют то преимущество, что это короткое замыкание. Это означает, что если первый операнд уже определяет результат, то второе оператора, это'т оценивала вообще.
Чтобы показать это, я использую функцию, которая просто принимает значение, печатает его и снова возвращает его. Это удобно, чтобы увидеть, что на самом деле оценку из-за печати заявления:
>>> def print_and_return(value):
... print(value)
... return value
>>> res = print_and_return(False) and print_and_return(True)
False
Как вы можете видеть, выполняется только один оператор печати, так что питон действительно не'т даже смотреть на правый операнд.
Это не тот случай для бинарных операторов. Они всегда оценивают оба операнда:
>>> 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(левая сторона)возвращает, они не'т иметь, чтобы быть
trueили
false, они просто должны вернуть
trueили
falseесли
логическое` называется на их <суп>(1)<суп>.
Так в псевдо-код(!) функции " и " и " или " работать, как эти:
в
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 вы не можете создавать функции называется и
или или
потому что это ключевые слова.
Также вы никогда не должны использовать на "оценить" или если значение bool(...)`.
Назвать этот неявный буль
может использоваться, чтобы настроить, как ведут себя классы с и
, или
и не
.
Чтобы показать, как это можно настроить, я использую этот класс, который снова печатать что-то отслеживать, что происходит:
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)
Если вы Don'т убоол - тогда Python также проверяет, если объект имеет методлен и если она возвращает значение больше нуля. Что может быть полезно знать, в случае вы создаете контейнер последовательности.
См. также 4.1. Правда испытания значение.
Возможно, несколько выходит за рамки первоначального вопроса, но в случае, если вы'ре дело с библиотеки numpy массивы или подклассы (как панды серии или таблицы данных), то неявный буль
звоните
поднимет 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, который выполняет элемент-мудрый " и "(или "или"):
>>> 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])
Если вы'повторно дело только с boolean массивы вы могли бы также использовать бинарные операторы с библиотеки 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)<суп>
Что буль
призываем операндов должен вернуть true
или false
это'т совершенно верно. Это's просто первый операнд, который должен возвращать логическое в его'ы `типа 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)
Что's, потому что " и "на самом деле возвращает первый операнд, если первый операнд имеет значение "ложь", и если это выполнено, то она возвращает второй операнд:
>>> x1
Test(10)
>>> x2
Test(False)
Аналогично для Или
А как раз наоборот:
>>> Test(True) or Test(10)
Test(True)
>>> Test(False) or Test(10)
Test(10)
Однако, если вы используете их в если
заявление Если
также будет неявно вызвать буль
на результат. Так что эти тонкости могут быть не актуальны для вас.
Я пошел с purlely математическое решение:
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:]
Вы используете и
и или
для выполнения логических операций, как в C, с++. Как буквально и
это и усилитель; &
и или
является ||
.
Предположим, вы хотите построить логические ворота в 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:]
Использование "и" в условных. Я часто пользуюсь этим при импорте в тетради Jupyter:
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'))
если заменить на "&ампер;" с "и" он выиграл'т работу.
может быть, с & а не % более быстрой и поддерживать читаемость
другие тесты четный/нечетный
х даже ? х % 2 == 0
х-нечетное ? не x % 2 == 0
может быть, более ясно с побитовым и 1
х-нечетное ? х & 1
х даже ? не х & 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