Python'эквивалент && (logical-and) в 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. Что я делаю неправильно?

Stevoisiak
Редактировал вопрос 23-го мая 2018 в 7:50
Программирование
python if-statement keyword logical-operators and-operator
21-го марта 2010 в 1:23
46 просмотров
Комментарии к вопросу (9)
Решение

Вы хотите использовать and вместо &&&.

Комментарии (6)

В Python используются условия and и or.

т.е.

if foo == 'abc' and bar == 'bac' or zoo == '123':
  # do something
detly
Редактировал ответ 7-го ноября 2013 в 3:15
Комментарии (6)

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

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

Я'м получаю сообщение об ошибке в случае, если условно. Что я делаю не так?

Есть причина, что вы получаете синтаксис ошибка нет и усилитель; & оператор в 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(левая сторона)возвращает, они не&#39;т иметь, чтобы быть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 массивы и подклассы

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

Однако, если вы используете их в если заявление Если также будет неявно вызвать буль на результат. Так что эти тонкости могут быть не актуальны для вас.

MSeifert
Редактировал ответ 1-го июля 2018 в 10:19
Комментарии (0)

Я пошел с 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:]
Big Red
Редактировал ответ 10-го июня 2014 в 7:27
Комментарии (1)

Вы используете и и или для выполнения логических операций, как в 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

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

MarianD
Редактировал ответ 22-го июля 2017 в 8:43
Комментарии (0)

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

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:]
bstpierre
Редактировал ответ 25-го мая 2011 в 12:45
Комментарии (0)

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

Один & (не &усилитель;&) достаточно или как высокое напрашивается ответ, вы можете использовать 'и'. Я также нашел это в панд 

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

если заменить на "&ампер;" с "и" он выиграл'т работу.

AlessioX
Редактировал ответ 3-го марта 2018 в 12:24
Комментарии (1)

может быть, с & а не % более быстрой и поддерживать читаемость

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

х даже ? х % 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
Комментарии (0)