Python est l'équivalent de && (logique-et) dans un if

Python utilise and et or conditions.

c'est à dire

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

J'obtiens une erreur dans le SI conditionnel. Ce que je fais mal?

Il y a des raisons pour que vous obtenez un SyntaxError est qu'il n'est pas && opérateur en Python. De même || et ! sont pas valide Python opérateurs.

Certains opérateurs vous savez peut-être d'autres langues ont un nom différent en Python.
Les opérateurs logiques && et || sont appelés and et or.
De même, la négation logique de l'opérateur ! est appelé not.

Vous pouvez donc écrire:

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

ou encore:

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

Quelques informations supplémentaires (qui peuvent venir dans maniable):

J'ai résumé l'opérateur "équivalents" dans ce tableau:

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

Voir aussi La documentation Python: 6.11. Opérations booléennes.

Outre les opérateurs logiques Python a aussi au niveau du bit/opérateurs binaires:

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

Il n'y a pas de négation binaire en Python (juste le bit à bit inverse de l'opérateur ~ - mais qu'est pas équivalent à not).

Voir aussi 6.6. Unaire de l'arithmétique et de la bit-à-bit/opérations binaires et 6.7. Opérations arithmétiques binaires.

Les opérateurs logiques (comme dans beaucoup d'autres langues) ont l'avantage que ceux-ci sont court-circuitées.
Cela signifie que si le premier opérande définit déjà le résultat, puis le deuxième opérateur n'est pas évaluée à tous.

Pour montrer cela, j'utilise une fonction qui prend simplement une valeur, l'imprime et le renvoie à nouveau. C'est pratique pour voir ce qui est réellement
évalués en raison de l'impression des déclarations:

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

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

Comme vous pouvez le voir une seule impression instruction est exécutée, de sorte que Python n'avait même pas regarder l'opérande de droite.

Ce n'est pas le cas pour les opérateurs binaires. Ceux qui sont toujours évaluer les deux opérandes:

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

Mais si le premier opérande n'est pas suffisant alors, bien sûr, le second opérateur est évaluée:

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

Pour résumer il s'agit ici d'une autre Table:

+-----------------+-------------------------+
|   Expression    |  Right side evaluated?  |
+=================+=========================+
| `True` and ...  |           Yes           |
+-----------------+-------------------------+
| `False` and ... |           No            |
+-----------------+-------------------------+
|  `True` or ...  |           No            |
+-----------------+-------------------------+
| `False` or ...  |           Yes           |
+-----------------+-------------------------+

La True et False représenter ce bool(left-hand-side) retourne, ils n'ont pas à être True ou False, ils ont juste besoin de retourner True ou False quand bool est appelé sur eux (1).

Donc en Pseudo-Code(!) le and et or fonctions de travail comme celles-ci:

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)

Remarque que c'est de la pseudo-code pas de code Python. En Python, vous ne pouvez pas créer des fonctions appelées and ou or parce que ces mots-clés.
Aussi, vous ne devez jamais utiliser "évaluer" ou if bool(...).

De personnaliser le comportement de vos propres classes

L'implicite bool appel peut être utilisé pour personnaliser la façon dont vos classes se comporter avec and, or et not.

Pour montrer comment cela peut être personnalisée-je utiliser cette classe qui, là encore, prints quelque chose pour suivre ce qui se passe:

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)

Donc, nous allons voir ce qui se passe avec cette classe en combinaison avec ces opérateurs:

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

Si vous n'avez pas de __bool__ méthode, puis Python vérifie également si l'objet a une __len__ méthode, et si elle renvoie une valeur supérieure à zéro.
Qui pourrait être utile à savoir dans le cas où vous créez un conteneur de séquence.

Voir aussi 4.1. Valeur De Vérité De Tests.

NumPy d'ensembles et de sous-classes

Probablement un peu au-delà de la portée de la question d'origine, mais dans le cas où vous avez à traiter avec des tableaux NumPy ou sous-classes (comme les Pandas Série ou DataFrames) puis l'implicite bool appel
va relever le redoutable 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().

Dans ces cas, vous pouvez utiliser la logique et fonction de NumPy qui exécute un élément-sage 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])

Si vous traitez seulement avec boolean tableaux vous pouvez également utiliser les opérateurs binaires avec NumPy, ces effectuez élément-sage (mais aussi binaire) comparaisons:

>>> 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 le bool appel sur les opérandes est de retour True ou False n'est pas tout à fait correct. C'est juste le premier opérande qui doit retourner un booléen dans __bool__ méthode:

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)

C'est parce que and renvoie en fait le premier opérande si le premier opérande est évaluée à False et si on les évalue à True puis il renvoie le deuxième opérande:

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

De même pour or mais juste dans l'autre sens:

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

Toutefois, si vous les utilisez dans un if déclaration de la if également implicitement appel bool sur le résultat. De sorte que ces subtilités peuvent ne pas être pertinentes pour vous.

Vous utilisez and et or pour effectuer des opérations logiques comme en C, C++. Comme littéralement and est && et or est ||.

---

Prendre un coup d'oeil à cet amusant exemple,

Dites que vous voulez construire des Portes Logiques en Python:

def AND(a,b):
    return (a and b) #using and operator

def OR(a,b):
    return (a or b)  #using or operator

Maintenant, essayez de les appeler:

print AND(False, False)
print OR(True, False)

Ce sera de sortie:

False
True

Espérons que cette aide!

Dans un "if" en Python, vous utilisez et, ou, pas et ce sont les équivalents des &&, ||, ! les opérateurs logiques sont utilisés dans d'autres langages de programmation

Un seul & (pas de double &&) est suffisante ou que la réponse sommet, suggère que vous pouvez utiliser 'et'.
J'ai aussi trouvé ça dans les pandas

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

si l'on remplace les "&" avec "et", ça ne marchera pas.