Эквивалент Python && (логический-и) в выражении if

Вот мой код:

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. Что я делаю неправильно?

Ответы

Ответ 1

Вам нужно and вместо &&.

Ответ 2

Python использует and и or условные обозначения.

то есть.

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

Ответ 3

Два комментария:

  • Используйте and и or для логических операций в Python.
  • Используйте 4 пробела для отступа вместо 2. Вы отблагодарите себя позже, потому что ваш код будет выглядеть примерно так же, как и все остальные. Подробнее см. PEP 8.

Ответ 4

Я получаю ошибку в условном 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 массивы и подклассы

Возможно, это немного выходит за рамки исходного вопроса, но в случае, если вы имеете дело с массивами или подклассами 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 для результата. Так что эти тонкие моменты могут не иметь отношения к вам.

Ответ 5

Я пошел с изрядно математическим решением:

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

Ответ 6

Вы используете 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

Надеюсь, это поможет!

Ответ 7

Возможно, это не лучший код для этой задачи, но работает -

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

Ответ 8

В "операторе If" в Python вы должны использовать и, или, нет, и они эквивалентны &&, ||,! логические операторы, которые используются в других языках программирования

Ответ 9

Использование "и" в условном выражении. Я часто использую это при импорте в 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

Ответ 10

Достаточно одного & (не двойного &&) или, как показывает верхний ответ, вы можете использовать "и". Я также нашел это в пандах

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

если мы заменим "&" на "и", это не сработает.

Ответ 11

возможно, и вместо этого% быстрее и удобнее читать

другие тесты четные/нечетные

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