Wie testen mehrerer Variablen gegen den Wert?

Ich versuche, eine Funktion, die den Vergleich mehrerer Variablen eine integer-und Ausgabe eine Zeichenfolge aus drei Buchstaben. Ich Frage mich, ob es einen Weg gibt, zu übersetzen, dies in Python. Also sagen:

x = 0
y = 1
z = 3
mylist = []

if x or y or z == 0 :
    mylist.append("c")
if x or y or z == 1 :
    mylist.append("d")
if x or y or z == 2 :
    mylist.append("e")
if x or y or z == 3 : 
    mylist.append("f")

die würde zurückgeben einer Liste von

["c", "d", "f"]

Ist so etwas möglich?

verwenden 1 (Tupel)
Wenn Sie auswerten wollen, eine Liste von Anweisungen in einer beliebigen/allen Weise können Sie any/all Funktionen. Zum Beispiel: all([1, 2, 3, 4, False]) False zurück all([True, 1, 2, 3]) True zurück any([False, 0, 0, False]) False zurück any([False, 0, True, False]) True zurück
Ich habe eine Zusammenfassung der Beitrag basiert auf Antworten hier: medium.com/codervlogger/...
Diese Frage ist eine sehr beliebte doppelte Ziel, aber ich denke, es ist suboptimal für diesen Zweck. Die meisten Menschen versuchen, etwas zu tun, wie if x == 0 or 1:, das ist natürlich ähnlich if x or y == 0:, aber vielleicht ein wenig verwirrend für Anfänger, aber trotzdem. Angesichts der schieren Menge der "Warum ist nicht mein x == 0 or 1 arbeiten?" Fragen, ich würde viel lieber diese Frage wie unsere kanonischen doppelte Ziel für diese Fragen.
Nehmen Sie besonders vorsichtig, wenn Sie im Vergleich zu den "falsey" Werte wie 0, 0.0 oder False. Sie können einfach schreiben Sie falschen code gibt die "richtige" Antwort.

InformationsquelleAutor user1877442 | 2013-02-27

706

Verkennst du, wie Boolesche Ausdrücke der Arbeit; Sie arbeiten nicht wie ein englischer Satz und denke, dass Sie reden über den selben Vergleich für alle Namen hier. Sie sind auf der Suche nach:
```
if x == 1 or y == 1 or z == 1:
```
x und y sonst ausgewertet auf Ihre eigene (False wenn 0, True sonst).

Können Sie verkürzen, mit einem containment-test gegen ein Tupel:
```
if 1 in (x, y, z):
```
oder noch besser:
```
if 1 in {x, y, z}:
```
mit ein set zum Vorteil der konstant-Kosten-Mitgliedschaft testen (in wird eine Feste Menge an Zeit, was auch immer den linken Operanden ist).

Wenn Sie or, python sieht jede Seite der Betreiber als separate Ausdrücken. Der Ausdruck x or y == 1 behandelt wird, als erste ein boolescher test für x, dann, wenn, die Falsch ist, die expression y == 1 getestet.

Dies ist aufgrund operator-Rangfolge. Die or - operator hat einen niedrigeren Vorrang als die == test, so dass die letzteren ausgewertet ersten.

Jedoch, selbst wenn dies nicht der Fall, und der Ausdruck x or y or z == 1 war tatsächlich so interpretiert (x or y or z) == 1 statt, würde dies noch immer nicht tun, was Sie erwarten, es zu tun.

x or y or z bewerten würde, um das erste argument, das "truthy', z.B. nicht False numerischen 0 oder leer (siehe Boolesche Ausdrücke für details auf, was Python Auffassung ist falsch in einem boolean-Kontext).

Also für die Werte x = 2; y = 1; z = 0, x or y or z würde lösen zu 2, denn das ist die erste true-Wert wie in den Argumenten. Dann 2 == 1 wäre False, obwohl y == 1 wäre True.

Das gleiche gilt für die umgekehrte; die Prüfung mehrerer Werte für eine einzelne variable; x == 1 or 2 or 3 scheitern würden, aus den gleichen Gründen. Verwenden x == 1 or x == 2 or x == 3 oder x in {1, 2, 3}.

Ich würde nicht so schnell zu gehen für die set version. Tupel sind sehr Billig zu erstellen und Durchlaufen. Auf meinem Rechner zumindest Tupel sind schneller als die Sätze so lange, wie die Größe der Tupel ist um 4-8 Elemente. Wenn Sie Scannen müssen mehr als einen Satz, aber wenn Sie sind auf der Suche für ein Element, das aus 2-4 Möglichkeiten, ein Tupel ist noch schneller! Wenn Sie arrangieren kann für die wahrscheinlichste Fall ist der erste in der die Tupel, die zu gewinnen ist sogar noch größer: (mein test: timeit.timeit('0 in {seq}'.format(seq=tuple(range(9, -1, -1)))))
In Python 3.3 und höher, der Satz gespeichert ist, als eine Konstante, unter Umgehung der Schöpfung Zeit insgesamt, die Beseitigung der Zeitpunkt der Erstellung. Tupel kann Billig zu erstellen, die als Python-caches ein Bündel von Ihnen, um zu vermeiden, Speicher Abwanderung, so dass die größte Differenz mit-sets finden Sie hier.
Wenn Sie Zeit nur die test-Mitgliedschaft, bei Integer-sets und tuples sind ebenso schnell für das ideal-Szenario, passend zu den ersten element. Nach, dass Tupel verlieren gegenüber setzt.
Mit der set literal notation für diesen test ist keine Einsparungen, es sei denn, der Inhalt der set literal sind auch Literale, richtig? if 1 in {x, y, z}: kann nicht zwischengespeichert werden, die set, weil x, y und z ändern könnte, also entweder die Lösung braucht eine tuple oder set von Grund auf neu, und ich vermute, was auch immer-lookup-Einsparungen, die Sie bekommen könnten, wenn die Prüfung für die Mitgliedschaft würden überschwemmt werden von größeren set Zeitpunkt der Erstellung.
ja, peephole-Optimierung (sei es für in [...] oder in {...}) funktioniert nur, wenn der Inhalt der Liste oder legen Sie unveränderlich sind Literale zu.

InformationsquelleAutor Martijn Pieters
84

Dein problem ist mehr leicht behandelt mit einem dictionary-Struktur wie:
```
x = 0
y = 1
z = 3
d = {0: 'c', 1:'d', 2:'e', 3:'f'}
mylist = [d[k] for k in [x, y, z]]
```
Oder sogar d = "cdef" führt zu MyList = ["cdef"[k] for k in [x, y, z]]
oder map(lambda i: 'cdef'[i], [x, y, z])
die Ausgabe-Reihenfolge ist nicht bestimmt durch die dict, bestimmt es sich nach der Reihenfolge der Liste [x, y, z]
Abgesehen von der list-comprehension, die ich noch nicht vollständig daran gewöhnt, die meisten von uns hatten den gleichen reflex: bauen, dict !

InformationsquelleAutor dansalmo
55

Bisherige Lösung: Wie bereits von Martijn Pieters, den richtigen und schnellsten, format:
```
if 1 in {x, y, z}:
```
Das eine große Problem, das scheint nicht zu richten ist, dass Sie möchten, dass Ihre Ausgabe-Liste, um jeden Buchstaben nach wahr, wenn Aussage.

Mit nur Martijn Pieters' Rat würden Sie jetzt haben:
```
if 0 in {x, y, z}:
    Mylist.append("c")
elif 1 in {x, y, z}:
    Mylist.append("d")
...
```
Problem: Die erste if-Anweisung würde true zurückgeben, und Sie würde nie an die folgende elif-Anweisung. Also deine Liste würde einfach zurück:
```
["c"]
```
Was Sie wollen, ist zu haben getrennte if-Anweisungen, so dass python wird Lesen Sie jede Aussage, ob der ehemalige wahr ist oder falsch. Wie:
```
if 0 in {x, y, z}:
    Mylist.append("c")
if 1 in {x, y, z}:
    Mylist.append("d")
if 2 in {x, y, z}:
    Mylist.append("e")
...
```
Dies funktionieren wird, aber 'wenn' Sie sind komfortabel mit Wörterbüchern (siehe was ich dort getan haben), können Sie reinigen Sie diese mit einer ersten dictionary-Zuordnung der zahlen zu den Buchstaben, die Sie wollen, dann nur mit einem " for " - Schleife:
```
numToLetters = {0:"c", 1:"d", 2:"e", 3:"f"}
for number in numToLetters:
    if number in {x, y, z}:
        Mylist.append(numToLetters[number])
```
InformationsquelleAutor ThatGuyRussell
40

Den direkten Weg zu schreiben x or y or z == 0 ist
```
if any(map((lambda value: value == 0), (x,y,z))):
    pass # write your logic.
```
Aber ich glaube nicht, dass Sie es mögen. 🙂
Und so hässlich ist.

Andere Weise (besser) ist:
```
0 in (x, y, z)
```
BTW viel ifs geschrieben werden konnte, wie so etwas
```
my_cases = {
    0: Mylist.append("c"),
    1: Mylist.append("d")
    # ..
}

for key in my_cases:
    if key in (x,y,z):
        my_cases[key]()
        break
```
In deinem Beispiel der dict statt einer Taste, erhalten Sie Fehler, weil der return-Wert .append ist None und die Berufung None gibt einen AttributeError. Im Allgemeinen Stimme ich mit dieser Methode, obwohl.
die dict-statt ein Schlüssel ist falsch, Sie bekommen Mylist=['c', 'd'] wenn das Wörterbuch Holen initialisiert, auch wenn Sie auskommentiert "for..loop" Teil

InformationsquelleAutor akaRem
28

Wenn Sie sehr sehr faul sind, können Sie legen Sie die Werte in ein array. Wie
```
list = []
list.append(x)
list.append(y)
list.append(z)
nums = [add numbers here]
letters = [add corresponding letters here]
for index in range(len(nums)):
    for obj in list:
        if obj == num[index]:
            MyList.append(letters[index])
            break
```
Können Sie auch die zahlen und Buchstaben in einem Wörterbuch nach und es tun, aber dies ist wahrscheinlich VIEL komplizierter, als einfach die if-Anweisungen. Das ist, was Sie erhalten, für den Versuch besonders faul 🙂

Eins noch, Ihr
```
if x or y or z == 0:
```
kompiliert wird, aber nicht so, wie Sie es wollen. Wenn du einfach eine variable in einer if-Anweisung (Beispiel)
```
if b
```
das Programm prüfen, ob die variable nicht null ist. Eine andere Art und Weise zu schreiben, die obige Aussage (was mehr Sinn macht) ist
```
if bool(b)
```
Bool ist eine eingebaute Funktion in python, die im Grunde genommen den Befehl zu überprüfen, die eine Boolesche Aussage (Wenn Sie nicht wissen, was das ist, es ist, was Sie versuchen, in Ihrem if-Anweisung jetzt :))

Anderen faulen Weg, die ich gefunden ist :
```
if any([x==0, y==0, z==0])
```
InformationsquelleAutor ytpillai
26

Zu prüfen, ob ein Wert enthalten ist, in einen Satz von Variablen, die Sie verwenden können, die eingebauten Module itertools und operator.

Beispiel:

Importe:
```
from itertools import repeat
from operator import contains
```
Variablen deklarieren:
```
x = 0
y = 1
z = 3
```
Erstellen Zuordnung von Werten (in der Reihenfolge, die Sie überprüfen möchten):
```
check_values = (0, 1, 3)
```
Verwenden itertools zu ermöglichen Wiederholung der Variablen:
```
check_vars = repeat((x, y, z))
```
Schließlich verwenden die map Funktion zum erstellen einen iterator:
```
checker = map(contains, check_vars, check_values)
```
Dann, wenn eine überprüfung der Werte (in der ursprünglichen Reihenfolge), verwenden Sie next():
```
if next(checker)  # Checks for 0
    # Do something
    pass
elif next(checker)  # Checks for 1
    # Do something
    pass
```
etc...

Diese hat einen Vorteil gegenüber der lambda x: x in (variables) weil operator ist mit einem eingebauten Modul und ist schneller und effizienter als die Verwendung von lambda die zum erstellen einer custom in-place-Funktion.

Andere Möglichkeit für die überprüfung, ob es eine nicht-null (oder False) Wert in einer Liste:
```
not (x and y and z)
```
Äquivalent:
```
not all((x, y, z))
```
Dies beantwortet nicht die OP ' s Frage. Es deckt nur den ersten Fall im Beispiel.

InformationsquelleAutor GuiltyDolphin

Denke ich, dass dieses handle es besser:

my_dict = {0: "c", 1: "d", 2: "e", 3: "f"}

def validate(x, y, z):
    for ele in [x, y, z]:
        if ele in my_dict.keys():
            return my_dict[ele]

Ausgabe:

print validate(0, 8, 9)
c
print validate(9, 8, 9)
None
print validate(9, 8, 2)
e

InformationsquelleAutor Bhargav Boda

24

Set ist der gute Ansatz hier, weil es Aufträge, die der Variablen, was zu sein scheint, Ihr Ziel hier. {z,y,x} ist {0,1,3} unabhängig von der Reihenfolge der Parameter.
```
>>> ["cdef"[i] for i in {z,x,y}]
['c', 'd', 'f']
```
Diese Weise die gesamte Lösung ist O(n).

Sollten Sie eine Beschreibung hinzufügen, was dein code leistet und wie er es tut. Kurze Antworten, die nur mithilfe von code wird abgeraten

InformationsquelleAutor B. M.

Wenn Sie möchten, verwenden Sie if, else-Anweisungen folgende andere Lösung vor:

myList = []
aList = [0, 1, 3]

for l in aList:
    if l==0: myList.append('c')
    elif l==1: myList.append('d')
    elif l==2: myList.append('e')
    elif l==3: myList.append('f')

print(myList)

InformationsquelleAutor hamid

24

All die hervorragenden Antworten, die sich hier konzentrieren sich auf die spezifischen Anforderungen der original-poster und konzentrieren sich auf die if 1 in {x,y,z} Lösung vorgebracht, die von Martijn Pieters.

Was Sie ignorieren, ist die breitere Implikation der Frage:

Wie kann ich testen, eine variable auf mehrere Werte?

Die Lösung wird nicht funktionieren, für die teilweise trifft, wenn Sie mit Zeichenfolgen, zum Beispiel:

Testen, ob die Zeichenfolge "Wild" ist in mehrere Werte
```
>>> x = "Wild things"
>>> y = "throttle it back"
>>> z = "in the beginning"
>>> if "Wild" in {x, y, z}: print (True)
... 
```
oder
```
>>> x = "Wild things"
>>> y = "throttle it back"
>>> z = "in the beginning"
>>> if "Wild" in [x, y, z]: print (True)
... 
```
für dieses Szenario, es ist am einfachsten zu konvertieren zu einem string
```
>>> [x, y, z]
['Wild things', 'throttle it back', 'in the beginning']
>>> {x, y, z}
{'in the beginning', 'throttle it back', 'Wild things'}
>>> 

>>> if "Wild" in str([x, y, z]): print (True)
... 
True
>>> if "Wild" in str({x, y, z}): print (True)
... 
True
```
Es sollte angemerkt werden, jedoch, wie bereits erwähnt, durch @codeforester Wort boundries verloren, mit dieser Methode, in:
```
>>> x=['Wild things', 'throttle it back', 'in the beginning']
>>> if "rot" in str(x): print(True)
... 
True
```
den 3 Buchstaben rot existieren, die in Kombination in der Liste, aber nicht als einzelne Wörter. Tests für " rot " würde scheitern, aber wenn man in der Liste, die Elemente wurden "in der Hölle verrotten!", das würde scheitern.

Das Ende vom Lied sein, seien Sie vorsichtig mit Ihren Suchkriterien, wenn die Nutzung dieser Methode und werden Sie sich bewusst, dass es nicht über diese Einschränkung.

Mit "convert to string" - Ansatz, verlieren wir das Wort Grenzen und die in - Prüfung nicht das richtige zu tun.
Ihr Punkt, ist fair, und ich erwähne es in der Antwort.

InformationsquelleAutor Rolf of Saxony

d = {0:'c', 1:'d', 2:'e', 3: 'f'}
x, y, z = (0, 1, 3)
print [v for (k,v) in d.items() if x==k or y==k or z==k]

InformationsquelleAutor Saksham Varma

Dieser code kann hilfreich sein,

L ={x, y, z}
T= ((0,"c"),(1,"d"),(2,"e"),(3,"f"),)
List2=[]
for t in T :
if t[0] in L :
    List2.append(t[1])
    break;

InformationsquelleAutor michael zxc858

One-line-Lösung:

mylist = [{0: 'c', 1: 'd', 2: 'e', 3: 'f'}[i] for i in [0, 1, 2, 3] if i in (x, y, z)]

Oder:

mylist = ['cdef'[i] for i in range(4) if i in (x, y, z)]

InformationsquelleAutor Vinayak Kaniyarakkal

Können Sie versuchen Sie die Methode unten dargestellt. In dieser Methode werden Sie die Freiheit haben, geben Sie/Eingabe der Anzahl der Variablen, die Sie eingeben möchten.

mydict = {0:"c", 1:"d", 2:"e", 3:"f"}
mylist= []

num_var = int(raw_input("How many variables? ")) #Enter 3 when asked for input.

for i in range(num_var): 
    ''' Enter 0 as first input, 1 as second input and 3 as third input.'''
    globals()['var'+str('i').zfill(3)] = int(raw_input("Enter an integer between 0 and 3 "))
    mylist += mydict[globals()['var'+str('i').zfill(3)]]

print mylist
>>> ['c', 'd', 'f']

InformationsquelleAutor Siddharth Satpathy

Es kann leicht getan werden, wie

for value in [var1,var2,var3]:
     li.append("targetValue")

InformationsquelleAutor Seenivasan

4

Vielleicht brauchen Sie direkte Formel für das output-bits festgelegt.
```
x=0 or y=0 or z=0   is equivalent to x*y*z = 0

x=1 or y=1 or z=1   is equivalent to (x-1)*(y-1)*(z-1)=0

x=2 or y=2 or z=2   is equivalent to (x-2)*(y-2)*(z-2)=0
```
Let ' s Karte-bits: 'c':1 'd':0xb10 'e':0xb100 'f':0xb1000

Verhältnis von isc ('c'):
```
if xyz=0 then isc=1 else isc=0
```
Verwenden Sie den Mathematik-wenn Formel https://youtu.be/KAdKCgBGK0k?list=PLnI9xbPdZUAmUL8htSl6vToPQRRN3hhFp&t=315

[c]: (xyz=0 and isc=1) or (((xyz=0 and isc=1) or (isc=0)) and (isc=0))

[d]: ((x-1)(y-1)(z-1)=0 and isc=2) or (((xyz=0 and isd=2) or (isc=0)) and (isc=0))

...

Verbinden Sie diese Formeln durch die folgende Logik:
- Logik and ist die Summe der Quadrate der Gleichungen
- Logik or ist das Produkt der Gleichungen
und du wirst eine totale Gleichung
express-Summe und Sie haben die volle Formel der Summe

dann Summe&1 ist c, Summe&2 ist d, Summe&4 ist e, Summe&5 ist f

Danach können Sie form vordefinierten array, wobei der index der string-Elemente entsprechen würde bereit string.

array[sum] gibt Sie die Zeichenfolge.

InformationsquelleAutor Sergei
3

Die mnemonische Form der Darstellung Ihrer pseudo-code in Python wäre:
```
x = 0
y = 1
z = 3
mylist = []

if any(v == 0 for v in (x, y, z)):
    mylist.append("c")
if any(v == 1 for v in (x, y, z)):
    mylist.append("d")
if any(v == 2 for v in (x, y, z)):
    mylist.append("e")
if any(v == 3 for v in (x, y, z)):
    mylist.append("f")
```
Dieser Ansatz ist universeller als ` wenn 2 (x, y, z): mylist.append('e')`, da kann beliebige Vergleiche (z.B. if any(v >= 42 for v in (x, y, z)): ). Und die Leistung aller 3 Methoden (2 in {x,y,z}, 2 in (x,y,z), any(_v == 2 for _v in (x,y,z))) scheint zu sein, fast das gleiche in CPython3.6 (siehe Gist)

InformationsquelleAutor rsalmei
3

Sieht aus wie baut man eine Art Caesar-Chiffre.

Einen viel allgemeineren Ansatz ist dieser:
```
input_values = (0, 1, 3)
origo = ord('c')
[chr(val + origo) for val in inputs]
```
Ausgänge
```
['c', 'd', 'f']
```
Nicht sicher, ob es ein ungewollter Nebeneffekt des Codes, aber die Reihenfolge der Ausgabe wird immer sortiert werden.

Wenn dies ist, was Sie wollen, die Letzte Zeile kann geändert werden, um:
```
sorted([chr(val + origo) for val in inputs])
```
InformationsquelleAutor firelynx
3

Testen mehrerer Variablen mit einem einzigen Wert: if 1 in {a,b,c}:

Testen mehrerer Werte einer Variablen: if a in {1, 2, 3}:

InformationsquelleAutor Md. Alamin Mahamud

Dies wird Ihnen helfen.

def test_fun(val):
    x = 0
    y = 1
    z = 2
    myList = []
    if val in (x, y, z) and val == 0:
        myList.append("C")
    if val in (x, y, z) and val == 1:
        myList.append("D")
    if val in (x, y, z) and val == 2:
        myList.append("E")

test_fun(2);

InformationsquelleAutor Mayur

Können Sie Wörterbuch :

x = 0
y = 1
z = 3
list=[]
dict = {0: 'c', 1: 'd', 2: 'e', 3: 'f'}
if x in dict:
    list.append(dict[x])
else:
    pass

if y in dict:
    list.append(dict[y])
else:
    pass
if z in dict:
    list.append(dict[z])
else:
    pass

print list

Dies kann append gleichen mehr dann einmal. Set?

InformationsquelleAutor Rohit Gawas

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.