Das geht nicht:

if cond1 && cond2:

Verwenden and anstatt &&.

Python verwendet and Und or Bedingungen.

dh

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

Ich erhalte einen Fehler in der IF-Bedingung. Was mache ich falsch?

Aus diesem Grund erhalten Sie a SyntaxError ist, dass es keine gibt && Operator in Python. Ebenfalls || Und ! Sind ungültig Python-Operatoren.

Einige der Operatoren, die Sie vielleicht aus anderen Sprachen kennen, haben in Python einen anderen Namen. Die logischen Operatoren && Und || heißen eigentlich and Und or. Ebenso der logische Negationsoperator ! wird genannt not.

Du könntest also einfach schreiben:

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

oder auch:

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

Einige zusätzliche Informationen (die nützlich sein könnten):

Ich habe die Operator-“Äquivalente” in dieser Tabelle zusammengefasst:

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

Siehe auch Python-Dokumentation: 6.11. Boolesche Operationen.

Neben den logischen Operatoren hat Python auch bitweise/binäre Operatoren:

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

In Python gibt es keine bitweise Negation (nur den bitweisen Umkehroperator ~ – das ist aber nicht gleichwertig not).

Siehe auch 6.6. Unäre arithmetische und bitweise/binäre Operationen Und 6.7. Binäre arithmetische Operationen.

Die logischen Operatoren (wie in vielen anderen Sprachen) haben den Vorteil, dass diese kurzgeschlossen werden. Das heißt, wenn der erste Operand bereits das Ergebnis definiert, wird der zweite Operator überhaupt nicht ausgewertet.

Um dies zu zeigen, verwende ich eine Funktion, die einfach einen Wert nimmt, ihn druckt und wieder zurückgibt. Dies ist praktisch, um zu sehen, was aufgrund der Druckanweisungen tatsächlich ausgewertet wird:

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

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

Wie Sie sehen können, wird nur eine print-Anweisung ausgeführt, sodass Python wirklich nicht einmal auf den richtigen Operanden geschaut hat.

Dies ist bei den binären Operatoren nicht der Fall. Diese werten immer beide Operanden aus:

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

Aber wenn der erste Operand nicht ausreicht, wird natürlich der zweite Operator ausgewertet:

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

Um dies zusammenzufassen, hier eine weitere Tabelle:

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

Der True Und False was darstellen bool(left-hand-side) Rückkehr, sie müssen nicht sein True oder Falsesie müssen nur zurückkehren True oder False Wenn bool wird zu ihnen gerufen (1).

Also im Pseudo-Code(!) die and Und or Funktionen funktionieren wie folgt:

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)

Beachten Sie, dass dies Pseudo-Code und kein Python-Code ist. In Python können Sie keine Funktionen namens erstellen and oder or denn das sind Stichworte. Auch sollten Sie niemals “auswerten” oder verwenden if bool(...).

Anpassen des Verhaltens Ihrer eigenen Klassen

Dies implizit bool call kann verwendet werden, um anzupassen, wie sich Ihre Klassen verhalten and, or Und not.

Um zu zeigen, wie dies angepasst werden kann, verwende ich wieder diese Klasse which prints etwas, um zu verfolgen, was passiert:

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)

Sehen wir uns also an, was mit dieser Klasse in Kombination mit diesen Operatoren passiert:

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

Wenn Sie keine haben __bool__ -Methode überprüft Python auch, ob das Objekt eine hat __len__ -Methode und wenn sie einen Wert größer als Null zurückgibt. Das kann nützlich sein, wenn Sie einen Sequenzcontainer erstellen.

Siehe auch 4.1. Wahrheitswertprüfung.

NumPy-Arrays und Unterklassen

Wahrscheinlich etwas über den Rahmen der ursprünglichen Frage hinaus, aber falls Sie es mit NumPy-Arrays oder Unterklassen (wie Pandas Series oder DataFrames) zu tun haben, dann das Implizite bool Anruf wird das Gefürchtete erwecken 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().

In diesen Fällen können Sie das logische und verwenden Funktion von NumPy, das elementweise eine ausführt and (oder 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])

Wenn Sie gerade damit zu tun haben boolesche Arrays Sie könnten auch die binären Operatoren mit NumPy verwenden, diese führen elementweise (aber auch binäre) Vergleiche durch:

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

Dass die bool Der Aufruf der Operanden muss zurückkehren True oder False ist nicht ganz richtig. Es ist nur der erste Operand, der einen booleschen Wert zurückgeben muss __bool__ Methode:

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)

Das ist, weil and gibt tatsächlich den ersten Operanden zurück, wenn der erste Operand ausgewertet wird False und wenn es zu wertet True dann gibt es den zweiten Operanden zurück:

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

Ähnlich für or aber genau andersherum:

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

Wenn Sie sie jedoch in einem verwenden if Aussage die if wird auch implizit aufrufen bool auf das Ergebnis. Daher sind diese Feinheiten für Sie möglicherweise nicht relevant.

Zwei Kommentare:

• Verwenden and Und or für logische Operationen in Python.
• Verwenden Sie 4 statt 2 Leerzeichen zum Einrücken. Sie werden sich später dafür bedanken, dass Ihr Code so ziemlich genauso aussieht wie der Code aller anderen. Sehen PEP 8 für mehr Details.

Ich ging mit einer rein mathematischen Lösung:

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

Sie nutzen and Und or um logische Operationen wie in C, C++ auszuführen. Wie wörtlich and Ist && Und or Ist ||.

Schauen Sie sich dieses lustige Beispiel an,

Angenommen, Sie möchten Logikgatter in Python erstellen:

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

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

Versuchen Sie jetzt, sie anzurufen:

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

Dies wird ausgeben:

False
True

Hoffe das hilft!

Wahrscheinlich ist dies nicht der beste Code für diese Aufgabe, aber es funktioniert –

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