Quel est le signe de l'opérateur (^) en Python faire?

J'ai couru à travers le signe de l'opérateur en python, aujourd'hui, et en l'essayant, j'ai obtenu le résultat suivant:

>>> 8^3
11
>>> 8^4
12
>>> 8^1
9
>>> 8^0
8
>>> 7^1
6
>>> 7^2
5
>>> 7^7
0
>>> 7^8
15
>>> 9^1
8
>>> 16^1
17
>>> 15^1
14
>>>

Il semble être basé sur 8, donc je suppose une sorte de byte opération? Je n'arrive pas à trouver grand chose sur cette recherche des sites autres qu'il se comporte bizarrement pour des flotteurs, quelqu'un a un lien pour ce que cet opérateur ne ou pouvez-vous expliquer ici?

Pour les entiers, même chose qu'il fait en C. ^_-
Pour info, à partir de l'interface python, vous pouvez taper help('^')
-1: C'est complètement couvert dans la documentation Python et à la fonction d'aide. Poser cette question ici est idiot.
Notez qu'il ne veut pas se comporter de façon étrange pour des flotteurs (il ne fonctionne tout simplement pas avec des chars!). Notez également que de nombreuses personnes accidentellement couru dans cette tout en regardant pour **, l'opérateur exponentiel.
help('^') ne fait rien dans mon Python 2.6.1 (apple construire). @S. Lott: entendez-vous ce (docs.python.org/reference/...) quand vous êtes en train de dire "complètement couvert"?. Semble un peu limité pour quelqu'un de familier avec le concept...
Merci à tous, je suppose que si je savais que c'était un opérateur au niveau du bit, je l'aurais su où chercher, mais je n'ai pas, d'où la question 🙂 Merci à tous pour vos réponses, elles ont toutes été utile et je sais maintenant un peu plus! 🙂
Graham: c'est en fait d'où il vient. J'ai vu l' ** l'opérateur et de la pensée, eh bien, je me demande ce signe ne puis, et ici, nous sommes 🙂
Non, il ne voulait pas dire que la page, qui est sur l'analyse de Python, il pas la sémantique de ce ^ n'. help('^') dans interactive interpretter devrait tirer vers le haut à l'aide d'expliquer les opérateurs arithmétiques, ce qui aurait fourni le nom "XOR au niveau du bit", qui aurait été assez d'informations.
J'ai essayé ceci dans mon interprète (2.5.4) et a obtenu: >>> aide('^') n la documentation Python trouvé pour '^'

InformationsquelleAutor Fry | 2010-03-16

142

C'est un bit à bit XOR (OU exclusif).

Le résultat est vrai si un (et un seul) des opérandes (donne) vrai.

À démontrer:
```
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
```
D'expliquer l'un de vos propres exemples:
```
>>> 8^3
11
```
Pensez-y de cette façon:
```
1000 # 8 (binaire) 
0011 # 3 (binaire) 
---- # APPLIQUER XOR ('verticale') 
1011 # result = 11 (binaire) 
```
- Un peu plus à l'exemple peut inclure à la fois des nombres ayant 1 dans le même bit de préciser que 1 xor 1 = 0.
- Je voulais ajouter, vous pouvez faire des nombres binaires en tapant 0bX où X est votre binaire. 0b0001, 0b0010, etc. Donc, 0b1101 ^ 0b1110 serait de vous donner 0b0011 (ou 3).
- Je pense que "le résultat est vrai si l'un (et un seul) des opérandes (donne) vrai." n'est pas exact, il quelle serait la définition d'une valeur booléenne xor
InformationsquelleAutor ChristopheD
39

Il appelle la __xor__() ou __rxor__() méthode de l'objet en tant que de besoin, ce qui pour les types integer fait un bit à bit ou exclusif.
- +1 pour le pointage de quoi il s' vraiment n'a, en dehors de l'entier de l'opération.
InformationsquelleAutor Ignacio Vazquez-Abrams
12

C'est un bit à bit ou exclusif. Binaire opérateurs au niveau du bit sont documentées dans le chapitre 5 de la Référence au Langage Python.

InformationsquelleAutor Alex Martelli
8

Généralement parlant, le symbole ^ est un infix version de la __xor__ ou __rxor__ méthodes. Quels que soient les types de données sont placés à droite et à gauche du symbole doit implémenter cette fonction dans des conditions de compatibilité. Pour les entiers, c'est la commune XOR opération, mais par exemple il n'est pas intégré dans la définition de la fonction de type de float avec le type int:
```
In [12]: 3 ^ 4
Out[12]: 7

In [13]: 3.3 ^ 4
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-13-858cc886783d> in <module>()
----> 1 3.3 ^ 4

TypeError: unsupported operand type(s) for ^: 'float' and 'int'
```
Une chose intéressante à propos de Python, c'est que vous pouvez remplacer ce comportement dans une classe de votre choix. Par exemple, dans certaines langues, le ^ symbole signifie que l'exponentiation. Vous pourriez le faire de cette façon, juste à titre d'exemple:
```
class Foo(float):
    def __xor__(self, other):
        return self ** other
```
Alors quelque chose de ce genre de travail, et maintenant, pour les instances de Foo seulement, le ^ symbole signifie exponentiation.
```
In [16]: x = Foo(3)

In [17]: x
Out[17]: 3.0

In [18]: x ^ 4
Out[18]: 81.0
```
- woah, était-il même possible? et pourrions-nous probablement changer la façon dont les + opérateur travaille trop?
- Oui, c'est la façon dont le + symbole est capable de faire un genre d'action pour list (concaténation) tout en faisant un autre type d'action (mathématique plus) pour les types numériques. Dans ce cas, vous devez substituer la __add__ ou __radd__ méthodes de votre classe.
- Comme une note côté, le __r*__ version de ceux-ci (comme __rxor__ ou __radd__) va être appelée à partir de l'argument figurant sur le droite de l'infixe symbole, et seulement si, l'appel à la fonction pour la main gauche symbole ne fonctionne pas. Vous pouvez penser à elle comme try: left_hand_symbol.__xor__(right_hand_symbol); except: right_hand_symbol.__rxor__(left_hand_symbol), mais xor peut être remplacé par un des opérateurs infixes dans le Python, Modèle de Données.
- Ce qui signifie que je peux créer mon propre opérateur qui permet int concaténation de chaînes? l'homme, python est une façon complexe que ce que je pensais
- Ouais, c'est chouette. Il y a un projet open source appelé Czerny et j'ai entendu parler à PyCon un an. C'est là que j'ai vu l'infixe les opérations ont été manipulées afin de rendre la syntaxe du programme plus belle et élégante. Je suppose que dans la composition de la musique, il est important de savoir si les choses sont enchaînés comme les canalisations de commandes à l'invite unix, ou si elles sont exécutées en parallèle. Ainsi, l'auteur a remplacé l'opérateur "ou", |, et le sol opérateur de division, //, pour dire "pipe" ou "parallèle" pour sa musique objets.
- Donc, vous pourriez dire quelque chose comme (CompositionA | CompositionB) // CompositionC et il serait juste de dire "Jouer de la composition d'Un suivi par la composition B, entre-temps aussi jouer de la composition C en même temps en parallèle." Parler d'un beau morceau de code!
- Note de côté, vu que Python se définit comme une opération xor et le nom de la méthode a "xor" en elle, je pense qu'il serait un mauvais choix de conception afin de rendre cette méthode de faire quelque chose de pas liées à la xor comme l'exponentiation. Je pense que c'est un bon exemple de la façon dont il l'appelle simplement la __xor__ méthode, mais de le faire pour de vrai serait une mauvaise pratique.
- Je ne suis pas nécessairement en désaccord avec vous: il y a peut être un lot de plus haut mièvre abus de Python, modèle de données. D'autre part, il y a quelque chose à dire pour le fait que ce n'est rien, mais un nom de méthode, c'est tout. Que faire si vous êtes à la mise en œuvre d'une classe qui n'a rien à voir avec les opérations bit à bit, le calcul numérique, booléen ou condition, mais il se trouve que vous besoin d'une expressif opérateur binaire pour la syntaxe de concision? Dans ce cas, je pense qu'il serait tout à fait bien, car il n'y a aucun risque de confondre le "xor" d'un sens pour un certain type de logique au niveau du bit.
- Ouais, j'étais à la recherche pour cela il suffit de savoir que la magie de la méthode de ça 😛
InformationsquelleAutor ely
2

Lorsque vous utilisez le ^ opérateur, derrière les rideaux de la méthode __xor__ est appelé.

a^b est équivalent à a.__xor__(b).

Aussi, a ^= b est équivalent à a = a.__ixor__(b) (où __xor__ est utilisé comme une solution de repli lorsque __ixor__ est implicitement appelée via l'aide de ^= mais n'existe pas).

En principe, ce __xor__ n'est complètement jusqu'à sa mise en œuvre. Cas d'utilisation courante en Python sont:
- Symétrique Différence de jeux (tous les éléments présents dans exactement un des deux ensembles)
Démo:
```
>>> a = {1, 2, 3}
>>> b = {1, 4, 5}
>>> a^b
{2, 3, 4, 5}
>>> a.symmetric_difference(b)
{2, 3, 4, 5}
```
- Bit à bit de Non-Égalité de pour les bits de deux entiers
Démo:
```
>>> a = 5
>>> b = 6
>>> a^b
3
```
Explication:
```
    101 (5 decimal)
XOR 110 (6 decimal)
-------------------
    011 (3 decimal)
```
InformationsquelleAutor timgeb

Vous devez vous connecter pour publier un commentaire.