Was ist die Rangfolge beim schreiben eine doppelte Ungleichheit in Python (explizit im code, und wie kann dieser überschrieben werden, für die arrays?)

Was ist der spezifische code, in order, ausgeführt wird, wenn ich nach etwas Fragen, wie

>>> 1 <= 3 >= 2
True

Wenn beide haben die gleiche Priorität und es ist einfach die Reihenfolge Ihrer Auswertung, warum die zweite Ungleichung Funktion als (3 >= 2) statt (True >= 2)

Betrachten Sie zum Beispiel den Unterschied zwischen diesen

>>> (1 < 3) < 2
True

>>> 1 < 3 < 2
False

Ist es nur eine Reine syntaktische short-cut " hart-codiert in Python zu erweitern, die zweite als die and von den beiden Aussagen?

Konnte ich dieses Verhalten ändern, für eine Klasse, so dass a <= b <= c wird erweitert, um etwas anderes? Es sieht wie im folgenden ist der Fall

a (logical operator) b (logical operator) c 
    --> (a logical operator b) and (b logical operator c)

aber die eigentliche Frage ist, wie dieser wird in code umgesetzt.

Ich bin neugierig, so dass ich replizieren kann, diese Art von __lt__ und __gt__ Verhalten in einige meiner eigenen Klassen, aber ich bin verwirrt darüber, wie dies erreicht wird, hält die Mitte argument konstant.

Hier ist ein konkretes Beispiel:

>>> import numpy as np

>>> tst = np.asarray([1,2,3,4,5,6])

>>> 3 <= tst
array([False, False,  True,  True,  True,  True], dtype=bool)

>>> 3 <= tst <= 5
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
/home/ely/<ipython-input-135-ac909818f2b1> in <module>()
----> 1 3 <= tst <= 5

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

Wäre es schön, dies zu ändern, so dass es "funktioniert einfach" mit arrays zu, wie diese:

>>> np.logical_and(3 <= tst, tst <= 5)
array([False, False,  True,  True,  True,  False], dtype=bool)

Hinzugefügt zur Klärung

In die Kommentare es wird darauf hingewiesen, dass ich habe einen schlechten job erklären die Frage. Hier einige klärende Bemerkungen:

1) ich bin nicht der Suche nach einer einfachen Erklärung der Tatsache, dass der Dolmetscher erscheint ein and zwischen den beiden angekettet Ungleichheiten. Ich wusste bereits, dass und sagte so oben.

2) Für eine Analogie zu dem, was ich tun will, betrachten Sie das with - Anweisung (link). Die folgenden:

with MyClass(some_obj) as foo:
    do_stuff()

entpackt in

foo = MyClass(some_obj)
foo.__enter__()
try:
    do_stuff()
finally:
    foo.__exit__()

So schreiben MyClass angemessen, ich kann viele Besondere Dinge in der with - Anweisung.

Ich Frage, ob es einen ähnlichen code Auspacken der verketteten Ungleichheit, durch die ich abfangen kann, was es tut, und leiten Sie zu verwenden der array-Stil logischen Operatoren statt nur für die Klassen I-Sorgfalt über.

Ich glaube, das ist ganz klar aus meiner Frage, die vor allem das Beispiel, aber ich hoffe das macht es klarer.

InformationsquelleAutor ely | 2012-09-30

9

Ich bin mir nicht ganz sicher, was du suchst, aber eine schnelle Demontage zeigt, dass a < b < c ist nicht zusammengestellt, um den gleichen bytecode als a < b and b < c
```
>>> import dis
>>>
>>> def f(a, b, c):
...     return a < b < c
...
>>> dis.dis(f)
  2           0 LOAD_FAST                0 (a)
              3 LOAD_FAST                1 (b)
              6 DUP_TOP
              7 ROT_THREE
              8 COMPARE_OP               0 (<)
             11 JUMP_IF_FALSE_OR_POP    21
             14 LOAD_FAST                2 (c)
             17 COMPARE_OP               0 (<)
             20 RETURN_VALUE
        >>   21 ROT_TWO
             22 POP_TOP
             23 RETURN_VALUE
>>>
>>> def f(a, b, c):
...     return a < b and b < c
...
>>> dis.dis(f)
  2           0 LOAD_FAST                0 (a)
              3 LOAD_FAST                1 (b)
              6 COMPARE_OP               0 (<)
              9 JUMP_IF_FALSE_OR_POP    21
             12 LOAD_FAST                1 (b)
             15 LOAD_FAST                2 (c)
             18 COMPARE_OP               0 (<)
        >>   21 RETURN_VALUE
```
Edit 1: Graben weiter, ich denke, das ist etwas komisch oder falsch mit numpy. Beachten Sie in diesem Beispiel code, ich denke, es funktioniert wie man es erwarten würde.
```
class Object(object):
    def __init__(self, values):
        self.values = values
    def __lt__(self, other):
        return [x < other for x in self.values]
    def __gt__(self, other):
        return [x > other for x in self.values]

x = Object([1, 2, 3])
print x < 5 # [True, True, True]
print x > 5 # [False, False, False]
print 0 < x < 5 # [True, True, True]
```
Edit 2: Tatsächlich so funktioniert das nicht "richtig"...
```
print 1 < x # [False, True, True]
print x < 3 # [True, True, False]
print 1 < x < 3 # [True, True, False]
```
Ich denke, es ist zu vergleichen Boolesche Werte in zahlen in der zweite Vergleich der 1 < x < 3.

Edit 3: ich weiß nicht, wie die Idee der Rücksendung nicht-Boolesche Werte aus dem gt, lt, gte, lte speziellen Methoden, aber es ist eigentlich nicht eingeschränkt, nach der Python-Dokumentation.

http://docs.python.org/reference/datamodel.html#object.lt

Durch Konvention, False und True zurückgegeben werden, die für eine erfolgreiche
Vergleich. Jedoch, diese Methoden wieder Wert...
- Das ist nicht ganz das was ich Suche, aber es ist hilfreich und näher dem rechten Weg als die anderen Antworten so weit. Da es sich nicht ergeben die gleichen byte-code, die Frage ist, was Python-Funktionen werden eingesetzt, um den Aufruf im ersten Fall, und wie kann ich diese überschreiben.
- Ja, Sie scheinen korrekt zu sein. Dies ist ein NumPy-bug. Wenn ich zum Beispiel Folgendes tun: list((-1 < vect)[:,0]) and list((vect < 5)[:,0]) dann funktioniert es. Also die and ist erstickt an der Tatsache, dass es zwei Argumente sind numpy.ndarray statt list. Dies ist sehr merkwürdig; es bedeutet, dass __gt__ und __lt__ müssen einige zusätzliche ndarray Reste in Ihnen.
- Es scheint, dass es Probleme mit der Beschaffung des richtigen True/False-Wert, aber zumindest ist es nicht erstickt an den array-Typen. Viel mehr Graben zu tun. Ich Frage mich, ob dies hat nichts zu tun mit __and__.
- was Sie wollen, ist einfach unmöglich. Sollten Sie die binären Operatoren statt, die gut funktionieren (das ist, was __and__ ist). Die and Betreiber kann nicht jedes element weiser Logik, es ist einfach nicht möglich, in Python, das Ergebnis ist, was Sie finden in Edit 2. Nur der Letzte Vergleich/Objekt zurückgegeben werden kann, und das wird nicht das tun, was Sie erwarten.
- Ich denke, Sie sind nicht mein Punkt. Ich Frage, wie kann ich die Kraft der doppelseitige Ungleichheit zu erweitern, in etwas, das nicht in der normalen and.
- auch Sie kann natürlich nicht, wenn man sich der kompilierte code ist es genau das gleiche tut (ignorieren, dass Ihr ein wenig optimiert), beide benutzen die JUMP_IF_FALSE_OP_POP Logik, die genau der and-operator.
- Ich weiß nicht, wie die Ton -, aber ich könnte mich verlesen, dein Kommentar. Das war nicht offensichtlich zu mir, das ist der Grund, warum ich die Frage gestellt habe. Die sehr Antwort oben zeigt den Punkt, den Sie versuchen zu machen, das ist, warum ich nahm es als Antwort. Ich bin wirklich nicht sicher, was ist Ihr Kommentar gemeint ist, hinzufügen.
InformationsquelleAutor FogleBird
3

Beide haben die gleiche Rangfolge, doch sind ausgewertet von Links nach rechts entsprechend der Dokumentation. Ein Ausdruck der form a <= b <= c wird erweitert, um a <= b and b <= c.
- Warum hat er das Ergebnis in (1 <= 3) --> True --> (True >= 2) --> Typ-Fehler???
- Der Ausdruck a <= b <= c wird erweitert, um a <= b and b <= c
- Im code, wie funktioniert der Erweiterung geschehen. Oder ist das nur ein "one-off" hard-coded Python-idiom?
- Siehe meine erweiterte Frage oben.
- Nochmals vielen Dank für Ihre Hilfe bei diesem. Ich weiß es zu schätzen wissen, also bitte nicht falsch gelesen haben, die folgende Anfrage. Wären Sie bereit, zu löschen, Ihre Antwort? Es geht nicht auf jedem der inhaltlichen Punkte meiner Fragen, und nur die Punkte in der Dokumentation für logische Operatoren, die in isolation (die hatte ich schon durchgelesen vor dem posten der Frage). Ich bin besorgt, dass da eine Antwort nun, die Frage nicht genug bekommen neue Aufmerksamkeit. Ich werde versuchen ein Kopfgeld, aber wenn Sie könnten, take down Ihre Antwort zu, das wäre sehr hilfreich. Danke.
- Ich glaube wirklich nicht, entfernen Sie diese Antwort es zu bekommen Sie bessere Antworten. Erstens, das ist, was Abstimmung, und zweitens weiter zu verbessern Ihre Frage wird mehr Einfluss.
- was die inhaltlichen Punkte beziehen Sie sich? Wenn Sie möchten, zu bekommen, so etwas wie ein numpy-array zu "einfach funktionieren", verkettete Vergleiche diese Weise, dann müssen Sie überschreiben __and__. array([0,5]) > 2 und array([2,5]) < 10 beide arbeiten und produzieren eine bool-dtyped array, aber (array([0,5]) > 2) and (array([2,5]) < 10) nicht, weil dieser Ausdruck mehrdeutig ist und numpy entscheidet sich zu weigern, der Versuchung zu erraten. Man kann nicht sagen, Python, etwas anderes als and zu unchain Vergleich.
- Ich sage, dass die syntax erweitert, dass die verkettete Ungleichheit in einer and der zwei separate Ungleichungen verwenden soll NumPy logical_and - Funktion anstelle von Python and Betrieb. Ich möchte dies überschreiben, so dass der ausbau-arbeiten mit NumPy ist. @DSM, ich glaube, du bist Missverständnis mich. Ich weiß, dass es nativ ist die ganze "Wahrheit Wert in einem array ist mehrdeutig" dealie. Ich Frage, wie kann ich schaffen Ungleichheiten, die die Nutzung der bestehenden array-Logik-tools entsprechend behandeln.
- Es sollte Recht einfach sein, wenn a < 5 erzeugt ein array von Bools auch 3 < a < 5 ähnlich produzieren ein array. Ob dies nur ein hard-codiert in die Dolmetscherin, so dass es immer verwenden müssen-Python-native and bei der Erweiterung des Ausdrucks, dann OK, aber diese Antwort gar nicht eingehen. Und wenn es hart codiert, das scheint so schlecht und unflexibel und unpythonic, insbesondere angesichts der Tatsache, wie Häufig dies wäre in NumPy.
- Die Verallgemeinerung, dass a <= b <= c wird erweitert, um a <= b and b <= c ist falsch.
InformationsquelleAutor Óscar López
1

aber die eigentliche Frage ist, wie dieser wird in code umgesetzt.

Meinst du , wie der interpreter wandelt es, oder was? Sie sagte bereits
```
a (logical operator) b (logical operator) c 
    --> (a logical operator b) and (b logical operator c)
```
~~also ich bin mir nicht sicher, was du fragst hier~~
OK, ich fand es heraus: Nein, Sie können nicht überschreiben die expansion von a < b < c in (a < b) and (b < c) IIUC.

Ich bin neugierig, so dass ich replizieren kann, diese Art von __lt__ und __gt__ Verhalten in einige meiner eigenen Klassen, aber ich bin verwirrt darüber, wie dies erreicht wird, hält die Mitte argument konstant.

Es hängt davon ab, welche der a, b und c im Ausdruck a < b < c sind Instanzen einer eigenen Klasse. Die Umsetzung Ihrer __lt__ und __gt__ und Methoden wird einige Weg, aber die Dokumentation weist darauf hin, dass:

Gibt es keine getauscht-argument-Versionen dieser Methoden (werden verwendet, wenn das linke argument unterstützt nicht den Betrieb, aber das richtige argument ist)

So, wenn Sie wollen Int < MyClass < Int, sind Sie aus Glück heraus. Sie müssen mindestens MyClass < MyClass < Something (also eine Instanz der Klasse wird auf der LHS der jeden Vergleich in der erweitert-Ausdruck).
- Also sagen Sie, dass die Ausweitung der a < b < c in a < b and b < c ist nur hard-codiert in den code für diesen Teil ein Dolmetscher? Es gibt keine Möglichkeit (abgesehen von der Verzweigung Python-source) für einige Klassen, erweitern Sie mit numpy.logical_and statt, so dass logische arrays werden korrekt behandelt?
- Ich verstehe nicht, warum die Antworten sind so blind für diese. Können Sie einen Rat geben, wie ich mich verbessern kann, meine Frage? Ich glaube, es ist ein sehr Gültiger Punkt, dass wir sollten in der Lage sein, um die Dinge zu kombinieren mit and aber es macht am meisten Sinn für unsere Klassen. Dies ist eine sehr häufige Art der operation in Python Pandas und in NumPy, also es ist nicht so, ich Frage für einige sehr Arkane array unterstützen. Zum Beispiel, sofort wieder ein array von bools aus der hervorgeht, wo eine date-variable fällt zwischen einem gültigen start-und end-Datum wäre viel besser ausgedrückt als eine verkettete Ungleichheit.
- Ihre Frage beginnt mit der Frage, wie eine verkettete Ungleichheit arbeitet, und sagt später, Sie schon wissen, und sagen, die eigentliche Frage ist etwas anderes. So, von über 5 Absätze, ich bin mir nicht mehr sicher, was Sie Fragen, und fühlen Sie meine Zeit verschwendet auf etwas, was Sie bereits wusste. Jetzt, in der achten Kommentar auf die erste Antwort, und die zweite Bemerkung zu der zweiten Antwort, Sie habe eigentlich deutlich gemacht, was Sie Fragen wollte. Wenn Sie glauben, die Antworten sind blind für die Frage, die Sie wollte zu Fragen, es ist, weil Sie auf der Grundlage der Frage, die Sie tatsächlich gefragt.
- ... wenn ich Zeit habe, werde ich versuchen, hacking deine Frage in etwas mehr beantwortbar. Ansonsten würd ich dir empfehlen eine neue Frage stellen, die klarer ist.
- Sorry, wenn es nicht klar war. Ich wollte mal Fragen, wie funktioniert es eine Schicht unterhalb, nur vom Dolmetscher, der Ersatz einen syntax mit dem anderen. Ich wusste schon, dass es knallte das and dazwischen. Aber denken Sie an die with - Anweisung. Umgesetzt wird dies mit einem __enter__ dann ein try block und dann ein finally mit der __exit__ nennen. Sie können viel tun, der syntax manipulation von wissen, wie with funktioniert. Ich hatte gehofft, dass verkettet Ungleichheiten in ähnlicher Weise reduziert auf eine Sequenz von calls auf einige __ Typ Funktionen, die mit der Handhabung der Verkettung explizit in einer dieser Funktionen.
- Ich auch nicht einverstanden, dass es war nicht klar. Ich gab ein ganz spezifisches Beispiel am Ende meiner Frage.
InformationsquelleAutor Useless

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.