Verificare se è impostata una sola variabile in un elenco di variabili

Question

Sto cercando un metodo semplice per verificare se solo una variabile in un elenco di variabili ha un valore True. Ho visto questo logical xor post e sto cercando di trovare un modo per adattarsi a più variabili e solo una vera.

Esempio

>>>TrueXor(1,0,0) 
True 

>>>TrueXor(0,0,1) 
True 

>>>TrueXor(1,1,0) 
False 

>>>TrueXor(0,0,0,0,0) 
False 

Answer 1

non ce n'è uno costruito in ma non è a duro a rotolare si possiede:

def TrueXor(*args): 
    return sum(args) == 1 

Dal momento che "[b] ooleans sono un sottotipo di pianura interi "(source) è possibile sommare abbastanza facilmente l'elenco degli interi e passare anche i veri booleani in questa funzione.

Quindi queste due chiamate sono omogenei:

TrueXor(1, 0, 0) 
TrueXor(True, False, False) 

Se si desidera esplicita di conversione booleano: sum(bool(x) for x in args) == 1.

Answer 2

>>> def f(*n): 
...  n = [bool(i) for i in n] 
...  return n.count(True) == 1 
... 
>>> f(0, 0, 0) 
False 
>>> f(1, 0, 0) 
True 
>>> f(1, 0, 1) 
False 
>>> f(1, 1, 1) 
False 
>>> f(0, 1, 0) 
True 
>>> 

Answer 3

La domanda a cui è collegato fornisce già la soluzione per due variabili. Tutto ciò che devi fare è estenderlo per lavorare su n variabili:

import operator 

def only_one_set(*vars): 
    bools = [bool(v) for v in vars] 
    return reduce(operator.xor, bools, False) 

>>> a, b, c, d, e = False, '', [], 10, -99 
>>> only_one_set(a, b, c, d) 
True 
>>> only_one_set(a, b, c, d, e) 
False 

Answer 4

Ecco il mio approccio diretto. L'ho rinominato solo_solo poiché xor con più di un input è solitamente un correttore di parità, non un controllore "solo uno".

def only_one(*args): 
    result = False 
    for a in args: 
     if a: 
      if result: 
       return False 
      else: 
       result = True 
    return result 

Testing:

>>> only_one(1,0,0) 
True 
>>> only_one(0,0,1) 
True 
>>> only_one(1,1,0) 
False 
>>> only_one(0,0,0,0,0) 
False 
>>> only_one(1,1,0,1) 
False 

Answer 5

Penso che la soluzione sum-based è bene per l'esempio dato, ma di tenere presente che booleano predicati in python sempre corto circuito la loro valutazione. Quindi potresti voler considerare qualcosa di più coerente con all and any.

def any_one(iterable): 
    it = iter(iterable) 
    return any(it) and not any(it)