У меня есть сценарий python, который может получать ноль или три аргумента командной строки. (Либо он работает по умолчанию, либо требует указания всех трех значений.)

Какой идеальный синтаксис для чего-то вроде:

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

?

Если вы имеете в виду минимальную форму, сделайте следующее:

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

Что переводит название вашего вопроса.

ОБНОВЛЕНИЕ: как правильно сказали Volatility и Supr, вы можете применить закон Де Моргана и получить эквивалент:

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

Я советую использовать ту форму, которая важнее для вас и других программистов. Первое означает «есть что-то ложное, но также и что-то истинное» , второе «Есть что-то истинное, но не все» . Если бы мне пришлось оптимизировать или сделать это аппаратно, я бы выбрал второй, здесь просто выберите наиболее читаемый (также принимая во внимание условия, которые вы будете тестировать, и их имена). Я выбрал первое.

Как насчет:

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

Другой вариант:

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

На этот вопрос уже было много высоко оцененных ответов и принятый ответ, но все они до сих пор были отвлечены различными способами выражения логической проблемы и упустили важный момент:

У меня есть сценарий python, который может получать ноль или три аргумента командной строки. (Либо он работает по умолчанию, либо требует указания всех трех значений)

Эта логика не должна лежать в основе вашего кода , скорее, она должна обрабатыватьсяargparseмодулем. Не утруждайтесь написанием сложного оператора if, вместо этого лучше настроить парсер аргументов примерно так:

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

И да, это должна быть опция, а не позиционный аргумент, потому что это, в конце концов, необязательно .

отредактировано: Чтобы решить проблему LarsH в комментариях, ниже приведен пример того, как вы могли бы написать это, если бы были уверены, что вам нужен интерфейс с 3 или 0 позиционными аргументами. Я считаю, что предыдущий интерфейс лучше по стилю, потому что необязательные аргументы должны быть параметрами , но вот альтернативный подход для полноты картины. Обратите внимание на переопределение kwargusageпри создании вашего парсера, потому что вargparseпротивном случае автоматически сгенерирует вводящее в заблуждение сообщение об использовании!

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

Вот несколько примеров использования:

# 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

Я бы пошел на:

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

Я думаю, это должно достаточно эффективно закоротить

объяснение

При создании condsитератора первое использование anyзакоротит и оставит итератор, указывающий на следующий элемент, если какой-либо элемент истинен; в противном случае он поглотит весь список и будет False. Следующий anyберет оставшиеся элементы в итерируемом объекте и проверяет, нет ли других истинных значений ... Если есть, то все утверждение не может быть истинным, поэтому нет ни одного уникального элемента (поэтому короткие замыкания очередной раз). Последний anyлибо вернет, Falseлибо исчерпает итерацию и будет True.

примечание: вышеупомянутое проверяет, установлено ли только одно условие

Если вы хотите проверить, установлен ли один или несколько элементов, но не все элементы, вы можете использовать:

not all(conds) and any(conds)

Английское предложение:

"Если a, b или c, но не все из них"

Переводится в эту логику:

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

Слово «но» обычно подразумевает союз, другими словами «и». Кроме того, «все они» переводит в сочетание условий: это условие, и это условие, и другое состояние. «Не» полностью инвертирует это соединение.

Я не согласен с принятым ответом. Автор не позаботился о применении наиболее простой интерпретации к спецификации и не применил закон Де Моргана, чтобы упростить выражение до меньшего числа операторов:

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

утверждая, что ответ - это «минимальная форма».

Это возвращается, Trueесли выполнено одно и только одно из трех условий True. Вероятно, то, что вы хотели в своем примере кода.

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

Что насчет: (уникальное состояние)

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

Обратите внимание: если вы разрешите два условия, вы можете это сделать

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

Чтобы было ясно, вы хотите принять свое решение на основе того, какая часть параметров имеет логическое значение ИСТИНА (в случае строковых аргументов - не пустые)?

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

Тогда вы приняли решение:

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

Теперь логика более понятна.

А почему бы просто не посчитать их?

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

Если вы не против быть немного загадочным, вы можете просто бросить вызов, 0 < (a + b + c) < 3который вернется, trueесли у вас есть от одного до двух истинных утверждений, и false, если все ложны или ни одно не является ложным.

Это также упрощается, если вы используете функции для оценки логических значений, поскольку вы оцениваете переменные только один раз, а это означает, что вы можете писать функции встроенными и не нужно временно хранить переменные. (Пример:. 0 < ( a(x) + b(x) + c(x) ) < 3)

В вопросе указано, что вам нужны либо все три аргумента (a и b и c), либо ни один из них (не (a или b или c))

Это дает:

(a и b и c) или нет (a или b или c)

Насколько я понимаю, у вас есть функция, которая принимает 3 аргумента, но если этого не произойдет, она будет работать по умолчанию. Поскольку вы не объяснили, что должно произойти, когда предоставлены 1 или 2 аргумента, я предполагаю, что он должен просто выполнять поведение по умолчанию. В этом случае, я думаю, вам будет очень полезен следующий ответ:

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

Однако, если вы хотите, чтобы 1 или 2 аргумента обрабатывались по-разному:

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

примечание: предполагается, что " False" значения не будут передаваться в этот метод.

Если вы работаете с итератором условий, доступ к нему может быть медленным. Но вам не нужно обращаться к каждому элементу более одного раза, и вам не всегда нужно читать его полностью. Вот решение, которое будет работать с бесконечными генераторами:

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

Когда каждый данный boolесть True, или когда каждый данный boolесть False...
все они равны друг другу!

Таким образом, мы просто должны найти два элемента , которые оценивают в разные boolс ,
чтобы знать , что есть по крайней мере один , Trueи по крайней мере один False.

Мое короткое решение:

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

Я верю, что это короткое замыкание, потому что AFAIK a==b==cравно a==b and b==c.

Мое обобщенное решение:

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)

Я также написал код, связанный с несколькими итерациями, но удалил его отсюда, потому что считаю это бессмысленным. Однако он все еще доступен здесь .

Это в основном «некоторые (но не все)» функциональность (по контрасту с any()и all()встроенной функцией).

Это означает, что среди результатов должны быть Falses и True s. Таким образом, вы можете сделать следующее:

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)

Одним из преимуществ этого кода является то, что вам нужно выполнить итерацию только один раз по результирующим (логическим) элементам.

Одним из недостатков является то, что все эти выражения истинности всегда вычисляются и не производят короткого замыкания, как операторы or/ and.