У мене є сценарій 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):

Що перекладає назву вашого запитання.

ОНОВЛЕННЯ: як правильно сказано Волатильність та Супр, ви можете застосувати закон Де Моргана і отримати еквівалент:

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якщо у вас є між одним і двома справжніми твердженнями, і хибними, якщо всі помилкові або жодне неправдиве.

Це також спрощує, якщо ви використовуєте функції для оцінки булів, оскільки ви оцінюєте змінні лише один раз, а це означає, що ви можете записати функції вбудовано і не потрібно тимчасово зберігати змінні. (Приклад:. 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 ...
всі вони рівні один одному!

Отже, нам просто потрібно знайти два елементи, які оцінюють різні bools,
щоб знати, що існує принаймні один 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оператори.