Das deutsche Python-Forum

Hallo zusammen,

ich habe folgendes gegeben:

a_list = [1,2,3,4]
b = 5

Nun möchte ich, dass ein Text ("OK") ausgegeben wird, wenn b nicht in a_list enthalten ist. Das ist ja eigentlich nicht schwer. Nun frage ich mich aber, welche der beiden Möglichkeiten die richtige ist bzw. man normalerweise verwendet?

a) if not b in a_list: print "OK"
b) if b not in a_list: print "OK"

Danke euch schonmal...

CU,
API

api hat geschrieben:welche der beiden Möglichkeiten die richtige ist bzw. man normalerweise verwendet?

a) if not b in a_list: print "OK"
b) if b not in a_list: print "OK"

Die richtige Antwort ist b), da in Python not in ein Operator ist.

Bei weiteren Fragen dieser Art: hier werden sie geholfen.

Gruß,
Mick.

Denke mal, das erste ist ein logisches NOT.
Die zweite Variante gibt es wahrscheinlich nur, weil sich das dann mehr wie menschliche Sprache (Englisch) anhört.
Den "... in .."-Operator gibt es ja wohl nicht in vielen anderen Sprachen, er ist nur sehr bequem, und deutet ebenfalls schon in Richtung Englisch.
Mit ".. not in .." entfernt sich Python dann noch mehr von dem, was in anderen Sprachen üblich ist, zugunsten von mehr Benutzer-/Programmiererfreundlichkeit.

Gruß

@pillmuncher: Ok, das leuchtet ein. Aber wo hast du das auf der PEP-8-Seite gefunden?

Hi,

http://docs.python.org/release/3.1.3/tu ... tures.html
5.7. More on Conditions
"The conditions used in while and if statements can contain any operators, not just comparisons.

The comparison operators in and not in check whether a value occurs (does not occur) in a sequence. "

Gruss,
Torres

Du kannst beides verwenden. Ich finde das a schöner.

api hat geschrieben:@pillmuncher: Ok, das leuchtet ein. Aber wo hast du das auf der PEP-8-Seite gefunden?

Direkt steht da nichts dazu in PEP8. Allerdings wird dort not in unter Other Recommendations (allerdings in ganz anderem Zusammenhang) als Operator gelistet.

Gibt es eigentlich einen Unterschied in diesen beiden Statements? Behandelt der Interpreter das evtl irgendwie anders?

Soll heissen, gibt es vielleicht einen Geschwindigkeitsunterschied?

Nein, sie sind äquivalent. Und auf der Ebene solltest du dir keine Gedanken über Geschwindigkeit machen.

api hat geschrieben: Soll heissen, gibt es vielleicht einen Geschwindigkeitsunterschied?

Ich hatte das vorhin mit grossen Listen getestet und habe keinen signifikanten Unterschied feststellen koennen.
Gruss
Torres (benutzte bisher auch eher if not in, werde ich mir aber abgewoehnen)

torres hat geschrieben:

api hat geschrieben: Torres (benutzte bisher auch eher if not in, werde ich mir aber abgewoehnen)

Stattdessen? not if in? in not if?

Ich würde von a) nachdrücklich abraten, da man beim Lesen immer überlegen muss, welcher Operator die höhere Präzedenz hat, also ob "not b" oder "b in a_list" zuerst ausgewertet wird (was jeweils zu unterschiedlichen Ergebnissen führen würde). Bei b) dagegen ist nur ein Operator im Spiel, mithin gibt es keine Unklarheiten.

stattdessen zukuenftig if b not in

@lunar: Seh ich persönlich anders. Und wirklich überlegen muss man da nicht. Weil es gibt AFAIK keinen Fall, wo es unklar wäre. `if not` ist für mich quasi ein Ausdruck.

Ok. Ich nehms zurück . Beim oder siehts wieder ganz anders aus

@problembär: Das es zum ``in``-Operator ein ``not in``-Gegenstück gibt, ist IMHO konsequent. Denn für ``==`` gibt es ja auch ein ``!=``, so dass man nicht ``not (a == b)`` schreiben muss, wenn man auf Ungleichheit testen muss. Zu ``is`` gibt es konsequenterweise dann auch ein ``is not``.

Verschiedene Sprachen lösen das unterschiedlich. Einige gar nicht, dass heisst man muss sich so einen Test selber programmieren, andere über Funktionen/Methoden, und einige über Operatoren. Und das alles jeweils in verschiedenen Graden von „Lesbarkeit“. Mal ein paar Beispiele:

Eher kompliziertere Formulierungen: ``g_list_find(a_list, b) != NULL`` (C/GLib), ``(find (lambda (x) (= b x)) a-list)`` (Scheme), ``find(aList.begin(), aList.end(), b) != aList.end()`` (C++/STL), ``b `elem` aList`` (Haskell)

Solche die ein verständliches Wort dafür nehmen: ``aList.Contains(b)`` (C#), ``aList.contains(b)`` (D, Java, C++/Qt), ``aList includes: b`` (Smalltalk), ``aList contains(b)`` (Io)

Und da wo es ``in`` heisst (und bis auf bei Io ein Operator ist): ``b in(aList)`` (Io), ``b in aList`` (CoffeeScript, JavaScript, Python)

D hat einen ``in``-Operator der zum Beispiel für Abbildungen implementiert ist, die in D als assoziative Arrays bezeichnet werden.

Also, ich folge dem Ansatz, dass wenn es schon einen "not in"-Operator gibt, so sollte man ihn auch benutzen.

Auch teile ich die Ansicht, dass bei komplexeren Statements der "not in"-Operator einfacher zu handhaben - bzw. verständlicher ist.