Bagaimana Anda mendapatkan xor logis dari dua variabel dengan Python?

Bagaimana Anda mendapatkan xor logis dari dua variabel dengan Python?

Sebagai contoh, saya memiliki dua variabel yang saya harapkan menjadi string. Saya ingin menguji bahwa hanya satu dari mereka yang berisi nilai True (bukan None atau string kosong):

str1 = raw_input("Enter string one:")
str2 = raw_input("Enter string two:")
if logical_xor(str1, str2):
    print "ok"
else:
    print "bad"

The ^Operator tampaknya bitwise, dan tidak didefinisikan pada semua objek:

>>> 1 ^ 1
0
>>> 2 ^ 1
3
>>> "abc" ^ ""
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for ^: 'str' and 'str'

Jika Anda sudah menormalkan input ke boolean, maka! = Adalah xor.

bool(a) != bool(b)

Anda selalu dapat menggunakan definisi xor untuk menghitungnya dari operasi logis lainnya:

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

Tapi ini agak terlalu bertele-tele bagi saya, dan pada pandangan pertama tidak terlalu jelas. Cara lain untuk melakukannya adalah:

bool(a) ^ bool(b)

Operator xor pada dua boolean adalah xor logis (tidak seperti pada int, di mana bitwise). Yang masuk akal, karena boolhanya subkelas dariint , tetapi diimplementasikan untuk hanya memiliki nilai 0dan 1. Dan xor logis setara dengan xor bitwise ketika domain dibatasi untuk 0dan1 .

Jadi logical_xorfungsi akan diimplementasikan seperti:

def logical_xor(str1, str2):
    return bool(str1) ^ bool(str2)

Penghargaan untuk Nick Coghlan di milis Python-3000 .

Bitwise eksklusif-atau sudah ada di dalam Python, dalam operatormodul (yang identik dengan ^operator):

from operator import xor
xor(bool(a), bool(b))  # Note: converting to bools is essential

Seperti yang dijelaskan Zach , Anda dapat menggunakan:

xor = bool(a) ^ bool(b)

Secara pribadi, saya menyukai dialek yang sedikit berbeda:

xor = bool(a) + bool(b) == 1

Dialek ini terinspirasi dari bahasa diagram diagram logis yang saya pelajari di sekolah tempat "ATAU" dilambangkan dengan kotak yang berisi ≥1(lebih besar atau sama dengan 1) dan "XOR" dilambangkan dengan kotak yang berisi=1 .

Ini memiliki keuntungan menerapkan dengan benar eksklusif atau pada beberapa operan.

• "1 = a ^ b ^ c ..." berarti jumlah operan benar ganjil. Operator ini "paritas".
• "1 = a + b + c ..." berarti tepat satu operan benar. Ini "eksklusif atau", yang berarti "satu dengan mengesampingkan yang lain".

• Python logis or: A or B: kembali Ajika bool(A)yaituTrue , jika tidak kembaliB
• Python logis and:: A and Bmengembalikan Ajika bool(A)adaFalse , jika tidak kembaliB

Untuk menjaga sebagian besar cara berpikir itu, definisi logis saya adalah:

def logical_xor(a, b):
    if bool(a) == bool(b):
        return False
    else:
        return a or b

Dengan cara itu dapat kembali a, batau False:

>>> logical_xor('this', 'that')
False
>>> logical_xor('', '')
False
>>> logical_xor('this', '')
'this'
>>> logical_xor('', 'that')
'that'

Saya telah menguji beberapa pendekatan dan not a != (not b)tampaknya menjadi yang tercepat.

Berikut ini beberapa tes

%timeit not a != (not b)
10000000 loops, best of 3: 78.5 ns per loop

%timeit bool(a) != bool(b)
1000000 loops, best of 3: 343 ns per loop

%timeit not a ^ (not b)
10000000 loops, best of 3: 131 ns per loop

Sunting: Contoh 1 dan 3 di atas tidak ada tanda kurung sehingga hasilnya salah. Hasil + truth()fungsi baru seperti yang disarankan ShadowRanger.

%timeit  (not a) ^  (not b)   # 47 ns
%timeit  (not a) != (not b)   # 44.7 ns
%timeit truth(a) != truth(b)  # 116 ns
%timeit  bool(a) != bool(b)   # 190 ns

Utas penghargaan:

Ide anoder ... Hanya Anda mencoba (mungkin) ekspresi pythonic «tidak» untuk mendapatkan perilaku logis «xor»

Tabel kebenarannya adalah:

>>> True is not True
False
>>> True is not False
True
>>> False is not True
True
>>> False is not False
False
>>>

Dan untuk string contoh Anda:

>>> "abc" is not  ""
True
>>> 'abc' is not 'abc' 
False
>>> 'abc' is not '' 
True
>>> '' is not 'abc' 
True
>>> '' is not '' 
False
>>> 

Namun; seperti yang mereka sebutkan di atas, itu tergantung pada perilaku aktual yang ingin Anda tarik tentang string pasangan mana pun, karena string bukan bolean ... dan bahkan lebih: jika Anda «Menyelam Ke Python» Anda akan menemukan «Sifat Aneh" dan "dan" atau "» http://www.diveintopython.net/power_of_introspection/and_or.html

Maaf saya menulis bahasa Inggris, ini bukan bahasa kelahiran saya.

Salam.

Python memiliki operator eksklusif-ATAU bitwise, yaitu ^:

>>> True ^ False
True
>>> True ^ True
False
>>> False ^ True
True
>>> False ^ False
False

Anda dapat menggunakannya dengan mengonversi input ke boolean sebelum menerapkan xor ( ^):

bool(a) ^ bool(b)

(Diedit - terima kasih Arel)

Karena saya tidak melihat varian sederhana dari xor menggunakan argumen variabel dan hanya operasi pada nilai-nilai Kebenaran Benar atau Salah, saya hanya akan melemparkannya ke sini untuk digunakan orang lain. Ini seperti dicatat oleh orang lain, cukup (tidak untuk mengatakan sangat) langsung.

def xor(*vars):
    sum = False
    for v in vars:
        sum = sum ^ bool(v)
    return sum

Dan penggunaannya juga mudah:

if xor(False, False, True, False):
    print "Hello World!"

Karena ini adalah XOR n-ary logis yang digeneralisasikan, nilai kebenarannya akan Benar setiap kali jumlah operan Benar ganjil (dan tidak hanya ketika tepat satu yang Benar, ini hanya satu kasus di mana n-ary XOR adalah Benar).

Jadi jika Anda mencari predikat n-ary yang hanya Benar ketika salah satu operannya benar, Anda mungkin ingin menggunakan:

def isOne(*vars):
    sum = False
    for v in vars:
        if sum and v:
            return False
        else:
            sum = sum or v
    return sum

Eksklusif Atau didefinisikan sebagai berikut

def xor( a, b ):
    return (a or b) and not (a and b)

Kadang-kadang saya menemukan diri saya bekerja dengan 1 dan 0 bukannya boolean nilai Benar dan Salah. Dalam hal ini xor dapat didefinisikan sebagai

z = (x + y) % 2

yang memiliki tabel kebenaran berikut:

     x
   |0|1|
  -+-+-+
  0|0|1|
y -+-+-+
  1|1|0|
  -+-+-+

Saya tahu ini terlambat, tetapi saya punya pemikiran dan mungkin layak, hanya untuk dokumentasi. Mungkin ini akan berhasil: np.abs(x-y)Idenya adalah itu

1. jika x = Benar = 1 dan y = Salah = 0 maka hasilnya adalah | 1-0 | = 1 = Benar
2. jika x = Salah = 0 dan y = Salah = 0 maka hasilnya adalah | 0-0 | = 0 = Salah
3. jika x = Benar = 1 dan y = Benar = 1 maka hasilnya adalah | 1-1 | = 0 = Salah
4. jika x = Salah = 0 dan y = Benar = 1 maka hasilnya adalah | 0-1 | = 1 = Benar

Sederhana, mudah dimengerti:

sum( (bool(a), bool(b) ) == 1

Jika pilihan eksklusif adalah yang Anda cari, itu dapat diperluas ke beberapa argumen:

sum( bool(x) for x in y ) % 2 == 1

Bagaimana dengan ini?

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

akan memberi ajika bsalah
akan memberi bjika asalah
akan memberi Falsesebaliknya

Atau dengan ekspresi terner Python 2.5+:

(False if a else b) if b else a

Beberapa implementasi yang disarankan di sini akan menyebabkan evaluasi berulang operan dalam beberapa kasus, yang dapat menyebabkan efek samping yang tidak diinginkan dan karenanya harus dihindari.

Yang mengatakan, xorimplementasi yang mengembalikan salah satu Trueatau Falsecukup sederhana; yang mengembalikan salah satu operan, jika mungkin, jauh lebih rumit, karena tidak ada konsensus mengenai operan mana yang harus dipilih, terutama ketika ada lebih dari dua operan. Misalnya, harus xor(None, -1, [], True)kembali None, []atauFalse ? Saya yakin setiap jawaban bagi sebagian orang tampak sebagai yang paling intuitif.

Untuk hasil Benar atau Salah, ada sebanyak lima pilihan yang mungkin: kembalikan operan pertama (jika cocok dengan hasil akhir dalam nilai, atau boolean), kembalikan kecocokan pertama (jika setidaknya ada satu, boolean lain), kembalikan operan terakhir (jika ... lain ...), kembalikan pertandingan terakhir (jika ... lain ...), atau selalu kembalikan boolean. Secara keseluruhan, itu 5 ** 2 = 25 rasa xor.

def xor(*operands, falsechoice = -2, truechoice = -2):
  """A single-evaluation, multi-operand, full-choice xor implementation
  falsechoice, truechoice: 0 = always bool, +/-1 = first/last operand, +/-2 = first/last match"""
  if not operands:
    raise TypeError('at least one operand expected')
  choices = [falsechoice, truechoice]
  matches = {}
  result = False
  first = True
  value = choice = None
  # avoid using index or slice since operands may be an infinite iterator
  for operand in operands:
    # evaluate each operand once only so as to avoid unintended side effects
    value = bool(operand)
    # the actual xor operation
    result ^= value
    # choice for the current operand, which may or may not match end result
    choice = choices[value]
    # if choice is last match;
    # or last operand and the current operand, in case it is last, matches result;
    # or first operand and the current operand is indeed first;
    # or first match and there hasn't been a match so far
    if choice < -1 or (choice == -1 and value == result) or (choice == 1 and first) or (choice > 1 and value not in matches):
      # store the current operand
      matches[value] = operand
    # next operand will no longer be first
    first = False
  # if choice for result is last operand, but they mismatch
  if (choices[result] == -1) and (result != value):
    return result
  else:
    # return the stored matching operand, if existing, else result as bool
    return matches.get(result, result)

testcases = [
  (-1, None, True, {None: None}, [], 'a'),
  (None, -1, {None: None}, 'a', []),
  (None, -1, True, {None: None}, 'a', []),
  (-1, None, {None: None}, [], 'a')]
choices = {-2: 'last match', -1: 'last operand', 0: 'always bool', 1: 'first operand', 2: 'first match'}
for c in testcases:
  print(c)
  for f in sorted(choices.keys()):
    for t in sorted(choices.keys()):
      x = xor(*c, falsechoice = f, truechoice = t)
      print('f: %d (%s)\tt: %d (%s)\tx: %s' % (f, choices[f], t, choices[t], x))
  print()

Banyak orang, termasuk saya, membutuhkan xorfungsi yang berperilaku seperti n-input xor circuit, di mana n adalah variabel. (Lihat https://en.wikipedia.org/wiki/XOR_gate ). Fungsi sederhana berikut mengimplementasikan ini.

def xor(*args):
   """
   This function accepts an arbitrary number of input arguments, returning True
   if and only if bool() evaluates to True for an odd number of the input arguments.
   """

   return bool(sum(map(bool,args)) % 2)

Contoh I / O berikut:

In [1]: xor(False, True)
Out[1]: True

In [2]: xor(True, True)
Out[2]: False

In [3]: xor(True, True, True)
Out[3]: True

Untuk mendapatkan xor logis dari dua atau lebih variabel dalam Python:

1. Konversikan input ke boolean
2. Gunakan bitwise xor operator ( ^atau operator.xor)

Sebagai contoh,

bool(a) ^ bool(b)

Ketika Anda mengonversi input menjadi booleans, bitwise xor menjadi xor logis .

Perhatikan bahwa jawaban yang diterima salah: != tidak sama dengan xor dengan Python karena kehalusan chaining operator .

Misalnya, xor dari tiga nilai di bawah salah ketika menggunakan !=:

True ^  False ^  False  # True, as expected of XOR
True != False != False  # False! Equivalent to `(True != False) and (False != False)`

(PS Saya mencoba mengedit jawaban yang diterima untuk memasukkan peringatan ini, tetapi perubahan saya ditolak.)

Sangat mudah ketika Anda tahu apa yang dilakukan XOR:

def logical_xor(a, b):
    return (a and not b) or (not a and b)

test_data = [
  [False, False],
  [False, True],
  [True, False],
  [True, True],
]

for a, b in test_data:
    print '%r xor %s = %r' % (a, b, logical_xor(a, b))

Ini mendapatkan XOR eksklusif logis untuk dua (atau lebih) variabel

str1 = raw_input("Enter string one:")
str2 = raw_input("Enter string two:")

any([str1, str2]) and not all([str1, str2])

Masalah pertama dengan pengaturan ini adalah bahwa kemungkinan besar melintasi seluruh daftar dua kali dan, setidaknya, akan memeriksa setidaknya satu dari elemen dua kali. Jadi mungkin meningkatkan pemahaman kode, tetapi tidak memberikan kecepatan (yang mungkin berbeda tergantung pada kasus penggunaan Anda).

Masalah kedua dengan pengaturan ini adalah memeriksa eksklusivitas terlepas dari jumlah variabel. Ini pada awalnya dapat dianggap sebagai fitur, tetapi masalah pertama menjadi jauh lebih signifikan karena jumlah variabel meningkat (jika mereka pernah melakukannya).

Xor ^menggunakan Python. Ia mengembalikan:

• Bitor xor untuk int
• Logor logis untuk bools
• Serikat eksklusif untuk set
• Hasil yang ditentukan pengguna untuk kelas yang mengimplementasikan __xor__ .
• TypeError untuk tipe yang tidak ditentukan, seperti string atau kamus.

Jika Anda berniat menggunakannya pada string, memasukkannya ke dalam boolmembuat operasi Anda tidak ambigu (bisa juga berarti set(str1) ^ set(str2)).

XOR diimplementasikan di operator.xor.

Ini adalah bagaimana saya akan membuat tabel kebenaran apa pun. Untuk xor khususnya kami memiliki:

| a | b  | xor   |             |
|---|----|-------|-------------|
| T | T  | F     |             |
| T | F  | T     | a and not b |
| F | T  | T     | not a and b |
| F | F  | F     |             |

Lihat saja nilai-nilai T di kolom jawaban dan string bersama-sama semua kasus nyata dengan logis atau. Jadi, tabel kebenaran ini dapat diproduksi dalam kasus 2 atau 3. Oleh karena itu,

xor = lambda a, b: (a and not b) or (not a and b)

Kita dapat dengan mudah menemukan xor dari dua variabel dengan menggunakan:

def xor(a,b):
    return a !=b

Contoh:

xor (Benar, Salah) >>> Benar