Définition de classe dynamique en Python

La définition d'objet dynamique peut être comprise comme une définition au moment de l'exécution. Contrairement à une définition statique, qui est utilisée dans la définition de mot-clé familière d'une classe class, une définition dynamique utilise une classe en ligne type.

Type de métaclasse

La classe de type est souvent utilisée pour obtenir le type d'un objet. Par exemple comme ceci:

h = "hello"
type(h)
<class 'str'>

Mais il a d'autres utilisations. Il peut initialiser de nouveaux types.Comme vous le savez, tout en Python est un objet. Il s'ensuit que toutes les définitions ont des types, y compris des classes et des objets. Par exemple:

class A:
    pass
type(A)
<class 'type'>

Il peut ne pas être tout à fait clair pourquoi une classe se voit attribuer un type de classe type, par opposition à ses instances:

a = A()
type(a)
<class '__main__.A'>

L'objet areçoit une classe en tant que type. C'est ainsi que l'interpréteur traite l'objet comme une instance de la classe. La classe elle-même a un type de classe typecar elle l'hérite de la classe de base object:

A.__bases__
(<class 'object'>,)

Type de classe object:

type(object)
<class 'type'>

La classe est objecthéritée par toutes les classes par défaut, c'est-à-dire:

class A(object):
    pass

Pareil que:

class A:
    pass

La classe en cours de définition hérite de la classe de base en tant que type. Cependant, cela n'explique pas pourquoi la classe de base objectest du type classe type. Le fait est que c'est typeune métaclasse. Comme vous le savez déjà, toutes les classes héritent de la classe de base object, qui est de type métaclasse type. Par conséquent, toutes les classes ont également ce type, y compris la métaclasse elle type- même :

type(type)
<class 'type'>

C'est le "point final de la saisie" en Python. La chaîne d'héritage de type est fermée sur la classe type. La métaclasse typesert de base à toutes les classes en Python. Il est facile de vérifier ceci:

builtins = [list, dict, tuple]
for obj in builtins:
    type(obj)
<class 'type'>
<class 'type'>
<class 'type'>

Une classe est un type de données abstrait et ses instances ont une référence de classe comme type.

Initialisation de nouveaux types avec la classe de type

Lors de la vérification des types, la classe est typeinitialisée avec un seul argument:

type(object) -> type

Ce faisant, il renvoie le type de l'objet. Cependant, la classe implémente une méthode d'initialisation différente avec trois arguments, qui retourne un nouveau type:

type(name, bases, dict) -> new type

Paramètres d'initialisation de type

• name
  
  Une chaîne qui définit le nom de la nouvelle classe (type).
• bases
  
  Un tuple de classes de base (classes dont la nouvelle classe héritera).
• dict
  
  Dictionnaire avec les attributs de la future classe. Habituellement avec des chaînes dans les clés et des types appelables dans les valeurs.

Définition de classe dynamique

Nous initialisons la classe du nouveau type, en fournissant tous les arguments nécessaires et l'appelons:

MyClass = type("MyClass", (object, ), dict())
MyClass
<class '__main__.MyClass'>

Vous pouvez travailler avec la nouvelle classe comme d'habitude:

m = MyClass()
m
<__main__.MyClass object at 0x7f8b1d69acc0>

De plus, la méthode est équivalente à la définition de classe habituelle:

class MyClass:
    pass

Définition dynamique des attributs de classe

Il y a peu d'intérêt dans une classe vide, alors la question se pose: comment ajouter des attributs et des méthodes?



Pour répondre à cette question, considérez le code d'initialisation initial:

MyClass = type(“MyClass”, (object, ), dict())

En règle générale, les attributs sont ajoutés à la classe lors de la phase d'initialisation en tant que troisième argument - le dictionnaire. Vous pouvez spécifier des noms et des valeurs d'attribut dans le dictionnaire. Par exemple, cela pourrait être une variable:

MyClass = type(“MyClass”, (object, ), dict(foo=“bar”)
m = MyClass()
m.foo
'bar'

Définition de méthode dynamique

Les objets appelables peuvent également être passés au dictionnaire, par exemple, les méthodes:

def foo(self):
    return “bar”
MyClass = type(“MyClass”, (object, ), dict(foo=foo))
m = MyClass()
m.foo
'bar'

Cette méthode a un inconvénient important - la nécessité de définir la méthode de manière statique (je pense que dans le contexte des tâches de métaprogrammation, cela peut être considéré comme un inconvénient). De plus, la définition d'une méthode avec un paramètre en selfdehors du corps de la classe semble étrange. Par conséquent, revenons à l'initialisation dynamique d'une classe sans attributs:

MyClass = type(“MyClass”, (object, ), dict())

Après avoir initialisé une classe vide, vous pouvez y ajouter des méthodes de manière dynamique, c'est-à-dire sans définition statique explicite:

code = compile('def foo(self): print(“bar”)', "<string>", "exec")

compileEst une fonction intégrée qui compile le code source dans un objet. Le code peut être exécuté par des fonctions exec()ou eval().

Compiler les paramètres de fonction

• source
  
  Le code source, peut être un lien vers un module.
• filename
  
  Le nom du fichier dans lequel l'objet sera compilé.
• mode
  
  Si spécifié "exec", la fonction compilera le code source dans un module.

Le résultat du travail compileest un objet de classe code:

type(code)
<class 'code'>

L'objet codedoit être converti en méthode. Puisqu'une méthode est une fonction, nous commençons par convertir un codeobjet de classe en objet de classe function. Pour ce faire, importez le module types:

from types import FunctionType, MethodType

Je vais l'importer MethodTypecar j'en aurai besoin plus tard pour convertir la fonction en méthode de classe.

function = FunctionType(code.co_consts[0], globals(), “foo”)

Paramètres de la méthode d'initialisation FunctionType

• code
  
  Objet de classe code. code.co_consts[0]Est un appel à un descripteur de co_constsclasse code, qui est un tuple avec des constantes dans le code de l'objet. Imaginez un objet codecomme un module avec une seule fonction que nous essayons d'ajouter comme méthode de classe. 0Est son index, puisque c'est la seule constante du module.
• globals()
  
  Dictionnaire des variables globales.
• name
  
  Paramètre facultatif spécifiant le nom de la fonction.

Le résultat est une fonction:

function
<function foo at 0x7fc79cb5ed90>
type(function)
<class 'function'>

Ensuite, vous devez ajouter cette fonction en tant que méthode de classe MyClass:

MyClass.foo = MethodType(function, MyClass)

Une expression assez simple qui assigne notre fonction à une méthode de classe MyClass.

m = MyClass()
m.foo()
bar

avertissement

Dans 99% des cas, vous pouvez vous en tirer avec des définitions de classe statiques. Cependant, le concept de métaprogrammation est bon pour révéler les éléments internes de Python. Très probablement, il vous sera difficile de trouver l'application des méthodes décrites ici, bien que dans ma pratique, il y ait eu un tel cas.



Avez-vous travaillé avec des objets dynamiques? Peut-être dans d'autres langues?

Liens

• Publication avancée sur Medium.