Python'da iki değişkenin mantıksal xor'unu nasıl elde edersiniz?

Python'da iki değişkenin mantıksal xor'unu nasıl elde edersiniz ?

Örneğin, dizeler olmasını beklediğim iki değişkenim var. Onlardan sadece biri doğru bir değer (hiçbiri veya boş dize değil) içerdiğini sınamak istiyorum:

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

^Operatör bitdüzeyi gibi görünüyor ve tüm nesnelerde tanımlanmamış:

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

Girdileri zaten boole'lara normalleştiriyorsanız, o zaman! = Xor olur.

bool(a) != bool(b)

Diğer mantıksal işlemlerden hesaplamak için xor tanımını her zaman kullanabilirsiniz:

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

Ama bu benim için biraz fazla ayrıntılı ve ilk bakışta özellikle net değil. Bunu yapmanın başka bir yolu:

bool(a) ^ bool(b)

İki boolean üzerindeki xor operatörü mantıksal xor'dur (bitlerin aksine, bitselin aksine). Bu mantıklı, çünkü boolsadece bir alt sınıfint , ama sadece değerleri 0ve sahip olmak için uygulanır 1. Domain sınırlı olduğunda Ve mantıksal xor bit düzeyinde xor eşdeğerdir 0ve 1.

Böylece logical_xorfonksiyon aşağıdaki gibi uygulanacaktır:

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

Kredi Python-3000 posta listesinde Nick Coghlan .

Bitwise exclusive- veya zaten Python'da yerleşiktir, operatormodüldeki ( ^operatörle aynıdır ):

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

As Zach açıkladı kullanabilirsiniz:

xor = bool(a) ^ bool(b)

Şahsen, biraz farklı bir lehçeyi tercih ediyorum:

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

Bu lehçeden, okulda öğrendiğim mantıksal bir diyagramlama dilinden esinlenilmiştir; burada "OR", ≥1(1'den büyük veya 1'e eşit) içeren bir kutu ile ve "XOR", içeren bir kutu ile belirtilmiştir =1.

Bunun özel veya birden fazla işlenen üzerinde doğru bir şekilde uygulanması avantajı vardır.

• "1 = a ^ b ^ c ...", gerçek işlenen sayısının tek olduğu anlamına gelir. Bu operatör "parite" dir.
• "1 = a + b + c ..." tam olarak bir işlenenin doğru olduğu anlamına gelir. Bu "münhasır ya da", yani "diğerlerinin dışlanmasına" anlamına gelir.

• Python mantıksal or: A or B: döner Aeğer bool(A)olduğunu True, aksi takdirde dönerB
• Python mantıksal and: A and B: döner Aeğer bool(A)olduğunu False, aksi takdirde dönerB

Bu düşünme biçiminin çoğunu korumak için, mantıksal xor tanımım:

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

Bu şekilde o dönebilir a, bya da False:

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

Birkaç yaklaşımı test ettim ve not a != (not b)en hızlı olduğu ortaya çıktı.

İşte bazı testler

%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

Düzenleme: Yukarıdaki örnek 1 ve 3, parantez eksik, bu nedenle sonuç yanlış. truth()ShadowRanger'ın önerdiği gibi yeni sonuçlar + işlevi.

%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

Ödüllendirici konu:

Anoder fikir ... Sadece mantıksal «xor» davranışını elde etmek için "değil" pitonik ifadesini deneyin

Doğruluk tablosu şöyle olurdu:

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

Ve örnek dizeniz için:

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

Ancak; yukarıda belirtildiği gibi, herhangi bir çift dizeyle ilgili çekmek istediğiniz gerçek davranışa bağlıdır, çünkü dizeler bolean değildir ... ve hatta daha fazlası: «Python'a Dalış» 'da «Tuhaf Doğası" ve "ve" veya "» http://www.diveintopython.net/power_of_introspection/and_or.html

Üzgünüm yazdığım İngilizcem, benim doğuştan gelen dil değil.

Saygılarımızla.

Python'un bitsel bir özel OR operatörü vardır ^:

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

Xor ( ^) öğesini uygulamadan önce girişleri boolelara dönüştürerek kullanabilirsiniz :

bool(a) ^ bool(b)

(Düzenlendi - teşekkürler Arel)

Değişken argümanları kullanarak xor'un basit varyantını görmediğim ve sadece True veya False değerleri üzerinde işlem yaptığım için, sadece herkesin kullanması için buraya atacağım. Başkaları tarafından belirtildiği gibi, oldukça açık (çok söylemek değil).

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

Ve kullanımı da basittir:

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

Bu genelleştirilmiş n-ary mantıksal XOR olduğundan, True işlenenlerinin sayısı garip olduğunda (ve sadece tam olarak bir True olduğunda değil, bu sadece n-ary XOR'un True olduğu bir durumdur) gerçeğin değeri True olacaktır.

Bu nedenle, yalnızca işlenenlerinden biri tam olarak doğru olduğunda n-ary yüklemini arıyorsanız, aşağıdakileri kullanmak isteyebilirsiniz:

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

Exclusive Or aşağıdaki gibi tanımlanır

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

Bazen kendimi boolean True ve False değerleri yerine 1 ve 0 ile çalışırken buluyorum. Bu durumda xor şu şekilde tanımlanabilir:

z = (x + y) % 2

Aşağıdaki doğruluk tablosuna sahiptir:

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

Bunun geç olduğunu biliyorum, ama bir düşüncem vardı ve sadece dokümantasyon için buna değebilir. Belki bu işe yarar: np.abs(x-y)Fikir şu ki

1. x = True = 1 ve y = False = 0 olursa sonuç | 1-0 | = 1 = True olur
2. x = False = 0 ve y = False = 0 ise sonuç | 0-0 | = 0 = False olur
3. x = True = 1 ve y = True = 1 ise sonuç | 1-1 | = 0 = Yanlış olur
4. x = False = 0 ve y = True = 1 ise sonuç | 0-1 | = 1 = True olur

Basit, anlaşılması kolay:

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

Özel bir seçim peşinde olduğunuz şeyse, birden fazla argümana genişletilebilir:

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

Buna ne dersin?

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

verecektir aeğer byanlışsa
verecektir beğer ayanlış
verecek Falseaksi

Veya Python 2.5+ üçlü ifadesiyle:

(False if a else b) if b else a

Burada önerilen uygulamalardan bazıları, bazı durumlarda işlenenlerin tekrar tekrar değerlendirilmesine neden olarak istenmeyen yan etkilere neden olabilir ve bu nedenle bundan kaçınılmalıdır.

Bununla birlikte, xorya geri dönen ya Trueda Falseoldukça basit bir uygulama ; işlenenlerden birini döndüren biri, mümkünse çok daha zordur, çünkü özellikle işlenenden fazla işlenen olduğunda, hangi işlenenin seçilmesi gerektiği konusunda bir fikir birliği yoktur. Örneğin, gereken xor(None, -1, [], True)dönmek None, []ya daFalse mi ? Eminim her cevap bazı insanlara en sezgisel cevap olarak görünür.

Doğru veya Yanlış sonuç için beş olası seçenek vardır: ilk işleneni döndür (sonuç sonucuyla eşleşirse, başka bir boolean), ilk eşleşmeyi döndür (en az bir tane varsa, başka bir boole), son işleneni döndür (if ... else ...), son eşleşmeyi döndür (if ... else ...) veya her zaman boolean döndürür. Tamamen, bu 5 ** 2 = 25 lezzet 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()

Ben de dahil olmak üzere birçok insanın xorn-giriş xor devresi gibi davranan ve n değişken olduğu bir işleve ihtiyacı vardır . (Bkz. Https://en.wikipedia.org/wiki/XOR_gate ). Aşağıdaki basit işlev bunu uygular.

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)

Örnek G / Ç aşağıdaki gibidir:

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

Python'da iki veya daha fazla değişkenin mantıksal xor değerini almak için:

1. Girdileri boolelara dönüştürün
2. Bitsel x ^veya operatörünü ( veya operator.xor) kullanın

Örneğin,

bool(a) ^ bool(b)

Girişleri boolelara dönüştürdüğünüzde, bitsel xor mantıksal xor olur .

Kabul edilen cevabın yanlış olduğunu unutmayın: operatör zincirlemesinin!= inceliği nedeniyle Python'daki xor ile aynı değildir .

Örneğin, aşağıdaki üç değerin xor değeri kullanılırken yanlıştır !=:

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

(Not: Bu uyarıyı eklemek için kabul edilen yanıtı düzenlemeyi denedim, ancak değişikliğim reddedildi.)

XOR'un ne yaptığını bildiğinizde kolaydır:

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))

Bu, iki (veya daha fazla) değişken için mantıksal özel XOR değerini alır

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

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

Bu kurulumdaki ilk sorun, büyük olasılıkla tüm listeyi iki kez geçmesi ve en azından elemanlardan en az birini iki kez kontrol etmesidir. Bu nedenle kodun anlaşılmasını artırabilir, ancak hıza katkıda bulunmaz (kullanım durumunuza bağlı olarak ihmal edilebilir şekilde farklılık gösterebilir).

Bu kurulumdaki ikinci sorun, değişken sayısına bakılmaksızın münhasırlığı kontrol etmesidir. Bu ilk başta bir özellik olarak kabul edilebilir, ancak değişkenlerin sayısı arttıkça (eğer varsa) ilk sorun çok daha önemli hale gelir.

Xor, ^Python'da. Döndürür:

• Ints için bitsel bir xor
• Bools için mantıksal xor
• Setler için özel bir birlik
• Uygulayan sınıflar için kullanıcı tanımlı sonuçlar __xor__ .
• Dizeler veya sözlükler gibi tanımlanmamış türler için TypeError.

Bunları yine de dizelerde kullanmak istiyorsanız, onları yayınlamak boolişleminizi açık hale getirir (aynı zamanda da olabilir set(str1) ^ set(str2)).

XOR, içinde uygulandı operator.xor.

Ben herhangi bir doğruluk tablosunu bu şekilde kodlamak istiyorum. Özellikle xor için:

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

Sadece cevap sütunundaki T değerlerine bakın ve tüm gerçek durumları mantıksal veya. Yani, bu doğruluk tablosu 2. veya 3. durumda üretilebilir.

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

Kullanarak iki değişkenin xor'unu kolayca bulabiliriz:

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

Misal:

xor (Doğru, Yanlış) >>> Doğru