O Python usa as condições and e or.

I. e.

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

Estou a ter um erro no condicional IF. O que estou a fazer de errado?

Há uma razão para se ter um SyntaxError é que não há nenhum operador && em Python. Do mesmo modo || e ! Não são operadores de Python válidos.

Alguns dos operadores que você pode conhecer de outras línguas têm um nome diferente em Python. Os operadores lógicos && e || são realmente chamados and e or. Da mesma forma, o operador de negação lógica ! é chamada not

if len(a) % 2 == 0 and len(b) % 2 == 0:

Ou mesmo:

if not (len(a) % 2 or len(b) % 2):

Algumas informações adicionais (que podem vir a ser úteis):

Resumi os "equivalentes" do operador nesta tabela:

+------------------------------+---------------------+
|  Operator (other languages)  |  Operator (Python)  |
+==============================+=====================+
|              &&              |         and         |
+------------------------------+---------------------+
|              ||              |         or          |
+------------------------------+---------------------+
|              !               |         not         |
+------------------------------+---------------------+

Ver também documentação em Python: 6.11. Operações booleanas .

Além dos operadores lógicos Python também tem operadores binários / binários:

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

Não existe uma negação bitwise em Python (apenas o operador inverso bitwise ~ - mas isso é não equivalente a not).

Ver também 6. 6. Aritmética unária e operações binárias/Binárias e 6, 7. Operações aritméticas Binárias.

Os operadores lógicos (como em muitas outras línguas) têm a vantagem de que estes são curto-circuitos. Isso significa que se o primeiro operando já define o resultado, então o segundo operador não é avaliado de todo.

Para mostrar isto eu uso uma função que simplesmente tem um valor, imprime - o e devolve-o outra vez. Isto é útil para ver o que é realmente avaliado devido às declarações de impressão:

>>> def print_and_return(value):
...     print(value)
...     return value

>>> res = print_and_return(False) and print_and_return(True)
False

Como você pode ver apenas uma declaração de impressão é executada, então Python realmente nem olhou para o operando direito.

Este não é o caso dos operadores binários. Aqueles sempre avaliam ambos os operandos:

>>> res = print_and_return(False) & print_and_return(True);
False
True

Mas se o primeiro operando não for suficiente, então, é claro, o segundo operador é avaliado:

>>> 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           |
+-----------------+-------------------------+

A True e False representam o que bool(left-hand-side) retorna, eles não têm que ser True ou False, eles só precisam de retorno True ou False quando bool é chamado de no-los (1).

So in Pseudo-Code (!) as funções and e or funcionam assim:

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)

Note que isto é um pseudo-código e não um código Python. Em Python você não pode criar funções chamadas and ou or porque estas são palavras-chave. Também você nunca deve usar "avaliar" ou if bool(...).

Esta chamada implícita bool pode ser usada para personalizar a forma como as suas classes se comportam com and, or e not

Para mostrar como isto pode ser personalizado eu uso Esta classe que novamente print é algo para rastrear o que está acontecendo:

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)

Se não tiver um método __bool__, então o Python também verifica se o object has a __len__ method and if it returns a value greater than zero. Isso pode ser útil para saber no caso de criar um recipiente de sequência.

Ver também 4. 1. Teste Do Valor Da Verdade.

Provavelmente um pouco além do âmbito da pergunta original, mas no caso de estar a lidar com matrizes NumPy ou subclasses (como séries Pandas ou DataFrames), então a chamada implícita bool vai levantar o temido 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().

Em estes casos você pode usar a função lógica e de NumPy que executa um elemento sábio and (ou 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])

Se você está lidando apenas com arrays booleanos você também poderia usar os operadores binários com NumPy, estes realizam comparações de elemento-sábio (mas também binário):

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

Que a chamada para os operandos tem de voltar True ou False não está completamente correcta. É só a primeira operação que precisa de devolver um booleano no seu método __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)

Porque and devolve realmente o primeiro operando se o primeiro operando for avaliado em False e se for avaliado em True Então devolve o segundo operando:

>>> x1
Test(10)
>>> x2
Test(False)

Da mesma forma para {[24] } mas ao contrário:

>>> Test(True) or Test(10)
Test(True)
>>> Test(False) or Test(10)
Test(10)

No entanto, se os usar numa declaração if, o if também implicitamente chamará bool sobre o resultado. Por isso, estes pontos mais finos podem não ser relevantes para si.

Duas observações:

• usar and e or para Operações lógicas em Python.
• utilize 4 espaços para indentar em vez de 2. Você vai agradecer a si mesmo mais tarde, porque o seu código vai ser praticamente o mesmo que o código de todos os outros. Ver PEP 8 para mais detalhes.

and e or para realizar operações lógicas como em C, C++. Literalmente and o && e or é ||.

diz que queres construir portas lógicas em 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)

Isto irá resultar:

False
True

espero que isto ajude!

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

Provavelmente este não é o melhor código para esta tarefa, mas está a funcionar -

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

Talvez com & em vez de % é mais rápido e a readibilidade Manta

Outros testes par / ímpar

Talvez seja mais claro com bitwise e 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

Uso condicional de" e". Uso isto muitas vezes na importação no caderno de 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

Um único & (não duplo &&) é suficiente ou como a resposta de cima sugere que você pode usar 'e'. Também encontrei isto em pandas.

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

Se substituirmos o " & " por "e", não vai funcionar.