J'ai un script python qui peut recevoir zéro ou trois arguments de ligne de commande. (Soit il s'exécute sur le comportement par défaut, soit il a besoin des trois valeurs spécifiées.)

Quelle est la syntaxe idéale pour quelque chose comme:

if a and (not b or not c) or b and (not a or not c) or c and (not b or not a):

?

Si vous voulez dire une forme minimale, allez-y:

if (not a or not b or not c) and (a or b or c):

Ce qui traduit le titre de votre question.

MISE À JOUR: comme correctement dit par Volatility et Supr, vous pouvez appliquer la loi de De Morgan et obtenir l'équivalent:

if (a or b or c) and not (a and b and c):

Mon conseil est d'utiliser la forme la plus importante pour vous et pour les autres programmeurs. Le premier signifie "il y a quelque chose de faux, mais aussi quelque chose de vrai" , le second "il y a quelque chose de vrai, mais pas tout" . Si je devais optimiser ou faire cela dans le matériel, je choisirais le second, ici il suffit de choisir le plus lisible (en tenant également compte des conditions que vous allez tester et de leurs noms). J'ai choisi le premier.

Que diriez-vous:

conditions = [a, b, c]
if any(conditions) and not all(conditions):
   ...

Autre variante:

if 1 <= sum(map(bool, conditions)) <= 2:
   ...

Cette question avait déjà de nombreuses réponses très positives et une réponse acceptée, mais jusqu'à présent, toutes étaient distraites par diverses façons d'exprimer le problème booléen et ont manqué un point crucial:

J'ai un script python qui peut recevoir zéro ou trois arguments de ligne de commande. (Soit il fonctionne avec le comportement par défaut, soit il a besoin des trois valeurs spécifiées)

Cette logique ne doit pas être la responsabilité de votre code en premier lieu , elle doit plutôt être gérée parargparsemodule. Ne vous embêtez pas à écrire une instruction if complexe, préférez plutôt configurer votre analyseur d'arguments comme ceci:

#!/usr/bin/env python
import argparse as ap
parser = ap.ArgumentParser()
parser.add_argument('--foo', nargs=3, default=['x', 'y', 'z'])
args = parser.parse_args()
print(args.foo)

Et oui, cela devrait être une option et non un argument positionnel, car après tout, il est facultatif .

édité: Pour répondre à la préoccupation de LarsH dans les commentaires, voici un exemple de la façon dont vous pourriez l'écrire si vous étiez certain de vouloir l'interface avec 3 ou 0arguments positionnels . Je suis d'avis que l'interface précédente est un meilleur style, car les arguments optionnels devraient être des options , mais voici une approche alternative par souci d'exhaustivité. Notez le kwarg de remplacementusagelors de la création de votre analyseur, carargparsesinon, cela générera automatiquement un message d'utilisation trompeur!

#!/usr/bin/env python
import argparse as ap
parser = ap.ArgumentParser(usage='%(prog)s [-h] [a b c]\n')
parser.add_argument('abc', nargs='*', help='specify 3 or 0 items', default=['x', 'y', 'z'])
args = parser.parse_args()
if len(args.abc) != 3:
  parser.error('expected 3 arguments')
print(args.abc)

Voici quelques exemples d'utilisation:

# default case
wim@wim-zenbook:/tmp$ ./three_or_none.py 
['x', 'y', 'z']

# explicit case
wim@wim-zenbook:/tmp$ ./three_or_none.py 1 2 3
['1', '2', '3']

# example failure mode
wim@wim-zenbook:/tmp$ ./three_or_none.py 1 2 
usage: three_or_none.py [-h] [a b c]
three_or_none.py: error: expected 3 arguments

J'irais pour:

conds = iter([a, b, c])
if any(conds) and not any(conds):
    # okay...

Je pense que cela devrait court-circuiter assez efficacement

Explication

En créant condsun itérateur, la première utilisation de anycourt-circuitera et laissera l'itérateur pointant vers l'élément suivant si un élément est vrai; sinon, il consommera la liste entière et sera False. Le suivant anyprend les éléments restants dans l'itérable, et s'assure qu'il n'y a pas d'autres valeurs vraies ... S'il y en a, la déclaration entière ne peut pas être vraie, donc il n'y a pas un élément unique (donc des courts-circuits encore). Le dernier anyretournera Falseou épuisera l'itérable et sera True.

Remarque: les contrôles ci-dessus vérifient si une seule condition est définie

Si vous souhaitez vérifier si un ou plusieurs éléments, mais pas tous, sont définis, vous pouvez utiliser:

not all(conds) and any(conds)

La phrase anglaise:

"Si a ou b ou c mais pas tous"

Se traduit par cette logique:

(a or b or c) and not (a and b and c)

Le mot "mais" implique généralement une conjonction, en d'autres termes "et". De plus, «tous» se traduit par une conjonction de conditions: cette condition, et cette condition, et une autre condition. Le «non» inverse toute cette conjonction.

Je ne suis pas d'accord que la réponse acceptée. L'auteur a négligé d'appliquer l'interprétation la plus directe à la spécification et a négligé d'appliquer la loi de De Morgan pour simplifier l'expression à moins d'opérateurs:

 not a or not b or not c  ->  not (a and b and c)

tout en affirmant que la réponse est une "forme minimale".

Cela revient Truesi une et une seule des trois conditions est True. Probablement ce que vous vouliez dans votre exemple de code.

if sum(1 for x in (a,b,c) if x) == 1:

Qu'en est-il: (condition unique)

if (bool(a) + bool(b) + bool(c) == 1):

Remarquez, si vous autorisez également deux conditions, vous pouvez le faire

if (bool(a) + bool(b) + bool(c) in [1,2]):

Pour être clair, vous voulez prendre votre décision en fonction de la quantité de paramètres logiques TRUE (en cas d'arguments de chaîne - non vides)?

argsne = (1 if a else 0) + (1 if b else 0) + (1 if c else 0)

Ensuite, vous avez pris une décision:

if ( 0 < argsne < 3 ):
 doSth() 

Maintenant, la logique est plus claire.

Et pourquoi ne pas simplement les compter?

import sys
a = sys.argv
if len(a) = 1 :  
    # No arguments were given, the program name count as one
elif len(a) = 4 :
    # Three arguments were given
else :
    # another amount of arguments was given

Si cela ne vous dérange pas d'être un peu énigmatique, vous pouvez simplement lancer 0 < (a + b + c) < 3ce qui reviendra truesi vous avez entre une et deux déclarations vraies et false si toutes sont fausses ou aucune n'est fausse.

Cela simplifie également si vous utilisez des fonctions pour évaluer les booléens car vous n'évaluez les variables qu'une seule fois et ce qui signifie que vous pouvez écrire les fonctions en ligne et que vous n'avez pas besoin de stocker temporairement les variables. (Exemple:. 0 < ( a(x) + b(x) + c(x) ) < 3)

La question indique que vous avez besoin des trois arguments (a et b et c) ou aucun d'entre eux (pas (a ou b ou c))

Cela donne:

(a et b et c) ou non (a ou b ou c)

Si je comprends bien, vous avez une fonction qui reçoit 3 arguments, mais si ce n'est pas le cas, elle fonctionnera avec le comportement par défaut. Puisque vous n'avez pas expliqué ce qui devrait se passer lorsque 1 ou 2 arguments sont fournis, je suppose qu'il devrait simplement faire le comportement par défaut. Dans ce cas, je pense que vous trouverez la réponse suivante très avantageuse:

def method(a=None, b=None, c=None):
    if all([a, b, c]):
        # received 3 arguments
    else:
        # default behavior

Cependant, si vous souhaitez que 1 ou 2 arguments soient traités différemment:

def method(a=None, b=None, c=None):
    args = [a, b, c]
    if all(args):
        # received 3 arguments
    elif not any(args):
        # default behavior
    else:
        # some args (raise exception?)

Remarque: cela suppose que les Falsevaleurs " " ne seront pas transmises à cette méthode.

Si vous travaillez avec un itérateur de conditions, l'accès peut être lent. Mais vous n'avez pas besoin d'accéder à chaque élément plus d'une fois, et vous n'avez pas toujours besoin de tout lire. Voici une solution qui fonctionnera avec des générateurs infinis:

#!/usr/bin/env python3
from random import randint
from itertools import tee

def generate_random():
    while True:
        yield bool(randint(0,1))

def any_but_not_all2(s): # elegant
    t1, t2 = tee(s)
    return False in t1 and True in t2 # could also use "not all(...) and any(...)"

def any_but_not_all(s): # simple
    hadFalse = False
    hadTrue = False
    for i in s:
        if i:
            hadTrue = True
        else:
            hadFalse = True
        if hadTrue and hadFalse:
            return True
    return False


r1, r2 = tee(generate_random())
assert any_but_not_all(r1)
assert any_but_not_all2(r2)

assert not any_but_not_all([True, True])
assert not any_but_not_all2([True, True])

assert not any_but_not_all([])
assert not any_but_not_all2([])

assert any_but_not_all([True, False])
assert any_but_not_all2([True, False])

Quand chaque donné boolest True, ou quand chaque donné boolest False...
ils sont tous égaux l'un à l'autre!

Il suffit donc de trouver deux éléments qui s'évaluent à des bools différents
pour savoir qu'il y en a au moins un Trueet au moins un False.

Ma solution courte:

not bool(a)==bool(b)==bool(c)

Je crois qu'il court-circuits, car AFAIK a==b==cest égal a==b and b==c.

Ma solution généralisée:

def _any_but_not_all(first, iterable): #doing dirty work
    bool_first=bool(first)
    for x in iterable:
        if bool(x) is not bool_first:
            return True
    return False

def any_but_not_all(arg, *args): #takes any amount of args convertable to bool
    return _any_but_not_all(arg, args)

def v_any_but_not_all(iterable): #takes iterable or iterator
    iterator=iter(iterable)
    return _any_but_not_all(next(iterator), iterator)

J'ai également écrit du code traitant de plusieurs itérables, mais je l'ai supprimé d'ici car je pense que c'est inutile. Il est cependant toujours disponible ici .

Ceci est essentiellement un « certains (mais pas tous) » fonctionnalité (en contraste avec le any()etall() fonctions intégrées ).

Cela implique qu'il devrait y avoir des Falses et des True s parmi les résultats. Par conséquent, vous pouvez effectuer les opérations suivantes:

some = lambda ii: frozenset(bool(i) for i in ii).issuperset((True, False))

# one way to test this is...
test = lambda iterable: (any(iterable) and (not all(iterable))) # see also http://stackoverflow.com/a/16522290/541412

# Some test cases...
assert(some(()) == False)       # all() is true, and any() is false
assert(some((False,)) == False) # any() is false
assert(some((True,)) == False)  # any() and all() are true

assert(some((False,False)) == False)
assert(some((True,True)) == False)
assert(some((True,False)) == True)
assert(some((False,True)) == True)

Un avantage de ce code est que vous n'avez besoin de parcourir qu'une seule fois les éléments (booléens) résultants.

Un inconvénient est que toutes ces expressions de vérité sont toujours évaluées et ne font pas de court-circuit comme les opérateurs or/ and.