it-swarm.com.de

Pythons Äquivalent von && (logisch-und) in einer if-Anweisung

Hier ist mein Code:

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

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

740
delete

Sie möchten and anstelle von &&.

1307
ChristopheD

Python verwendet die Bedingungen and und or.

d.h.

if foo == 'abc' and bar == 'bac' or Zoo == '123':
  # do something
210
David Titarenco

Zwei Kommentare:

  • Verwenden Sie and und or für logische Operationen in Python.
  • Verwenden Sie 4 Leerzeichen zum Einrücken anstelle von 2. Sie werden sich später bedanken, da Ihr Code so ziemlich genauso aussieht wie der Code aller anderen. Siehe PEP 8 für weitere Einzelheiten.
36
istruble

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

Der Grund, warum Sie SyntaxError erhalten, ist, dass es in Python keinen && -Operator gibt. Ebenso sind || und ! keine gültigen Python-Operatoren.

Einige der Operatoren, die Sie möglicherweise aus anderen Sprachen kennen, haben in Python einen anderen Namen. Die logischen Operatoren && und || heißen tatsächlich and und or. Ebenso heißt der logische Negationsoperator !not.

Sie könnten 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 den 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         |         |          |
+--------------------+--------------------+

Es gibt keine bitweise Negation in Python (nur den bitweisen inversen Operator ~ - aber das ist nicht äquivalent zu 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 sind. Das heißt, wenn der erste Operand das Ergebnis bereits definiert, wird der zweite Operator überhaupt nicht ausgewertet.

Um dies zu zeigen, verwende ich eine Funktion, die einfach einen Wert annimmt, ihn ausgibt und wieder zurückgibt. Dies ist praktisch, um zu sehen, was aufgrund der print-Anweisungen 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, wird nur eine print-Anweisung ausgeführt, sodass Python nicht einmal den richtigen Operanden ansah.

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 hier zusammenzufassen, ist eine andere Tabelle:

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

Die True und False stellen dar, was bool(left-hand-side) zurückgibt, sie müssen nicht True oder False sein, sie müssen nur True zurückgeben oder False, wenn bool für sie aufgerufen wird (1).

In Pseudo-Code (!) Funktionieren die Funktionen and und or folgendermaßen:

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 Pseudocode und nicht Python Code ist. In Python können Sie keine Funktionen mit dem Namen and oder or erstellen, da dies Schlüsselwörter sind. Außerdem sollten Sie niemals "evaluieren" oder if bool(...) verwenden.

Anpassen des Verhaltens Ihrer eigenen Klassen

Dieser implizite bool -Aufruf kann verwendet werden, um das Verhalten Ihrer Klassen mit and, or und not anzupassen.

Um zu zeigen, wie dies angepasst werden kann, verwende ich diese Klasse, die wieder print ist, 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)

Schauen 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 __bool__ -Methode haben, prüft Python auch, ob das Objekt eine __len__ -Methode hat und ob es einen Wert größer als Null zurückgibt. Dies kann hilfreich sein, wenn Sie einen Sequenzcontainer erstellen.

Siehe auch 4.1. Truth Value Testing .

NumPy Arrays und Unterklassen

Wahrscheinlich etwas jenseits des Rahmens der ursprünglichen Frage, aber für den Fall, dass Sie mit NumPy-Arrays oder Unterklassen (wie Pandas -Reihen oder DataFrames) arbeiten, wird der implizite bool -Aufruf den gefürchteten 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 die logische und Funktion von NumPy verwenden, die elementweise and (oder or) ausführt:

>>> 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 es nur mit booleschen Arrays zu tun haben , können Sie 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 der bool -Aufruf für die Operanden True oder False zurückgeben muss, ist nicht ganz richtig. Es ist nur der erste Operand, der einen Booleschen Wert in seiner __bool__ -Methode zurückgeben muss:

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)

Dies liegt daran, dass and tatsächlich den ersten Operanden zurückgibt, wenn der erste Operand zu False ausgewertet wird, und wenn er zu True ausgewertet wird, dann gibt er den zweiten Operanden zurück:

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

Ähnlich für or, aber genau umgekehrt:

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

Wenn Sie sie jedoch in einer if -Anweisung verwenden, ruft if auch implizit bool für das Ergebnis auf. Daher sind diese Feinheiten für Sie möglicherweise nicht relevant.

27
MSeifert

Ich habe mich für eine rein mathematische Lösung entschieden:

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:]
10
Big Red

Sie verwenden 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 Logic Gates 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 nun, sie anzurufen:

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

Dies wird Folgendes ausgeben:

_False
True
_

Hoffe das hilft!

8
geekidharsh

Wahrscheinlich ist dies nicht der beste Code für diese Aufgabe, aber er 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:]
5

In einer "If-Anweisung" in Python würden Sie nd, oder nicht verwenden und diese sind äquivalent zu &&, ||,! logischen Operatoren, die werden in anderen Programmiersprachen verwendet

0
masterpianist