Làm cách nào để tìm giá trị còn thiếu chính xác hơn?

Question

sẽ kiểm tra mã sau nếu x và y là những giá trị riêng biệt (các biến x, y, z chỉ có thể có giá trị a, b, hoặc c) và nếu như vậy, đặt z vớ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ể thực hiện điều này theo cách ngắn gọn, dễ đọc hơn và hiệu quả hơn không?

Answer 1

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 nắm giữ. Trong trường hợp nà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().

Edit: Theo đề nghị của Raymond hettinger trong các ý kiến, bạn cũng có thể sử dụng tuple giải nén để trích xuất các phần tử từ tập:

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

Answer 2

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

Dưới đây là tất cả các kịch bản để hiển thị 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' 

Answer 3

tôi nghĩ rằng nó nên trông như thế:

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

Answer 4

Tôi nghĩ rằng giải pháp của Sven Marnach và F.J là đẹp, nhưng nó không nhanh hơn trong bài kiểm tra nhỏ của tôi. Đây là phiên bản được tối ưu hóa Raymond bằng cách sử dụng một 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 gốc:

$ 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à tồi tệ nhất có thể đầu vào cho if -statements từ tất cả sáu so sánh sẽ phải được thử. Thử nghiệm với tất cả các giá trị cho x và y cho:

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 set biế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 chậm 2 và 8 lần. Lý do là phiên bản dựa trên if chạy mã đơn giản hơn nhiều: kiểm tra bình đẳng so với băm.

Tôi nghĩ 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 chi phí cho bạn hiệu suất - trong khi chúng cung cấp cho bạn nhiều 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 thay đổi mã: thật dễ dàng để mở rộng giải pháp dựa trên thiết lậ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ì.

Answer 5

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

hoặc ít hackish 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ẽ là giải pháp dict là nhanh hơn ... bạn muốn có thời gian nó.

Answer 6

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

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

Tất nhiên, nếu phím x+y là không có mặt trong bản đồ, nó sẽ tạo ra một KeyError mà bạn sẽ phải xử lý.

Nếu từ điển được precomputed một lần duy nhất và được lưu trữ để sử dụng trong tương lai, truy cập sẽ nhanh hơn nhiều, vì không có cấu trúc dữ liệu mới sẽ được tạo ra cho mỗi đánh giá, chỉ cần một chuỗi nố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] 

Answer 7

Nếu ba mục trong câu hỏi là không "a", "b" và "c", nhưng thay vì 1, 2 và 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 z để còn lại một trong ba số a, b và c cho hai số x và y từ bộ này, bạn có thể sử dụng

z = x^y^a^b^c 

Tất nhiên bạn có thể precompute a^b^c nếu các 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) 

Ví dụ:

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

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

Answer 8

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

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

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

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

Answer 9

mã tuyệt vời của Sven đã làm chỉ là một chút quá nhiều công việc và chould đã sử dụng tuple giải nén thay vì pop (). Ngoài ra, nó có thể đã thêm một bảo vệ if x != y để kiểm tra x và y là khác biệt.Dưới đây là những gì các câu trả lời được cải thiện trông giống như:

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

Sau đây là các timings so sánh với một bộ thời gian để hiển thị các 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 

Dưới đây là kết quả của timings:

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 

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

Answer 10

Phương pháp strip là một tùy chọn chạy một cách nhanh chóng đối với tôi: "Có"

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

Answer 11

Xem nếu điều này làm việc

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