Comment obtenir le xor logique de deux variables en Python?

Comment obtenir le xor logique de deux variables en Python?

Par exemple, j'ai deux variables qui devraient être des chaînes. Je veux tester qu'un seul d'entre eux contient une valeur True (n'est pas None ou la chaîne vide):

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

L' ^opérateur semble être au niveau du bit et n'est pas défini sur tous les objets:

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

Si vous normalisez déjà les entrées en booléens, alors! = Est xor.

bool(a) != bool(b)

Vous pouvez toujours utiliser la définition de xor pour le calculer à partir d'autres opérations logiques:

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

Mais c'est un peu trop verbeux pour moi, et ce n'est pas particulièrement clair à première vue. Une autre façon de procéder est:

bool(a) ^ bool(b)

L'opérateur xor sur deux booléens est un xor logique (contrairement aux entiers, où il est au niveau du bit). Ce qui est logique, car booln'est qu'une sous-classe deint , mais est implémenté pour n'avoir que les valeurs 0et 1. Et xor logique est équivalent à xor au niveau du bit lorsque le domaine est limité à 0et 1.

Ainsi, la logical_xorfonction serait implémentée comme:

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

Nous remercions Nick Coghlan sur la liste de diffusion Python-3000 .

Bitwise exclusive-or est déjà intégré à Python, dans le operatormodule (qui est identique à l' ^opérateur):

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

Comme Zach l'a expliqué, vous pouvez utiliser:

xor = bool(a) ^ bool(b)

Personnellement, je privilégie un dialecte légèrement différent:

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

Ce dialecte est inspiré d'un langage de diagramme logique que j'ai appris à l'école où "OU" était désigné par une boîte contenant ≥1(supérieur ou égal à 1) et "XOR" était désigné par une boîte contenant =1.

Cela présente l'avantage d'implémenter correctement des opérandes exclusifs ou multiples.

• "1 = a ^ b ^ c ..." signifie que le nombre d'opérandes vrais est impair. Cet opérateur est "parité".
• "1 = a + b + c ..." signifie exactement qu'un opérande est vrai. C'est "exclusif ou", ce qui signifie "l'un à l'exclusion des autres".

• Python logique or:: A or Bretourne Asi bool(A)est True, sinon retourneB
• Python logique and:: A and Bretourne Asi bool(A)est False, sinon retourneB

Pour garder la plupart de cette façon de penser, ma définition logique xor serait:

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

De cette façon , il peut revenir a, bou False:

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

J'ai testé plusieurs approches et j'ai not a != (not b)semblé être la plus rapide.

Voici quelques tests

%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

Modifier: les exemples 1 et 3 ci-dessus manquent de parenthèses, donc le résultat est incorrect. Nouveaux résultats + truth()fonction comme suggéré par 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

Fil de récompense:

Idée d'anode ... Il suffit d'essayer l'expression (peut-être) pythonique «n'est pas» pour obtenir le comportement du «xor» logique

La table de vérité serait:

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

Et pour votre exemple de chaîne:

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

Toutefois; comme ils l'ont indiqué ci-dessus, cela dépend du comportement réel que vous souhaitez retirer sur les chaînes de couple, car les chaînes ne sont pas boléennes ... et plus encore: si vous «Plongez dans Python», vous trouverez «La nature particulière de" et "et" ou "» http://www.diveintopython.net/power_of_introspection/and_or.html

Désolé mon anglais écrit, ce n'est pas ma langue d'origine.

Cordialement.

Python a un opérateur OU exclusif au niveau du bit, c'est ^:

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

Vous pouvez l'utiliser en convertissant les entrées en booléens avant d'appliquer xor ( ^):

bool(a) ^ bool(b)

(Modifié - merci Arel)

Comme je ne vois pas la simple variante de xor utilisant des arguments variables et uniquement une opération sur les valeurs de vérité True ou False, je vais la jeter ici pour que quiconque puisse l'utiliser. C'est comme noté par d'autres, assez (pour ne pas dire très) simple.

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

Et l'utilisation est également simple:

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

Comme il s'agit du XOR logique n-aire généralisé, sa valeur de vérité sera True chaque fois que le nombre d'opérandes True est impair (et pas seulement quand exactement un est True, ce n'est qu'un cas dans lequel le XOR n-aire est True).

Ainsi, si vous êtes à la recherche d'un prédicat n-aire qui n'est vrai que lorsque l'un de ses opérandes est exactement, vous pouvez utiliser:

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

Exclusif Or est défini comme suit

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

Parfois, je me retrouve à travailler avec 1 et 0 au lieu des valeurs booléennes True et False. Dans ce cas, xor peut être défini comme

z = (x + y) % 2

qui a la table de vérité suivante:

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

Je sais que c'est tard, mais j'ai eu une pensée et ça pourrait valoir la peine, juste pour la documentation. Peut-être que cela fonctionnerait: np.abs(x-y)L'idée est que

1. si x = True = 1 et y = False = 0 alors le résultat serait | 1-0 | = 1 = True
2. si x = Faux = 0 et y = Faux = 0 alors le résultat serait | 0-0 | = 0 = Faux
3. si x = True = 1 et y = True = 1, le résultat serait | 1-1 | = 0 = False
4. si x = False = 0 et y = True = 1 alors le résultat serait | 0-1 | = 1 = True

Simple, facile à comprendre:

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

Si un choix exclusif est ce que vous recherchez, il peut être étendu à plusieurs arguments:

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

Que dis-tu de ça?

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

donnera asi best faux
donnera bsi aest faux
donnera Falseautrement

Ou avec l'expression ternaire Python 2.5+:

(False if a else b) if b else a

Certaines des implémentations suggérées ici entraîneront une évaluation répétée des opérandes dans certains cas, ce qui peut entraîner des effets secondaires involontaires et doit donc être évité.

Cela dit, une xorimplémentation qui renvoie soit Trueou Falseest assez simple; celui qui renvoie l'un des opérandes, si possible, est beaucoup plus délicat, car il n'y a pas de consensus quant à l'opérande qui doit être choisi, surtout lorsqu'il y a plus de deux opérandes. Par exemple, devrait xor(None, -1, [], True)revenir None, []ou False? Je parie que chaque réponse apparaît à certaines personnes comme la plus intuitive.

Pour le résultat True ou False, il y a jusqu'à cinq choix possibles: retourner le premier opérande (s'il correspond au résultat final en valeur, sinon booléen), retourner la première correspondance (s'il en existe au moins un, sinon booléen), retourne le dernier opérande (si ... sinon ...), retourne la dernière correspondance (si ... sinon ...), ou retourne toujours booléen. Au total, cela fait 5 ** 2 = 25 saveurs de 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()

Beaucoup de gens, y compris moi-même, ont besoin d'une xorfonction qui se comporte comme un circuit xor à n entrées, où n est variable. (Voir https://en.wikipedia.org/wiki/XOR_gate ). La fonction simple suivante implémente cela.

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)

Voici un exemple d'E / S:

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

Pour obtenir le xor logique de deux ou plusieurs variables en Python:

1. Convertir les entrées en booléens
2. Utilisez l'opérateur xor au niveau du bit ( ^ou operator.xor)

Par exemple,

bool(a) ^ bool(b)

Lorsque vous convertissez les entrées en booléens, xor au niveau du bit devient xor logique .

Notez que la réponse acceptée est fausse: != n'est pas la même chose que xor en Python en raison de la subtilité du chaînage des opérateurs .

Par exemple, le xor des trois valeurs ci-dessous est incorrect lors de l'utilisation !=:

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

(PS J'ai essayé de modifier la réponse acceptée pour inclure cet avertissement, mais ma modification a été rejetée.)

C'est facile quand vous savez ce que fait 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))

Ceci obtient le XOR logique exclusif pour deux (ou plus) variables

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

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

Le premier problème avec cette configuration est qu'elle traverse très probablement toute la liste deux fois et, au minimum, vérifiera au moins un des éléments deux fois. Il peut donc augmenter la compréhension du code, mais il ne se prête pas à la vitesse (qui peut différer de manière négligeable selon votre cas d'utilisation).

Le deuxième problème avec cette configuration est qu'elle vérifie l'exclusivité quel que soit le nombre de variables. C'est peut-être au premier abord considéré comme une caractéristique, mais le premier problème devient beaucoup plus important à mesure que le nombre de variables augmente (si jamais elles le font).

Xor est ^en Python. Il renvoie:

• Un xor au niveau du bit pour les pouces
• Xor logique pour bools
• Une union exclusive pour les décors
• Résultats définis par l'utilisateur pour les classes qui implémentent __xor__.
• TypeError pour les types non définis, tels que les chaînes ou les dictionnaires.

Si vous avez l'intention de les utiliser sur des chaînes de toute façon, les intégrer boolrend votre opération sans ambiguïté (vous pouvez également signifier set(str1) ^ set(str2)).

XOR est implémenté dans operator.xor.

C'est ainsi que je coderais n'importe quelle table de vérité. Pour xor en particulier, nous avons:

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

Regardez simplement les valeurs T dans la colonne de réponse et enchaînez tous les vrais cas avec un ou logique. Donc, cette table de vérité peut être produite dans le cas 2 ou 3. Par conséquent,

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

Nous pouvons facilement trouver le xor de deux variables en utilisant:

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

Exemple:

xor (Vrai, Faux) >>> Vrai