Eu tenho um script python que pode receber zero ou três argumentos de linha de comando. (Ele é executado no comportamento padrão ou precisa dos três valores especificados.)

Qual é a sintaxe 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):

?

Se você quer dizer um formulário mínimo, vá com isso:

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

O que traduz o título da sua pergunta.

UPDATE: como corretamente dito pela Volatility e Supr, você pode aplicar a lei de De Morgan e obter o equivalente:

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

Meu conselho é usar o formulário que for mais significativo para você e para outros programadores. O primeiro significa "há algo falso, mas também algo verdadeiro" , o segundo "há algo verdadeiro, mas não tudo" . Se eu otimizasse ou fizesse isso no hardware, escolheria o segundo, aqui, apenas o mais legível (também levando em consideração as condições que você testará e seus nomes). Eu escolhi o primeiro.

E se:

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

Outra variante:

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

Essa pergunta já tinha muitas respostas altamente votadas e uma resposta aceita, mas todas elas até agora foram distraídas por várias maneiras de expressar o problema booleano e perderam um ponto crucial:

Eu tenho um script python que pode receber zero ou três argumentos de linha de comando. (Ele é executado no comportamento padrão ou precisa dos três valores especificados)

Essa lógica não deve ser de responsabilidade do seu código em primeiro lugar , mas deve ser manipulada porargparsemódulo. Não se preocupe em escrever uma declaração if complexa, em vez disso, prefira configurar seu analisador de argumentos da seguinte forma:

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

E sim, deve ser uma opção, não um argumento posicional, porque afinal é opcional .

editado: Para abordar a preocupação de LarsH nos comentários, abaixo está um exemplo de como você pode escrevê-lo se tiver certeza de que deseja a interface com 3 ou 0argumentos posicionais . Sou da opinião de que a interface anterior tem um estilo melhor, porqueargumentos opcionais devem ser opções , mas aqui está uma abordagem alternativa por uma questão de integridade. Observe o kwarg sobrescritousageao criar seu analisador, pois,argparsecaso contrário,será gerada automaticamente uma mensagem de uso enganosa!

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

Aqui estão alguns exemplos 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

Eu iria para:

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

Eu acho que isso deve causar um curto-circuito com bastante eficiência

Explicação

Ao criar condsum iterador, o primeiro uso de anyentrará em curto-circuito e deixará o iterador apontando para o próximo elemento, se algum item for verdadeiro; caso contrário, consumirá toda a lista e será False. O próximo anypega os itens restantes no iterável e garante que não existem outros valores verdadeiros ... Se houver, toda a declaração não pode ser verdadeira, portanto, não há um elemento único (portanto, curto-circuitos novamente). O último anyretornará Falseou esgotará o iterável e o será True.

nota: o acima verifica se apenas uma condição está definida

Se você deseja verificar se um ou mais itens, mas nem todos os itens estão definidos, pode usar:

not all(conds) and any(conds)

A sentença em inglês:

"Se a ou b ou c, mas não todos"

Traduz para esta lógica:

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

A palavra "mas" geralmente implica uma conjunção, em outras palavras "e". Além disso, "todos eles" se traduz em uma conjunção de condições: essa condição e essa condição e outra condição. O "não" inverte toda a conjunção.

Eu não concordo que a resposta aceita. O autor deixou de aplicar a interpretação mais direta à especificação e deixou de aplicar a Lei de De Morgan para simplificar a expressão a menos operadores:

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

enquanto afirma que a resposta é uma "forma mínima".

Isso retorna Truese uma e apenas uma das três condições for True. Provavelmente o que você queria no seu código de exemplo.

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

Que tal: (condição única)

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

Observe, se você permitir duas condições também, poderá fazer isso

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

Para ser claro, você deseja tomar sua decisão com base em quanto dos parâmetros é TRUE lógico (no caso de argumentos de string - não está vazio)?

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

Então você tomou uma decisão:

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

Agora a lógica está mais clara.

E por que não apenas contá-los?

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

Se você não se importa em ser um pouco enigmático, pode simular o 0 < (a + b + c) < 3que retornará truese você tiver entre uma e duas declarações verdadeiras e false se todas forem falsas ou nenhuma for falsa.

Isso também simplifica se você usar funções para avaliar os bools, pois apenas avalia as variáveis ​​uma vez, o que significa que você pode escrever as funções em linha e não precisa armazenar temporariamente as variáveis. (Exemplo:. 0 < ( a(x) + b(x) + c(x) ) < 3)

A pergunta afirma que você precisa dos três argumentos (a e bec) ou nenhum deles (não (a ou b ou c))

Isto dá:

(a e bec) ou não (a ou b ou c)

Pelo que entendi, você tem uma função que recebe 3 argumentos, mas se não o fizer, será executada no comportamento padrão. Como você não explicou o que deve acontecer quando 1 ou 2 argumentos são fornecidos, assumirei que ele deve simplesmente executar o comportamento padrão. Nesse caso, acho que você encontrará a seguinte resposta muito vantajosa:

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

No entanto, se você deseja que 1 ou 2 argumentos sejam tratados de maneira 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: Isso pressupõe que os Falsevalores " " não serão passados ​​para este método.

Se você trabalha com um iterador de condições, pode ser lento o acesso. Mas você não precisa acessar cada elemento mais de uma vez e nem sempre precisa ler tudo. Aqui está uma solução que funcionará com geradores 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])

Quando todo dado boolé True, ou quando todo dado boolé False...
todos são iguais um ao outro!

Portanto, basta encontrar dois elementos que sejam avaliados para bools diferentes
para saber que há pelo menos um Truee pelo menos um False.

Minha curta solução:

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

Eu acredito que curto-circuito, porque AFAIK a==b==cé igual a==b and b==c.

Minha solução 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)

Também escrevi um código que lida com várias iteráveis, mas a excluí daqui porque acho inútil. No entanto, ainda está disponível aqui .

Isso é basicamente uma funcionalidade "alguns (mas não todos)" (quando contrastada com as funções any()e all()internas).

Isso implica que deve haver Falses e True s entre os resultados. Portanto, você pode fazer o seguinte:

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)

Uma vantagem desse código é que você só precisa iterar uma vez pelos itens resultantes (booleanos).

Uma desvantagem é que todas essas expressões de verdade são sempre avaliadas e não causam curto-circuito como os operadores or/ and.