Comment tester plusieurs variables en fonction de la valeur?

Je suis en train de faire une fonction qui permettra de comparer plusieurs variables d'un entier et de sortie d'une chaîne de trois lettres. Je me demandais si il y avait un moyen de les traduire en Python. Donc, dire:

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")

qui permettrait le retour d'une liste de 

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

Est quelque chose comme cela possible?

  • utilisation 1 en (n-uplet)
  • Lorsque vous souhaitez évaluer une liste de déclarations dans un tout manière, vous pouvez utiliser any/all fonctions. Par exemple: all([1, 2, 3, 4, False]) retournera False all([True, 1, 2, 3]) retournera True any([False, 0, 0, False]) retournera False any([False, 0, True, False]) retournera True
  • J'ai fait un résumé de message basé sur les réponses ici: medium.com/codervlogger/...
  • Cette question est très populaire en double objectif, mais je pense que c'est sous-optimale à cette fin. La plupart des gens essaient de faire quelque chose comme if x == 0 or 1:, ce qui est évidemment semblable à if x or y == 0:, mais pourrait être un peu déroutant pour les débutants néanmoins. Etant donné le volume de "Pourquoi n'est pas mon x == 0 or 1 de travail?" des questions, je préférerais utiliser les cette question comme nos canonique double cible de ces questions.
  • Prendre des précautions supplémentaires lors de la comparaison à "falsey" des valeurs comme 0, 0.0 ou False. Vous pouvez facilement écrire du mauvais code qui donne la "bonne" réponse.
InformationsquelleAutor user1877442 | 2013-02-27
  1. 740

    Vous ne comprenez pas comment les expressions booléennes de travail; ils ne travaillent pas comme une phrase anglaise et suppose que vous parlez de la même comparaison pour tous les noms ici. Vous êtes à la recherche pour:

    if x == 1 or y == 1 or z == 1:

    x et y sont par ailleurs évalués sur leur propre (False si 0, True contraire).

    Vous pouvez raccourcir à l'aide d'un test de confinement contre un n-uplet:

    if 1 in (x, y, z):

    ou mieux encore:

    if 1 in {x, y, z}:

    à l'aide de un set de prendre avantage de la constante-coût de l'adhésion d'essai (in prend un montant fixe de temps, quelle que soit la gauche opérande est).

    Lorsque vous utilisez or, python voit de chaque côté de l'opérateur séparé expressions. L'expression x or y == 1 est traitée comme la première, un boolean test pour x, alors si c'est Faux, l'expression y == 1 est testé.

    Cela est dû à la priorité de l'opérateur. Le or opérateur a une priorité plus basse que la == de test, de sorte que le dernier est évalué première.

    Cependant, même si cela était pas le cas, et l'expression x or y or z == 1 a effectivement été interprété comme (x or y or z) == 1 au lieu de cela, ce serait encore de ne pas faire ce que vous vous attendez à faire.

    x or y or z d'évaluer au premier argument qui est "truthy', par exemple, ne pas False, numérique 0 ou vide (voir des expressions booléennes pour plus de détails sur ce que Python considère faux dans un contexte booléen).

    Donc pour les valeurs x = 2; y = 1; z = 0, x or y or z permettrait de résoudre à 2, parce que c'est le premier vrai-comme valeur dans les arguments. Puis 2 == 1 serait False, même si y == 1 serait True.

    Il en serait de même à l'inverse, de tester plusieurs valeurs par rapport à une seule variable; x == 1 or 2 or 3 serait un échec pour les mêmes raisons. Utilisation x == 1 or x == 2 or x == 3 ou x in {1, 2, 3}.

    • Je ne voudrais pas être si prompts à aller pour le set version. Tuple sont très bon marché à créer et à parcourir. Sur ma machine, au moins, les tuples sont plus rapides que les jeux, aussi longtemps que la taille de la n-uplet est autour de 4 à 8 éléments. Si vous devez analyser de plus, l'utilisation d'un ensemble, mais si vous êtes à la recherche d'un élément de 2-4 possibilités, un tuple est encore plus rapide! Si vous pouvez vous arranger pour la plupart des cas probable d'être le premier dans le tuple, la victoire est encore plus grand: (mon test: timeit.timeit('0 in {seq}'.format(seq=tuple(range(9, -1, -1)))))
    • En Python 3.3 et le haut, l'ensemble est stocké comme une constante, en contournant le temps de création tout à fait, en éliminant le temps de création. Les Tuples peut être bon de le créer comme Python cache une liasse d'entre eux pour éviter les problèmes de mémoire le taux de désabonnement, faisant que la plus grande différence avec les jeux ici.
    • Si vous avez le temps tout l'adhésion d'essai, pour les entiers et ensembles de n-uplets sont tout aussi vite pour le scénario idéal, la mise en correspondance du premier élément. Après que les tuples de perdre aux jeux.
    • À l'aide de la set littérale de notation pour ce test n'est pas une épargne à moins que le contenu de la set littérale sont également littéraux, droit? if 1 in {x, y, z}: ne peut pas mettre en cache les set, parce que x, y et z pourrait changer, donc soit la solution a besoin pour construire une tuple ou set à partir de zéro, et je soupçonne que quelle que soit la recherche d'économies que vous pouvez obtenir lorsque la vérification de l'adhésion pourraient être submergés par une plus grande set moment de la création.
    • oui, judas optimisation (que ce soit pour in [...] ou in {...}) ne fonctionne que si le contenu de la liste ou un ensemble sont immuables littéraux de trop.
    • par curiosité, j'ai une liste d'Url comme des chaînes par lequel je vérifie si la chaîne contient plusieurs sous-chaînes (c'est à dire 'word1' in string and 'word2' in string...). serait la même syntaxe (c'est à dire string in (word1, word2):) les travaux dans ce scénario, ou, comme je suis dans l'attente, serait-il un échec?
    • c'est le mauvais test; string n'est pas contenue dans la séquence (word1, word2). Vous pouvez utiliser all(w in string for w in sequence_of_words_to_test) si vous avez plusieurs mots de tester en une seule chaîne. Ou utiliser le word1 in string and word2 in string approche si vous avez seulement 2 ou 3 chaînes de test, et ils sont codés en dur.
    • in n'est pas constante de temps "quelle que soit la gauche opérande est" - techniquement avec set vous auriez besoin, au plus, le temps nécessaire pour retourner la valeur de hachage (le calculer si vous n'avez pas de cache) et font une est égale à vérifier, ce qui peut très bien prendre plus de temps constant. Bien que ce coût existe aussi avec des n-uplets.
    • le temps n'est pas une quantité fixe. Cela signifie que la complexité algorithmique est O(1); il n'a pas d'importance combien d'éléments sont, dans l'ensemble, des tests de confinement va prendre la même quantité de temps, à peu près, indépendamment de la taille de l'ensemble.
    • des tests de confinement par rapport à une liste ou un tuple ou une autre séquence se linéaire de temps, O(N), chaque élément est testé un par un. Ainsi, lorsque le tuple ou une liste ou une séquence double, le temps moyen. Les ensembles et les dictionnaires ainsi battre séquences, d'autant que le nombre d'éléments augmente.
    • le calcul de la valeur de hachage est distinct de O(quelque chose), qui est indépendant de la taille N de l'ensemble, dict, tuple, etc. sur le côté droit. Python immuable types de cache de la valeur de toute façon.
    • Je sais, mais je ne suis toujours pas sûr de savoir pourquoi vous dites "quelle que soit la gauche opérande est", parce que le coût des modifications en fonction des éléments que vous avez dans l'ensemble (même si c'est toujours la pseudo-constante) - je serais bien avec ce paragraphe si vous retirez de la partie, ou de le remplacer par "quel que soit le nombre d'éléments que vous avez dans le jeu*".
    • Je ne vois vraiment pas besoin. Bad hash implémentations sont l'exception, pas la norme. Nous aurions à se qualifier listobj[index] que O(1) (fourni index n'est pas une coutume objet Python avec un mauvais __index__ mise en œuvre), ou le tri d'une liste *O(N log N) (à condition que le contenu n'ont pas de complexe de la commande implémentations jeter hors de comparaison des coûts). Pour contains opérations, le coût peut être supposée constante. Si le hachage coût pour un "mauvais acteur" de l'objet est grande, ça va encore être le même coût indépendant de la taille de l'ensemble que vous tester.
    • bien sûr, les tuples sont plus rapides que les ensembles lorsque l'on compare les 2-3 valeurs, mais je dirais que la réponse de transmettre les bonnes pratiques d'une époque perspective de la complexité beaucoup plus élevé que la réponse à profiter des détails de mise en œuvre (sous réserve de modifications) pour atteindre microptimizations sur le niveau de "sérieusement, ne vous inquiétez pas à ce sujet".
    • C'est une chose simple. Il suffit de l'ajouter pour chaque section, la variable à tester. J'ai lu des choses, et à mon avis, ils n'ont aucun rapport avec la question que ce soit.
    • a) La set approche n'est pas évidente, et il y a toujours le générique piège avec "falsey" non-valeurs entières: False in (1,0,2) et 0.0 in (1,0,2) à la fois donner True. b) Alias: l'utilisation accidentelle de la if x is y avec de petits nombres entiers et l'internement des chaînes de caractères peut aussi donner la mauvaise réponse. Sont de cette question et ses réponses uniquement pour les entiers? c) in est surchargé pour les chaînes et les séquences; considérer: '77' in '777' est Vrai, mais '77' in ('666','777') est Faux. d) ...
    • d) les sous-classes/super-classes: dict() == collections.Counter() est Vrai. e) les Itérateurs et les plages: [0,1,2] == range(3) est Faux. Bien que [0,1,2] == list(range(3)) est Vrai
    • Je ne sais pas ce que vous obtenez ici. Vous décrivent normale de l'égalité des tests règles, des ensembles de ne pas modifier ces. False == 0 est également Vrai, et donc est 0.0 == 0. Et au moins avec un ensemble d'adhésion d'essai vous éviter parfois fait is erreur. Je ne dis rien sur l'utilisation de in sur des chaînes ou des n-uplets.

    InformationsquelleAutor Martijn Pieters
  2. 85

    Votre problème est plus facile à régler avec un dictionnaire de la structure comme:

    x = 0
y = 1
z = 3
d = {0: 'c', 1:'d', 2:'e', 3:'f'}
mylist = [d[k] for k in [x, y, z]]
    • Ou même d = "cdef" qui conduit à MyList = ["cdef"[k] for k in [x, y, z]]
    • ou map(lambda i: 'cdef'[i], [x, y, z])
    • l'ordre de sortie n'est pas déterminé par la dict, il est déterminé par l'ordre de la liste [x, y, z]
    • En dehors de la compréhension de liste dont je ne suis pas encore totalement habitué, la plupart d'entre nous a eu le même réflexe: construire que le dict !
    InformationsquelleAutor dansalmo
  3. 57

    Comme indiqué par Martijn Pieters, le bon, et le plus rapide, le format est:

    if 1 in {x, y, z}:

    À l'aide de ses conseils ont séparé si-états, de sorte que Python va lire chaque énoncé de savoir si les anciens ont été True ou False. Tels que:

    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")
...

    Cela va fonctionner, mais si vous êtes à l'aise à l'aide de dictionnaires (voir ce que j'ai fait là), vous pouvez nettoyer ce en faisant un premier dictionnaire de la cartographie du nombre de lettres que vous voulez, puis juste à l'aide d'une boucle for:

    num_to_letters = {0: "c", 1: "d", 2: "e", 3: "f"}
for number in num_to_letters:
    if number in {x, y, z}:
        mylist.append(num_to_letters[number])
    InformationsquelleAutor ThatGuyRussell
  4. 42

    La voie la plus directe pour écrire x or y or z == 0 est

    if any(map((lambda value: value == 0), (x,y,z))):
    pass # write your logic.

    Mais je ne crois pas, vous l'aimez. 🙂
    Et de cette façon, c'est moche.

    L'autre sens (une meilleure) est:

    0 in (x, y, z)

    BTW beaucoup de ifs) peut être écrit quelque chose comme cela

    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
    • Dans votre exemple de la dict au lieu d'une clé, vous obtiendrez des erreurs parce que la valeur de retour de .append est None, et en appelant None donne un AttributeError. En général je suis d'accord avec cette méthode, bien que.
    • le dict au lieu d'une clé est fausse, vous obtiendrez Maliste=['c', 'd'] lorsque le dictionnaire de l'initialisation, même si vous avez dit "pour..boucle" partie
    InformationsquelleAutor akaRem
  5. 29

    Si vous ÊTES très très paresseux, vous pouvez mettre les valeurs dans un tableau. Comme

    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

    Vous pouvez aussi mettre les chiffres et de lettres dans un dictionnaire et de le faire, mais ce n'est probablement BEAUCOUP plus compliqué que de simplement les instructions if. C'est ce que vous obtenez pour essayer d'être très paresseux 🙂

    Une chose de plus, votre 

    if x or y or z == 0:

    de compiler, mais pas dans la façon dont vous le souhaitez. Lorsqu'il vous suffit de mettre une variable dans une instruction if (exemple)

    if b

    le programme va vérifier si la variable n'est pas nulle. Une autre façon d'écrire la déclaration ci-dessus (ce qui fait plus de sens) est 

    if bool(b)

    Bool est une fonction intégrée de fonction en python qui fait de la commande de vérification d'une proposition booléenne (Si vous ne savez pas ce que c'est, c'est ce que vous essayez de vous rendre dans votre déclaration si en ce moment :))

    Une autre manière paresseuse que j'ai trouvé est :

    if any([x==0, y==0, z==0])
    InformationsquelleAutor ytpillai
  6. 27

    Pour vérifier si une valeur est contenue dans un ensemble de variables, vous pouvez utiliser la fonction intégrée de modules itertools et operator.

    Par exemple:

    Importations:

    from itertools import repeat
from operator import contains

    Déclarer des variables:

    x = 0
y = 1
z = 3

    Créer le mappage des valeurs (dans l'ordre que vous voulez vérifier):

    check_values = (0, 1, 3)

    Utilisation itertools pour permettre la répétition des variables:

    check_vars = repeat((x, y, z))

    Enfin, l'utilisation de la map fonction pour créer un itérateur:

    checker = map(contains, check_vars, check_values)

    Puis, lors de la vérification des valeurs (dans l'ordre d'origine), l'utilisation next():

    if next(checker)  # Checks for 0
    # Do something
    pass
elif next(checker)  # Checks for 1
    # Do something
    pass

    etc...

    Ce qui a un avantage sur le lambda x: x in (variables) parce que operator est une fonction intégrée de module et il est plus rapide et plus efficace que l'utilisation lambda qui a créer un personnalisé en place de la fonction.

    Une autre option pour vérifier si il est non nulle (ou Faux) de la valeur dans une liste:

    not (x and y and z)

    Équivalent:

    not all((x, y, z))
    • Cela ne veut pas répondre à l'OP de la question. Il ne couvre que le premier cas dans l'exemple fourni.
    InformationsquelleAutor GuiltyDolphin
  7. 25

    Je pense que ce sera mieux le gérer:

    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]

    De sortie:

    print validate(0, 8, 9)
c
print validate(9, 8, 9)
None
print validate(9, 8, 2)
e
    InformationsquelleAutor Bhargav Boda
  8. 25

    Est la bonne approche, car il commande les variables, ce qui semble être votre but ici. {z,y,x} est {0,1,3} quel que soit l'ordre des paramètres.

    >>> ["cdef"[i] for i in {z,x,y}]
['c', 'd', 'f']

    De cette façon, l'ensemble de la solution est O(n).

    • Vous devez ajouter une description de votre code accomplit et comment il le fait. Des réponses courtes en utilisant uniquement du code est découragé
    InformationsquelleAutor B. M.
  9. 25

    Si vous souhaitez utiliser si, d'autre des déclarations suivantes est une autre solution:

    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
  10. 25

    Toutes les excellentes réponses fournies ici de se concentrer sur les besoins spécifiques de l'original de l'affiche et de se concentrer sur la if 1 in {x,y,z} solutions mises de l'avant par Martijn Pieters.

    Ce qu'ils ignorent, c'est le plus large implication de la question:

    Comment puis-je tester une variable à l'encontre de plusieurs valeurs?

    La solution proposée ne fonctionne pas pour les partiels succès si l'aide de cordes par exemple:

    Test si la chaîne de caractères "Sauvage" est à valeurs multiples

    >>> x = "Wild things"
>>> y = "throttle it back"
>>> z = "in the beginning"
>>> if "Wild" in {x, y, z}: print (True)
...

    ou

    >>> x = "Wild things"
>>> y = "throttle it back"
>>> z = "in the beginning"
>>> if "Wild" in [x, y, z]: print (True)
...

    pour ce scénario, il est plus facile de convertir une chaîne de caractères

    >>> [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

    Il convient de noter, cependant, comme mentionné par @codeforester, ce mot boundries sont perdus avec cette méthode, comme dans: 

    >>> x=['Wild things', 'throttle it back', 'in the beginning']
>>> if "rot" in str(x): print(True)
... 
True

    les 3 lettres rot n'existe pas en combinaison dans la liste, mais pas comme un mot. Test pour "pourrir" serait un échec, mais si l'un des éléments de la liste ont été "pourrir en enfer", qui serait défaillant.

    Le résultat étant, faites attention à vos critères de recherche si l'utilisation de cette méthode et de savoir qu'elle ne cette limitation.

    InformationsquelleAutor Rolf of Saxony
  11. 22
    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
  12. 22

    Ce code peut être utile

    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
  13. 7

    Une solution en ligne:

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

    Ou:

    mylist = ['cdef'[i] for i in range(4) if i in (x, y, z)]
    InformationsquelleAutor Vinayak Kaniyarakkal
  14. 6

    Vous pouvez essayer la méthode indiquée ci-dessous. Dans cette méthode, vous aurez la liberté de préciser d'entrée/le nombre de variables que vous souhaitez entrer.

    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
  15. 5

    Peut-être vous avez besoin de formule directe pour la sortie bits.

    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

    Nous allons carte de bits: 'c':1 'd':0xb10 'e':0xb100 'f':0xb1000

    Rapport de l'isc (est 'c'):

    if xyz=0 then isc=1 else isc=0

    Utiliser les maths si la formule 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))

    ...

    La connexion de ces formules en logique suivante:

    • logique and est la somme des carrés des équations
    • logique or est le produit des équations

    et vous aurez un total équation
    express somme et vous avez la formule de la somme

    puis sum&1 est c, sum&2 d, sum&4 est e, sum&5 est f

    Après cela, vous pouvez formulaire prédéfini tableau où l'indice de la chaîne éléments correspondent à des prêts de la chaîne.

    array[sum] vous donne la chaîne.

    InformationsquelleAutor Sergei
  16. 4

    Il peut être fait facilement que 

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

    Les plus mnémonique façon de représenter votre pseudo-code en Python serait:

    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")
    • Cette approche est plus universel que " si 2 en (x, y, z): maliste.append('e')` car permet arbitraire des comparaisons (par exemple if any(v >= 42 for v in (x, y, z)): ). Et la performance de tous les 3 méthodes (2 in {x,y,z}, 2 in (x,y,z), any(_v == 2 for _v in (x,y,z))) semble être presque la même dans CPython3.6 (voir Résumé)
    InformationsquelleAutor rsalmei
  18. 3

    Dirait que vous êtes en train de construire une sorte de César de chiffrement.

    Beaucoup plus généralisée de l'approche est ceci:

    input_values = (0, 1, 3)
origo = ord('c')
[chr(val + origo) for val in inputs]

    sorties

    ['c', 'd', 'f']

    Ne sais pas si c'est un côté souhaité effet de votre code, mais l'ordre de votre sortie sera toujours triés.

    Si c'est ce que vous voulez, la dernière ligne peut être changé:

    sorted([chr(val + origo) for val in inputs])
    InformationsquelleAutor firelynx
  19. 3

    De tester plusieurs variables avec une valeur unique: if 1 in {a,b,c}:

    De tester plusieurs valeurs à une variable: if a in {1, 2, 3}:

    InformationsquelleAutor alamin
  20. 1

    Vous pouvez utiliser le dictionnaire :

    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
    • Cela peut même ajouter plus d'une fois cette. Set?
    InformationsquelleAutor Rohit Gawas
  21. 0

    Cela va vous aider.

    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