Introduction à la surcharge des opérateurs Python

Introduction à la surcharge des opérateurs Python

La surcharge d'opérateurs permet aux programmeurs de redéfinir les opérateurs existants afin qu'ils puissent être appliqués à des types et classes de données personnalisés. Dans la documentation officielle de Python, la surcharge d'opérateurs est généralement appelée « Émulation de types numériques » ou « Émulation de types de conteneurs ». Sa signification est de permettre aux objets de classe définis par l'utilisateur de simuler le comportement de types numériques ou de types de conteneurs via des méthodes spéciales (add, mul, __getitem__, etc.). https://docs.python.org/3/reference/datamodel.html#emulated-numeric-types

En Python, la surcharge d'opérateurs peut être obtenue en définissant des méthodes spéciales dans une classe personnalisée. La surcharge des opérateurs est également appelée surcharge des opérateurs. La surcharge d'opérateurs fait référence à la définition de méthodes spécifiques afin que les objets personnalisés puissent utiliser des opérateurs intégrés pour effectuer des opérations. Grâce à la surcharge des opérateurs, vous pouvez définir différentes règles de fonctionnement pour différents types d'objets, rendant ainsi les opérations entre objets plus flexibles et intuitives.

En Python, la surcharge d'opérateurs est implémentée à l'aide de méthodes spéciales (également appelées méthodes magiques ou méthodes de double soulignement). Les noms de ces méthodes spéciales sont prédéfinis, commencent et se terminent par un double trait de soulignement, et correspondent à l'opérateur correspondant (par exemple, la méthode spéciale pour l'opération d'addition est __add__())

Par exemple, la méthode add() peut être définie pour surcharger l'opérateur "+". Lorsque l'instance correspondante effectue une opération d'ajout, Python appellera automatiquement la méthode __add__() pour effectuer son comportement personnalisé. De même, des méthodes telles que sub(), mul() et __div__() peuvent également être utilisées pour surcharger d'autres opérateurs.

Voici un exemple de code source pour surcharger l'opérateur « + » afin d'implémenter l'addition vectorielle :

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2

print(v3.x, v3.y) # 输出：4 6

La fonction de ce code est de créer une classe personnalisée nommée Vector pour représenter un vecteur bidimensionnel. Cette classe surcharge la méthode __add__ - surchargeant l'opérateur "+", permettant l'ajout de deux instances du type Vector. Lorsque vous essayez d'ajouter deux objets vectoriels, Python appelle automatiquement la méthode __add__, ajoutant ainsi les vecteurs.

À titre de comparaison, ce qui suit utilise C++ ou Java pour implémenter le code source de surcharge de l'opérateur "+" pour implémenter l'addition vectorielle.

★Utilisez C++ pour implémenter l'opérateur "+" surchargé pour implémenter l'addition de vecteurs :

#include <iostream>
using namespace std;
 
class Vector {  
public:  
    Vector(int x, int y) : x(x), y(y) {}

    Vector operator+(const Vector& other) const {  
        return Vector(x + other.x, y + other.y);  
    }

    int getX() const {  
        return x;  
    }

    int getY() const {  
        return y;  
    }

private:  
    int x;  
    int y;  
};

int main() {  
    Vector v1(1, 2);  
    Vector v2(3, 4);  
    Vector v3 = v1 + v2;

    cout << v3.getX() << " " << v3.getY() << endl; // 输出：4 6  
    return 0;  
}

★Utilisez Java pour implémenter l'opérateur "+" surchargé afin d'implémenter l'addition de vecteurs :

public class Vector {  
    private int x;  
    private int y;

    public Vector(int x, int y) {  
        this.x = x;  
        this.y = y;  
    }

    public Vector add(Vector other) {  
        return new Vector(x + other.x, y + other.y);  
    }

    public int getX() {  
        return x;  
    }

    public int getY() {  
        return y;  
    }

    public static void main(String[] args) {  
        Vector v1 = new Vector(1, 2);  
        Vector v2 = new Vector(3, 4);  
        Vector v3 = v1.add(v2);

        System.out.println(v3.getX() + " " + v3.getY()); // 输出：4 6  
    }  
}

D'ACCORD!