Python UND Operator auf zwei booleschen Listen - wie?

Habe ich zwei boolean-Listen, z.B.,

x=[True,True,False,False]
y=[True,False,True,False]

Ich will UND diese Listen zusammen mit dem erwarteten Ausgang:

xy=[True,False,False,False]

Dachte ich, dass der Ausdruck x and y würde, doch kam zu entdecken, dass es nicht: in der Tat (x and y) != (y and x)

Ausgabe von x and y: [True,False,True,False]

Ausgabe von y and x: [True,True,False,False]

Mit list comprehension hat korrekte Ausgabe. Uff!

xy = [x[i] and y[i] for i in range(len(x)]

Verstand Sie, ich konnte nicht finden jede Bezugnahme sagte mir, ich den UND-operator funktionieren würde, wie ich versuchte, mit x und y ist. Aber es ist einfach zu versuchen, die Dinge in Python.
Kann jemand mir erklären was ist passiert mit x and y?

Und hier ist ein einfaches test-Programm:

import random
random.seed()
n = 10
x = [random.random() > 0.5 for i in range(n)]
y = [random.random() > 0.5 for i in range(n)]
# Next two methods look sensible, but do not work
a = x and y
z = y and x
# Next: apparently only the list comprehension method is correct
xy = [x[i] and y[i] for i in range(n)]
print 'x        : %s'%str(x)
print 'y        : %s'%str(y)
print 'x and y  : %s'%str(a)
print 'y and x  : %s'%str(z)
print '[x and y]: %s'%str(xy)

Kommentar zu dem Problem

ist x eine Liste ist, y eine Liste. x und y ist true, wenn und nur wenn beide Listen nicht-leer ist (eine leere Liste ist falsch-y', alle nicht-leere Listen sind "Wahrheit-y'): x und y ist nicht 'und jedes element' oder sonst kümmern sich die Werte. Kommentarautor: user2864740

InformationsquelleAutor der Frage Glenn N | 2015-08-24

28

and gibt einfach entweder der erste oder der zweite operand ist, auf Ihre Wahrheit Wert. Wenn der erste operand betrachtet wird false zurückgegeben, sonst wird der andere operand wird zurückgegeben.

Listen sind als wahr wenn nicht leer, so dass beide Listen werden als true betrachtet. Ihre Inhalte nicht spielen hier eine Rolle.

Da beide Listen sind nicht leer, x and y gibt einfach die zweite Liste Objekt; nur wenn x leer war, wäre es zurückgegeben statt:
```
>>> [True, False] and ['foo', 'bar']
['foo', 'bar']
>>> [] and ['foo', 'bar']
[]
```
Sehen die Wahrheit Wert testen - Abschnitt in der Python-Dokumentation:
Jedes Objekt getestet werden kann, für die Wahrheit Wert, für den Einsatz in einem if oder while Zustand oder als operand der booleschen Operationen unten. Die folgenden Werte werden als false:

[...]
- eine leere Sequenz, zum Beispiel '', (), [].
[...]

Alle anderen Werte werden als true betrachtet — also Objekte, die viele Arten sind immer wahr.
(Hervorhebung von mir), und die Boolesche Operationen - Abschnitt rechts unten:

x and y

wenn x falsch ist, dann x, sonst y

Ist ein short-circuit operator, so dass es nur wertet das zweite argument, wenn die erste ist True.

Sie tatsächlich benötigen, um zu testen, die Werte enthalten in den Listen explizit. Sie können dies tun, mit einer Liste Verständnis, wie Sie entdeckt. Schreiben Sie es mit der zip() - Funktion paar bis die Werte:
```
[a and b for a, b in zip(x, y)]
```
InformationsquelleAutor der Antwort Martijn Pieters

Könnten Sie numpy:

>>> import numpy as np
>>> x=np.array([True,True,False,False])
>>> y=np.array([True,False,True,False])
>>> x & y
array([ True, False, False, False], dtype=bool)

Numpy ermöglicht numerische und logische Operationen auf arrays wie:

>>> z=np.array([1,2,3,4])
>>> z+1
array([2, 3, 4, 5])

Können Sie durchführen bitweise und-Verknüpfung mit der & Betreiber.

Statt einer Liste Verständnis, die Sie verwenden können, numpy zu generieren, die boolean-array direkt so:

>>> np.random.random(10)>.5
array([ True,  True,  True, False, False,  True,  True, False, False, False], dtype=bool)

InformationsquelleAutor der Antwort dawg

4

and ist nicht unbedingt ein boolescher operator, es gibt einen von zwei Argumente, die unabhängig von Ihrem Typ. Wenn das erste argument falsch ist-ish (Falsenumerischen null oder ein leerer string/container), es gibt das argument. Ansonsten, es gibt das zweite argument.

In deinem Fall, beide x und y sind nicht-leere Listen, so das erste argument ist immer wahr-ish, was bedeutet x and y zurück y und y and x zurück x.

InformationsquelleAutor der Antwort chepner
2

Sollte dies tun, was Sie wollen:
```
xy = [a and b for a, b in zip(x, y)]
```
Den Grund x and y zurück y und y and x zurück x ist, weil booleschen Operatoren in python gib den letzten Wert geprüft, bestimmt die wahr-heit des Ausdrucks. Nicht-leere list's bewerten zu True, und da and erforderlich, dass beide Operanden auswerten True die letzten Operanden geprüft wird der zweite operand ist. Kontrast mit x or y, was wieder x weil Sie nicht brauchen, um zu überprüfen y zu bestimmen, die wahr-heit des Ausdrucks.

InformationsquelleAutor der Antwort Cyphase
1

Anstatt
```
[a and b for a, b in zip(x, y)]
```
könnte man verwenden Sie einfach die Möglichkeit, numpy, sich zu vermehren bool-Werte:
```
(np.array(x)*np.array(y))
>> array([ True, False, False, False], dtype=bool)
```
Tun oder übersehe ich ein Sonderfall?

InformationsquelleAutor der Antwort Philipp

Können Sie die zip Funktion

x=[True,True,False,False]
y=[True,False,True,False]
z=[a and b for a,b in zip(x,y)]

InformationsquelleAutor der Antwort Uri Goren

0

Zusätzlich zu dem, was @Martijn Pieters hat geantwortet, ich möchte nur hinzufügen, den folgenden code zu erklären and und or Operationen in Aktion.

and gibt den ersten falsy-Wert festgestellt sonst die letzten argument ausgewertet.

Ähnlich or gibt den ersten Wert truthy begegnet else dem letzten argument ausgewertet.
```
nl1 = [3,3,3,3,0,0,0,0]
nl2 = [2,2,0,0,2,2,0,0]
nl3 = [1,0,1,0,1,0,1,0]
and_list = [a and b and c for a,b,c in zip(nl1,nl2,nl3)]
or_list = [a or b or c for a,b,c in zip(nl1,nl2,nl3)]
```
Werte sind

and_list = [1, 0, 0, 0, 0, 0, 0, 0]

or_list = [3, 3, 3, 3, 2, 2, 1, 0]

InformationsquelleAutor der Antwort Tony

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.