Ho uno script Python che può ricevere zero o tre argomenti della riga di comando. (Funziona in base al comportamento predefinito o richiede tutti e tre i valori specificati.)

Qual è la sintassi ideale per qualcosa del genere:

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 intendi una forma minima, vai con questo:

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

Il che traduce il titolo della tua domanda.

AGGIORNAMENTO: come correttamente affermato da Volatility e Supr, è possibile applicare la legge di De Morgan e ottenere l'equivalente:

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

Il mio consiglio è di usare qualunque modulo sia più significativo per te e per gli altri programmatori. Il primo significa "c'è qualcosa di falso, ma anche qualcosa di vero" , il secondo "C'è qualcosa di vero, ma non tutto" . Se dovessi ottimizzare o fare questo in hardware, sceglierei il secondo, qui scelgo solo il più leggibile (tenendo anche conto delle condizioni che testerai e dei loro nomi). Ho scelto il primo.

Che ne dite di:

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

Altra variante:

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

Questa domanda aveva già molte risposte molto apprezzate e una risposta accettata, ma finora tutte sono state distratte da vari modi di esprimere il problema booleano e hanno perso un punto cruciale:

Ho uno script Python che può ricevere zero o tre argomenti della riga di comando. (Funziona in base al comportamento predefinito o richiede tutti e tre i valori specificati)

Questa logica non dovrebbe essere la responsabilità del tuo codice in primo luogo , piuttosto dovrebbe essere gestito dalargparsemodulo. Non preoccuparti di scrivere un'istruzione if complessa, preferisci invece impostare il tuo parser di argomenti in questo modo:

#!/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 sì, dovrebbe essere un'opzione non un argomento posizionale, perché dopo tutto è facoltativo .

modificato: per rispondere alle preoccupazioni di LarsH nei commenti, di seguito è riportato un esempio di come potresti scriverlo se fossi certo di volere l'interfaccia con 3 o 0argomenti posizionali . Sono dell'opinione che l'interfaccia precedente abbia uno stile migliore, perché gliargomenti opzionali dovrebbero essere opzioni , ma ecco un approccio alternativo per completezza. Nota la sostituzione di kwargusagedurante la creazione del tuo parser, perchéargparsealtrimenti genererà automaticamente un messaggio di utilizzo fuorviante!

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

Ecco alcuni esempi di utilizzo:

# 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

Vorrei:

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

Penso che questo dovrebbe cortocircuitare in modo abbastanza efficiente

Spiegazione

Creando condsun iteratore, il primo utilizzo di anycortocircuita e lascia l'iteratore che punta all'elemento successivo se un oggetto è vero; in caso contrario, consumerà l'intero elenco e sarà False. Il prossimo anyprende gli elementi rimanenti nell'iterabile e si assicura che non ci siano altri valori veri ... Se ci sono, l'intera istruzione non può essere vera, quindi non c'è un elemento unico (quindi i cortocircuiti ancora). L'ultimo anytornerà Falseo esaurirà l'iterabile e sarà True.

nota: quanto sopra controlla se è impostata una sola condizione

Se vuoi verificare se uno o più articoli, ma non tutti gli articoli sono impostati, puoi usare:

not all(conds) and any(conds)

La frase inglese:

"Se a o b o c ma non tutti"

Si traduce in questa logica:

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

La parola "ma" di solito implica una congiunzione, in altre parole "e". Inoltre, "tutti loro" si traduce in una congiunzione di condizioni: questa condizione, e quella condizione, e altre condizioni. Il "non" inverte l'intera congiunzione.

Non sono d'accordo che la risposta accettata. L'autore ha trascurato di applicare l'interpretazione più semplice alla specifica e ha trascurato di applicare la legge di De Morgan per semplificare l'espressione a un minor numero di operatori:

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

sostenendo che la risposta è una "forma minima".

Questo ritorna Truese una e solo una delle tre condizioni è True. Probabilmente quello che volevi nel tuo codice di esempio.

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

Che dire: (condizione unica)

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

Nota, se consenti anche due condizioni, potresti farlo

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

Per essere chiari, vuoi prendere la tua decisione in base a quanti parametri sono VERO logici (in caso di argomenti stringa - non vuoti)?

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

Quindi hai preso una decisione:

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

Ora la logica è più chiara.

E perché non contarli?

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 non ti dispiace essere un po 'enigmatico puoi semplicemente rotolare con il 0 < (a + b + c) < 3quale tornerà truese hai tra una e due affermazioni vere e false se tutte sono false o nessuna è falsa.

Ciò semplifica anche se si utilizzano le funzioni per valutare i bool mentre si valutano le variabili una sola volta e ciò significa che è possibile scrivere le funzioni in linea e non è necessario archiviare temporaneamente le variabili. (Esempio:. 0 < ( a(x) + b(x) + c(x) ) < 3)

La domanda afferma che sono necessari tutti e tre gli argomenti (a e b e c) o nessuno di essi (non (a o b o c))

Questo da:

(a e b e c) o no (a o b o c)

A quanto ho capito, hai una funzione che riceve 3 argomenti, ma in caso contrario verrà eseguito sul comportamento predefinito. Dal momento che non hai spiegato cosa dovrebbe accadere quando vengono forniti 1 o 2 argomenti, suppongo che dovrebbe semplicemente fare il comportamento predefinito. In tal caso, penso che troverai la seguente risposta molto vantaggiosa:

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

Tuttavia, se si desidera che 1 o 2 argomenti vengano gestiti in modo diverso:

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: questo presuppone che i Falsevalori " " non verranno passati in questo metodo.

Se lavori con un iteratore di condizioni, potrebbe essere lento accedervi. Ma non è necessario accedere a ciascun elemento più di una volta e non è sempre necessario leggerlo tutto. Ecco una soluzione che funzionerà con infiniti generatori:

#!/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 ogni dato boolè True, o quando ogni dato boolè False...
sono tutti uguali tra loro!

Quindi, dobbiamo solo trovare due elementi che valutino le diverse bools
per sapere che ce n'è almeno uno Truee almeno uno False.

La mia breve soluzione:

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

Lo credo cortocircuiti, perché AFAIK è a==b==cugualea==b and b==c .

La mia soluzione generalizzata:

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)

Ho anche scritto del codice relativo a più iterabili, ma l'ho eliminato da qui perché penso sia inutile. È comunque ancora disponibile qui .

Questa è sostanzialmente una funzionalità "alcune (ma non tutte)" (se confrontata con any()eall() funzioni incorporate ).

Ciò implica che non ci dovrebbe essere Falses e True s tra i risultati. Pertanto, è possibile effettuare le seguenti operazioni:

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 vantaggio di questo codice è che devi iterare una sola volta attraverso gli elementi (booleani) risultanti.

Uno svantaggio è che tutte queste espressioni di verità vengono sempre valutate e non fanno cortocircuiti come gli operatori or/ and.