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

https://stackoverflow.com/questions/2485466

21-09-2019
|

Вопрос

Вот мой код:

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.
Используйте 4 пробела для отступа вместо 2.Позже вы поблагодарите себя, потому что ваш код будет выглядеть почти так же, как код всех остальных.Видеть ПКП 8 Больше подробностей.

Я получаю ошибку в условии 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 также есть побитовые / двоичные операторы:

+--------------------+--------------------+
|  Logical operator  |  Bitwise operator  |
+====================+====================+
|        and         |         &          |
+--------------------+--------------------+
|         or         |         |          |
+--------------------+--------------------+

В Python нет побитового отрицания (только побитовый обратный оператор ~ - но это так нет эквивалентно not).

Преимущество логических операторов (как и во многих других языках) заключается в том, что они имеют короткое замыкание.Это означает, что если первый операнд уже определяет результат, то второй оператор вообще не вычисляется.

Чтобы показать это, я использую функцию, которая просто принимает значение, печатает его и возвращает снова.Это удобно, чтобы увидеть, что на самом деле оценивается из-за инструкций print:

>>> 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 call можно использовать для настройки поведения ваших классов с 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__ метод и возвращает ли он значение, большее нуля.Это может быть полезно знать на случай, если вы создадите контейнер последовательности.

Массивы 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 от результата.Так что эти тонкости могут быть для вас неуместны.

Я выбрал чисто математическое решение:

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, 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'))

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

возможно, с & вместо % работает быстрее и сохраняет читабельность

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

х четный?х % 2 == 0

х нечетный?не х % 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

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow