Tengo un script de Python que puede recibir cero o tres argumentos de línea de comando. (Se ejecuta con el comportamiento predeterminado o necesita los tres valores especificados).

¿Cuál es la sintaxis ideal para algo como:

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 te refieres a una forma mínima, ve con esto:

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

Lo que traduce el título de su pregunta.

ACTUALIZACIÓN: como dicen correctamente Volatility y Supr, puede aplicar la ley de De Morgan y obtener un equivalente:

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

Mi consejo es usar el formulario que sea más significativo para usted y para otros programadores. El primero significa "hay algo falso, pero también algo verdadero" , el segundo "hay algo verdadero, pero no todo" . Si tuviera que optimizar o hacer esto en hardware, elegiría el segundo, aquí solo elegir el más legible (también teniendo en cuenta las condiciones que probará y sus nombres). Elegí el primero.

Qué tal si:

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

Otra variante:

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

Esta pregunta ya tenía muchas respuestas altamente votadas y una respuesta aceptada, pero todas hasta ahora estaban distraídas por varias formas de expresar el problema booleano y perdieron un punto crucial:

Tengo un script de Python que puede recibir cero o tres argumentos de línea de comando. (Se ejecuta con el comportamiento predeterminado o necesita los tres valores especificados)

Esta lógica no debe ser responsabilidad de su código en primer lugar , sino que debe ser manejada por elargparsemódulo. No se moleste en escribir una declaración if compleja, en su lugar, prefiera configurar su analizador de argumentos de la siguiente manera:

#!/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)

Y sí, debería ser una opción, no un argumento posicional, porque después de todo es opcional .

editado: para abordar la preocupación de LarsH en los comentarios, a continuación se muestra un ejemplo de cómo podría escribirlo si estaba seguro de que deseaba la interfaz con 3 o 0argumentos posicionales . Soy de la opinión de que la interfaz anterior es mejor estilo, porque losargumentos opcionales deberían ser opciones , pero aquí hay un enfoque alternativo en aras de la integridad. Tenga en cuenta la omisión de kwargusageal crear su analizador, porque deargparselo contrario generará automáticamente un mensaje de uso engañoso.

#!/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)

Aquí hay algunos ejemplos de uso:

# 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

Yo iría por:

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

Creo que esto debería cortocircuitar de manera bastante eficiente

Explicación

Al hacer condsun iterador, el primer uso de anyhará un cortocircuito y dejará el iterador apuntando al siguiente elemento si algún elemento es verdadero; de lo contrario, consumirá toda la lista y será False. El siguiente anytoma los elementos restantes en el iterable, y se asegura de que no haya otros valores verdaderos ... Si los hay, toda la declaración no puede ser verdadera, por lo tanto no hay un elemento único (por lo tanto, cortocircuitos de nuevo). El último anyregresará Falseo agotará el iterable y será True.

nota: lo anterior verifica si solo se establece una condición

Si desea verificar si uno o más elementos, pero no todos los elementos están configurados, puede usar:

not all(conds) and any(conds)

La oración en inglés:

"Si a o b o c pero no todos"

Se traduce a esta lógica:

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

La palabra "pero" generalmente implica una conjunción, en otras palabras, "y". Además, "todos ellos" se traduce en una conjunción de condiciones: esta condición, y esa condición, y otra condición. El "no" invierte toda esa conjunción.

No estoy de acuerdo con la respuesta aceptada. El autor descuidó aplicar la interpretación más directa a la especificación y descuidó aplicar la Ley de De Morgan para simplificar la expresión a menos operadores:

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

mientras afirma que la respuesta es una "forma mínima".

Esto regresa Truesi una y solo una de las tres condiciones es True. Probablemente lo que quería en su código de ejemplo.

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

¿Qué pasa con: (condición única)

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

Tenga en cuenta que si permite dos condiciones también podría hacerlo

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

Para ser claros, ¿desea tomar su decisión en función de la cantidad de parámetros que son VERDADEROS lógicos (en caso de argumentos de cadena, no vacíos)?

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

Entonces tomaste una decisión:

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

Ahora la lógica es más clara.

¿Y por qué no solo contarlos?

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 no le importa ser un poco críptico, puede rodar de manera simple con 0 < (a + b + c) < 3lo que regresará truesi tiene entre una y dos declaraciones verdaderas y falso si todas son falsas o ninguna es falsa.

Esto también se simplifica si usa funciones para evaluar los bools, ya que solo evalúa las variables una vez y eso significa que puede escribir las funciones en línea y no necesita almacenar temporalmente las variables. (Ejemplo:. 0 < ( a(x) + b(x) + c(x) ) < 3)

La pregunta indica que necesita los tres argumentos (a y byc) o ninguno de ellos (no (a o b o c))

Esto da:

(a y byc) o no (a o b o c)

Según tengo entendido, tiene una función que recibe 3 argumentos, pero si no lo hace, se ejecutará con el comportamiento predeterminado. Como no ha explicado lo que debería suceder cuando se proporcionan 1 o 2 argumentos, asumiré que simplemente debería hacer el comportamiento predeterminado. En cuyo caso, creo que encontrará la siguiente respuesta muy ventajosa:

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

Sin embargo, si desea que 1 o 2 argumentos se manejen de manera diferente:

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

nota: Esto supone que " False" los valores no se pasarán a este método.

Si trabaja con un iterador de condiciones, el acceso puede ser lento. Pero no necesita acceder a cada elemento más de una vez, y no siempre necesita leerlo todo. Aquí hay una solución que funcionará con generadores infinitos:

#!/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])

Cuando cada dado booles True, o cuando cada dado booles False... ¡
todos son iguales entre sí!

Por lo tanto, solo necesitamos encontrar dos elementos que evalúen diferentes bools
para saber que hay al menos uno Truey al menos uno False.

Mi solución corta:

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

Creo que es un cortocircuito, porque AFAIK a==b==ces igual a==b and b==c.

Mi solución generalizada:

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)

También escribí un código que trata con múltiples iterables, pero lo eliminé de aquí porque creo que no tiene sentido. Sin embargo, todavía está disponible aquí .

Esto es básicamente una funcionalidad de "algunos (pero no todos)" (en contraste con las funciones incorporadas any()y all()).

Esto implica que debe haber Falses y True s entre los resultados. Por lo tanto, puede hacer lo siguiente:

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)

Una ventaja de este código es que solo necesita iterar una vez a través de los elementos resultantes (booleanos).

Una desventaja es que todas estas expresiones de verdad siempre se evalúan y no hacen cortocircuitos como los operadores or/ and.