Je prends mon premier cours de sciences informatiques et je viens d'apprendre à la mise en œuvre de la classe et à l'héritage. En particulier, nous venons de couvrir la méthode de remplacement et de la manière dont nous définissons les classes hériter de la superclasse code> code> par défaut. En tant que l'un de mes exemples, essayez ce cas particulier d'héritage, j'ai utilisé le code suivant: Je m'attendais au résultat de Alors mes questions: je pensais (x == y) code>, car Comme je le comprends, la valeur par défaut pour
__ eq __ () code> est de vérifier si ce sont les mêmes objets ou non, ne vous inquiétez pas du contenu. Qui est
false code>,
x code> et
y code> avoir le même contenu mais sont des objets différents. Le second m'a surpris cependant. P>
(x == y) code> et
x. __ eq __ (y) code> était synonyme et fait exactement le même appel. Pourquoi celles-ci produisent-elles une sortie différente? Et pourquoi le deuxième retour conditionnel
notimplementé code>? P> p>
3 Réponses :
Si vous avez implémenté la fonction __ __ __ __ __ () code> fonction pour une classe, elle est appelée lorsque vous utilisez
x == y code>. Sinon
x == y code> s'appuie sur une logique de comparaison par défaut.
__ eq __ () code> n'est pas mis en œuvre automatiquement lorsque vous définissez une classe. P>
En fait (si vous utilisez Python 3, ou des classes de style neuf dans Python 2), est i> un __ eq __ __ code> que vous obtenez gratuitement - celui que vous héritez de < Code> Object code>. Avec des classes de style ancien, si vous ne définissez pas
__ eq __ code>, vous n'obtirez jamais
notimplementé code> de celui-ci comme dans la question - vous obtiendrez un attributError.
L'opérateur Donc, en un mot, votre confusion découle de cette hypothèse, ce qui est incorrect: p>
Je pensais (x == y) et x .__ eq __ (y) étaient synonymes et ont fait exactement le même appel p>
blockQuote>
En fait, == code> est équivalent à la fonction code> eq code>, qui appellera à l'intérieur de l'intérieur le
__ eq __ code> méthode de l'opérande gauche s'il existe Essayez de déterminer l'égalité. Ce n'est pas le seul em> chose que cela va faire, et si
__ eq __ code> n'existe pas, comme c'est le cas ici, il effectuera d'autres chèques, tels que la vérification de la vérification si les deux sont les deux. le même objet, ou
__ cmP __ code> pré-python 3. P>
(x == y) code> et
opérateurs.eq (x, y) code> est synonyme, et
x .__ eq __ (y) code> est l'une des choses
eq (x, y) code> va essayer de vérifier. p>
Le Ceci peut être plus utile que de soulever une exception, car il permet à Python de revenir à d'autres options pour résoudre l'utilisation de l'opérateur. Par exemple, si vous faites Dans le cas, vous vous demandez, notaimplemented code> valeur
Vous voyez renvoyé de votre hérité __ eq __ code> est une valeur intégrée spéciale utilisée comme sentinelle à Python. Il peut être renvoyé par
__ magique __ code> Méthodes qui implémentent des opérateurs de mathématiques ou de comparaison pour indiquer que la classe ne prend pas en charge l'opérateur qui a été tenté (avec les arguments fournis). P>
x + y code>, Python essaiera d'abord d'exécuter
x .__ ajouter __ (y) code>. Si cela retourne
notimplementé code>, essayez la version "Reverse",
y .__ radd __ (x) code>, qui peut fonctionner si
y code> est un type plus sophistiqué que
x code> est. p>
x == y code>, Python essaie d'abord
x .__ eq __ (y) code>, puis
y .__ eq __ (x ) code>, et enfin
x est Y code> (qui sera toujours évalué à une valeur booléenne). Étant donné que
objet .__ eq __ code> renvoie
notamplemented code> Dans tous les cas, votre classe redevient à la comparaison d'identité lorsque vous utilisez l'opérateur réel, mais vous indique le
notamplemented code > Sentinel lorsque vous appelez
__ eq __ code> directement. p>