Pythons Äquivalent zu && (logisches Und) in einer if-Anweisung

Lesezeit: 9 Minuten

Das funktioniert nicht:

if cond1 && cond2:

  • Es scheint mir, dass der Interpreter, anstatt ein kryptisches “SyntaxError: invalid syntax” auszugeben – erkennen sollte, dass der Benutzer verwendet hat && und schlagen Sie ihnen vor, das Schlüsselwort zu verwenden and stattdessen. Gleiches gilt für Dinge wie ++ und andere gängige Operatoren aus anderen Sprachen.

    – ArtOfWarfare

    26. September 2013 um 17:28 Uhr

  • @physicsmichael “es sollte einen und vorzugsweise nur einen offensichtlichen Weg geben, dies zu tun.” import this

    – Nik T

    14. September 2014 um 20:24 Uhr

  • and und or kann auch verwendet werden, um die Richtigkeit von Ausdrücken zu bewerten, die mehr als nur boolesche Werte beinhalten. Weitere Informationen finden Sie in diesem Beitrag.

    – cs95

    29. Dezember 2018 um 12:07 Uhr

Benutzer-Avatar
Christophe D

Benutzen and anstatt &&.

  • was soll ich dafür tun: wenn x==’n’ und y ==’a’ oder y==’b’: geht das !? @ChristopheD

    – gebeugt

    2. April 2015 um 15:35 Uhr


  • @diffracteD: Verwenden Sie Klammern, wenn Sie die Standardoperatorpriorität überschreiben möchten (was Sie hier erfahren können: ibiblio.org/g2swap/byteofpython/read/operator-precedence.html)

    – Christoph D

    2. April 2015 um 21:51 Uhr


  • Ich finde es gut, dass David Titarenco ein Cut-n-Paste-Beispiel gegeben hat

    – Alex Roche

    27. Mai 2015 um 16:33 Uhr


  • Ich bin hier angekommen, nachdem ich beide eingegeben hatte && und AND und bekam einen Fehler (keine Erwartung, dass Python das Wort in Kleinbuchstaben haben möchte and).

    – Xeoncross

    22. November 2016 um 17:28 Uhr

  • Ich denke, Sie sollten & See verwenden: stackoverflow.com/questions/36921951/…

    – Reddspark

    27. Juli 2017 um 20:24 Uhr


Benutzer-Avatar
David Titarenco

Python verwendet and und or Bedingungen.

dh

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

  • Vergessen Sie nicht, dass Python auch nicht (na ja, und !)

    – InspektorG4dget

    21. März 2010 um 2:54 Uhr

  • Wird Ihr Beispiel zu “(if this and this) or that” OR “if this and (this or that)” ausgewertet?

    – Jeff

    19. Februar 2014 um 18:04 Uhr

  • @Jeff Dein erster Weg. and hat einen höheren Vorrang als or.

    – Buge

    26. August 2014 um 19:05 Uhr


  • @Buge es sieht so aus, als ob “oder” weiter oben in der von Ihnen verlinkten Tabelle steht

    – Matt

    4. Dezember 2017 um 14:59 Uhr

  • @Matt die Tabelle geht von der niedrigsten Priorität zur höchsten. Es ist einfacher, sich an den Vorrang zu erinnern, wenn Sie sich mit boolescher Algebra beschäftigt haben; “oder” ist Addition und “und” ist Multiplikation.

    – Michael Stroud

    5. Dezember 2017 um 19:02 Uhr


Benutzer-Avatar
MSeifert

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

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

  • Benutzen 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.

Benutzer-Avatar
Groß Rot

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

  • Dies ist keine Antwort auf die eigentliche Frage.

    – Matthäus Lesen

    26. Oktober 2017 um 17:33 Uhr

Benutzer-Avatar
MarianD

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!

  • Dies ist keine Antwort auf die eigentliche Frage.

    – Matthäus Lesen

    26. Oktober 2017 um 17:33 Uhr

Benutzer-Avatar
bstpierre

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

1011620cookie-checkPythons Äquivalent zu && (logisches Und) in einer if-Anweisung

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy