Làm cách nào để tìm giá trị còn thiếu một cách ngắn gọn hơn?

Kiểm tra mã sau nếu xvà ylà những giá trị riêng biệt (các biến x, y, zchỉ có thể có giá trị a, bhoặc c) và nếu như vậy, bộ zvới nhân vật thứ ba:

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'

Có thể làm điều này theo cách ngắn gọn, dễ đọc và hiệu quả hơn không?

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

Tôi giả định rằng một trong ba trường hợp trong mã của bạn được giữ nguyên. Nếu đúng như vậy, tập hợp set(("a", "b", "c")) - set((x, y))sẽ bao gồm một phần tử duy nhất, được trả về bởi pop().

Chỉnh sửa: Theo đề xuất của Raymond Hettinger trong các nhận xét, bạn cũng có thể sử dụng bộ giải nén để trích xuất phần tử duy nhất từ ​​tập hợp:

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

Các stripphương pháp là một tùy chọn chạy một cách nhanh chóng cho tôi:

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

Đoạn mã tuyệt vời của Sven đã làm quá nhiều việc và đáng lẽ phải sử dụng bộ giải nén tuple thay vì pop () . Ngoài ra, nó có thể có thêm một bộ phận bảo vệ if x != yđể kiểm tra xem x và y có khác biệt hay không. Đây là câu trả lời được cải thiện trông như thế nào:

# 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}

Dưới đây là thời gian so sánh với bộ thời gian để hiển thị hiệu suất tương đối:

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

Đây là kết quả của thời gian:

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

Các mốc thời gian này cho thấy rằng hiệu suất của phiên bản gốc thay đổi khá nhiều tùy thuộc vào việc câu lệnh if nào được kích hoạt bởi các giá trị đầu vào khác nhau.

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

Dưới đây là tất cả các tình huống để cho thấy rằng nó hoạt động:

>>> (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'

Nếu ba mục trong câu hỏi không phải là "a", "b"và "c", mà đúng hơn 1, 2và 3, bạn cũng có thể sử dụng một XOR nhị phân:

z = x ^ y

Tổng quát hơn, nếu bạn muốn thiết lập zvới một còn lại của ba số a, bvà cđưa hai con số xvà ytừ bộ này, bạn có thể sử dụng

z = x ^ y ^ a ^ b ^ c

Tất nhiên bạn có thể tính toán trước a ^ b ^ cnếu con số được cố định.

Cách tiếp cận này cũng có thể được sử dụng với các chữ cái gốc:

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

Thí dụ:

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

Đừng mong đợi bất cứ ai đọc mã này ngay lập tức tìm ra ý nghĩa của nó :)

Tôi nghĩ giải pháp của Sven Marnach và FJ là tuyệt vời, nhưng nó không nhanh hơn trong thử nghiệm nhỏ của tôi. Đây là phiên bản được tối ưu hóa của Raymond sử dụng tính toán trước 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

Đây là giải pháp ban đầu:

$ 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

Lưu ý rằng đây là đầu vào tồi tệ nhất có thể cho if-statements vì tất cả sáu phép so sánh sẽ phải được thử. Thử nghiệm với tất cả các giá trị cho xvà ycho:

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

Các setbiến thể dựa trên cho thấy việc thực hiện tương tự cho đầu vào khác nhau, nhưng nó là một cách nhất quán giữa 2 và 8 lần chậm hơn . Lý do là ifbiến thể dựa trên chạy mã đơn giản hơn nhiều: kiểm tra bình đẳng so với băm.

Tôi nghĩ rằng cả hai loại giải pháp đều có giá trị: điều quan trọng là phải biết rằng việc tạo cấu trúc dữ liệu "phức tạp" như tập hợp sẽ khiến bạn tốn kém hiệu suất - trong khi chúng mang lại cho bạn rất nhiều về khả năng đọc và tốc độ phát triển . Các kiểu dữ liệu phức tạp cũng tốt hơn nhiều khi mã thay đổi: thật dễ dàng để mở rộng giải pháp dựa trên tập hợp thành bốn, năm, ... biến trong khi các câu lệnh if nhanh chóng biến thành cơn ác mộng bảo trì.

Hãy thử tùy chọn này, sử dụng từ điển:

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

Tất nhiên, nếu x+ychìa khóa không có trong bản đồ, nó sẽ tạo ra một chìa khóa KeyErrormà bạn sẽ phải xử lý.

Nếu từ điển được tính toán trước một lần và được lưu trữ để sử dụng trong tương lai, việc truy cập sẽ nhanh hơn nhiều, vì không phải tạo cấu trúc dữ liệu mới cho mỗi lần đánh giá, chỉ cần nối chuỗi và tra cứu từ điển:

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'

hoặc ít hackish hơn và sử dụng Chuyển nhượng có điều kiện

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

nhưng có lẽ giải pháp dict nhanh hơn ... bạn phải tính thời gian.

Tôi nghĩ nó sẽ như thế này:

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

Sử dụng khả năng hiểu danh sách, giả sử giống như những người khác rằng một trong ba trường hợp trong mã của bạn giữ nguyên:

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

Hoặc, giống như trong câu trả lời được chấp nhận, tận dụng tuple để giải nén nó,

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

Xem nếu điều này hoạt động

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