Як я можу знайти відсутнє значення більш стисло?

Наступний код перевіряє , якщо xі yє різними значення (змінні x, y, zможуть мати тільки значення a, bабо c) , і якщо так, то набори zдля третього символу:

if x == 'a' and y == 'b' or x == 'b' and y == 'a':
    z = 'c'
elif x == 'b' and y == 'c' or x == 'c' and y == 'b':
    z = 'a'
elif x == 'a' and y == 'c' or x == 'c' and y == 'a':
    z = 'b'

Чи можливо це зробити більш стислим, зрозумілим та ефективним способом?

z = (set(("a", "b", "c")) - set((x, y))).pop()

Я припускаю, що один із трьох випадків у вашому коді має місце. Якщо це так, набір set(("a", "b", "c")) - set((x, y))буде складатися з одного елемента, який повертаєтьсяpop() .

Редагувати: Як пропонував Реймонд Хеттінгер у коментарях, ви також можете скористатися розпаковуванням кортежів для вилучення окремого елемента з набору:

z, = set(("a", "b", "c")) - set((x, y))

stripМетод є ще одним варіантом , який працює швидко для мене:

z = 'abc'.strip(x+y) if x!=y else None

Відмінний код Свена зробив трохи занадто багато роботи і міг би використовувати розпакування кортежу замість pop () . Крім того, він міг би додати захисник if x != yдля перевірки різниці x та y . Ось як виглядає покращена відповідь:

# create the set just once
choices = {'a', 'b', 'c'}

x = 'a'
y = 'b'

# the main code can be used in a loop
if x != y:
    z, = choices - {x, y}

Ось порівняльні терміни з набором синхронізації, щоб показати відносну ефективність:

import timeit, itertools

setup_template = '''
x = %r
y = %r
choices = {'a', 'b', 'c'}
'''

new_version = '''
if x != y:
    z, = choices - {x, y}
'''

original_version = '''
if x == 'a' and y == 'b' or x == 'b' and y == 'a':
    z = 'c'
elif x == 'b' and y == 'c' or x == 'c' and y == 'b':
    z = 'a'
elif x == 'a' and y == 'c' or x == 'c' and y == 'a':
    z = 'b'
'''

for x, y in itertools.product('abc', repeat=2):
    print '\nTesting with x=%r and y=%r' % (x, y)
    setup = setup_template % (x, y)
    for stmt, name in zip([original_version, new_version], ['if', 'set']):
        print min(timeit.Timer(stmt, setup).repeat(7, 100000)),
        print '\t%s_version' % name

Ось результати таймінгу:

Testing with x='a' and y='a'
0.0410830974579     original_version
0.00535297393799    new_version

Testing with x='a' and y='b'
0.0112571716309     original_version
0.0524711608887     new_version

Testing with x='a' and y='c'
0.0383319854736     original_version
0.048309803009      new_version

Testing with x='b' and y='a'
0.0175108909607     original_version
0.0508949756622     new_version

Testing with x='b' and y='b'
0.0386209487915     original_version
0.00529098510742    new_version

Testing with x='b' and y='c'
0.0259420871735     original_version
0.0472128391266     new_version

Testing with x='c' and y='a'
0.0423510074615     original_version
0.0481910705566     new_version

Testing with x='c' and y='b'
0.0295209884644     original_version
0.0478219985962     new_version

Testing with x='c' and y='c'
0.0383579730988     original_version
0.00530385971069    new_version

Ці терміни показують, що продуктивність оригінальної версії досить сильно варіюється залежно від того, які оператори if ініціюються різними вхідними значеннями.

z = (set('abc') - set(x + y)).pop()

Ось усі сценарії, щоб показати, що це працює:

>>> (set('abc') - set('ab')).pop()   # x is a/b and y is b/a
'c'
>>> (set('abc') - set('bc')).pop()   # x is b/c and y is c/b
'a'
>>> (set('abc') - set('ac')).pop()   # x is a/c and y is c/a
'b'

Якби три розглянуті елементи не були "a", "b"а "c", а, скоріше 1, 2і 3, ви також можете використовувати двійковий XOR:

z = x ^ y

Більш загально, якщо ви хочете встановити zодне з трьох чисел a, що залишилось , bі cдавши два числа xі yз цього набору, ви можете використовувати

z = x ^ y ^ a ^ b ^ c

Звичайно, ви можете попередньо обчислити, a ^ b ^ cякщо цифри фіксовані.

Цей підхід також можна використовувати з оригінальними літерами:

z = chr(ord(x) ^ ord(y) ^ 96)

Приклад:

>>> chr(ord("a") ^ ord("c") ^ 96)
'b'

Не чекайте, що хтось, хто читає цей код, негайно зрозуміє, що це означає :)

Я думаю, що рішення Свена Марнаха та FJ є прекрасним, але це не швидше у моєму маленькому тесті. Це оптимізована версія Реймонда з використанням заздалегідь обчисленого set:

$ python -m timeit -s "choices = set('abc')" \
                   -s "x = 'c'" \
                   -s "y = 'a'" \
                      "z, = choices - set(x + y)"
1000000 loops, best of 3: 0.689 usec per loop

Оригінальне рішення:

$ python -m timeit -s "x = 'c'" \
                   -s "y = 'a'" \
                      "if x == 'a' and y == 'b' or x == 'b' and y == 'a':" \
                      "    z = 'c'" \
                      "elif x == 'b' and y == 'c' or x == 'c' and y == 'b':" \
                      "    z = 'a'" \
                      "elif x == 'a' and y == 'c' or x == 'c' and y == 'a':" \
                      "    z = 'b'"
10000000 loops, best of 3: 0.310 usec per loop

Зверніть увагу, що це найгірший можливий вхід для if-значень, оскільки всі шість порівнянь доведеться випробувати. Тестування з усіма значеннями для xі yдає:

x = 'a', y = 'b': 0.084 usec per loop
x = 'a', y = 'c': 0.254 usec per loop
x = 'b', y = 'a': 0.133 usec per loop
x = 'b', y = 'c': 0.186 usec per loop
x = 'c', y = 'a': 0.310 usec per loop
x = 'c', y = 'b': 0.204 usec per loop

Варіант на setоснові показує однакову продуктивність для різних входів, але постійно в 2 - 8 разів повільніший . Причина полягає в тому, що на ifбазі варіанта працює набагато простіший код: тести на рівність порівняно з хешуванням.

Я думаю, що обидва типи рішень цінні: важливо знати, що створення "складних" структур даних, таких як набори, коштує вам чогось у продуктивності - в той час як вони дають вам багато в читабельності та швидкості розробки . Складні типи даних також набагато кращі, коли код змінюється: легко розширити рішення на основі набору до чотирьох, п’яти, ... змінних, тоді як оператори if швидко перетворюються на кошмар обслуговування.

Спробуйте цей варіант, використовуючи словники:

z = {'ab':'c', 'ba':'c', 'bc':'a', 'cb':'a', 'ac':'b', 'ca':'b'}[x+y]

Звичайно, якщо x+yключа немає на карті, він видасть ключ, з KeyErrorяким вам доведеться обробляти.

Якщо словник попередньо обчислюється і зберігається для подальшого використання, доступ буде набагато швидшим, оскільки для кожної оцінки не потрібно буде створювати нових структур даних, потрібна лише конкатенація рядків та пошук словника:

lookup_table = {'ab':'c', 'ba':'c', 'bc':'a', 'cb':'a', 'ac':'b', 'ca':'b'}
z = lookup_table[x+y]

z = 'a'*('a' not in x+y) or 'b'*('b' not in x+y) or 'c'

або менш хакерський і використовуючи умовне призначення

z = 'a' if ('a' not in x+y) else 'b' if ('b' not in x+y) else 'c'

але, мабуть, вирішення дикту швидше ... вам доведеться його встигнути.

Я думаю, це повинно виглядати так:

z = (set(("a", "b", "c")) - set((x, y))).pop() if x != y else None

Використовуючи розуміння списку, припускаючи, як і інші, що має місце один із трьох випадків у вашому коді:

l = ['a', 'b', 'c']
z = [n for n in l if n not in [x,y]].pop()

Або, як у прийнятій відповіді, скориставшись кортежем, щоб розпакувати його,

z, = [n for n in l if n not in [x,y]]

Подивіться, чи це працює

if a not in xy
    z= 'a'
if b not in xy
    z='b'
if c not in xy
    z='c'