Introduction aux méthodes Dunder en Python

Ce court article est consacré aux méthodes dunder de Python, également appelées méthodes magiques.

Qu'est-ce que les méthodes Dunder?

Les méthodes Dunder sont des méthodes spéciales en Python qui commencent et se terminent par deux traits de soulignement (__). Elles vous permettent de définir le comportement de vos objets pour les opérations intégrées, telles que l'addition, la soustraction, la représentation sous forme de chaîne, etc.

Parmi les méthodes dunder courantes, on peut citer:

• __init__(self, ...): Appelé lorsqu'un objet est créé.
  • Comme notre méthode %OnNew dans ObjectScript.
• __str__(self): Appelée par la fonction intégrée str() et print pour représenter l'objet sous forme de chaîne.
• __repr__(self): Appelée par la fonction intégrée repr() pour représenter l'objet à des fins de débogage.
• __add__(self, other): Appelée lorsque l'opérateur + est utilisé.
• __len__(self): Appelée par la fonction intégrée len() pour renvoyer la longueur de l'objet.
• __getitem__(self, key): Appelée pour récupérer un élément d'une collection à l'aide de la syntaxe d'indiçage.
• __setitem__(self, key, value): Appelée pour définir un élément dans une collection à l'aide de la syntaxe d'indiçage.
• ... et bien d'autres encore.

Pourquoi les méthodes Dunder sont-elles importantes et pertinentes dans le contexte IRIS?

Dans ObjectScript, nous n'avons pas de sucre syntaxique comme en Python, mais nous pouvons obtenir un comportement similaire à l'aide des méthodes dunder.

Exemple : nous avons importé un module Python qui contient une fonction renvoyant une liste Python, et nous souhaitons l'utiliser dans ObjectScript. Nous devons utiliser la méthode dunder __getitem__ pour accéder aux éléments de la liste.

# src/python/article/dunder_example.py
def get_list():
    return [1, 2, 3, 4, 5]

Class Article.DunderExample Extends %RegisteredObject
{

ClassMethod Run()
{
    Set sys = ##class(%SYS.Python).Import("sys")
    do sys.path.append("/irisdev/app/src/python/article")
    set dunderExample = ##class(%SYS.Python).Import("dunder_example")
    set myList = dunderExample."get_list"()
    for i=0:1:myList."__len__"()-1 {
        write myList."__getitem__"(i), !
    }
}

}

Lançons-la:

iris session iris -U IRISAPP '##class(Article.DunderExample).Run()'

Le résultat sera le suivant:

1
2
3
4
5

Cela montre comment utiliser les méthodes dunder pour interagir avec des objets Python dans un contexte IRIS, ce qui vous permet de tirer parti des capacités de Python tout en travaillant dans l'environnement ObjectScript.

Supplément

Une bonne utilisation de dunder consisterait à placer à la fin de votre script Python un bloc if __name__ == " __main__ ": afin d'empêcher l'exécution du code lorsque le script est importé en tant que module.

Rappelez-vous, le premier article expliquait que lorsque vous importiez un script, le code y était exécuté. Ce bloc vous permet de définir du code qui ne doit s'exécuter que lorsque le script est exécuté directement, et non lorsqu'il est importé.

Exemple:

# src/python/article/dunder_example.py
def get_list():
    return [1, 2, 3, 4, 5]

if __name__ == "__main__":
    print(get_list())

Conclusion

Ce que vous pouvez faire en Python, même avec son sucre syntaxique, vous pouvez le faire en ObjectScript avec les méthodes dunder.