Utilisez type() pour créer dynamiquement des classes

Étant donné que les classes sont également des objets, nous pouvons créer des classes pendant l'exécution du programme. Python est un langage dynamique. La plus grande différence entre les langages dynamiques et les langages statiques est que les définitions des fonctions et des classes ne sont pas définies au moment de la compilation, mais créées dynamiquement au moment de l'exécution. Avant, nous comprenons d’abord la fonction type().

Nous créons d'abord un nouveau module hello.py, puis définissons une classe Hello,

class Hello(object):
    def hello(self, name='Py'):
        print('Hello,', name)

Puis référençons le module hello dans un autre module et générons les informations correspondantes. La fonction type() est utilisée pour afficher le type d'un type et d'une variable.

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
from com.twowater.hello import Hello
h = Hello()
h.hello()
print(type(Hello))
print(type(h))

Quel est le résultat de sortie ?

Hello, Py
<class 'type'>
<class 'com.twowater.hello.Hello'>

Comme mentionné ci-dessus, la fonction type() peut vérifier le type d'un type ou d'une variable. Hello est une classe, son type est type, et h est une instance, son type est com.twowater.hello.Hello . Le com.twowater précédent est le nom de mon package, et le module hello se trouve sous ce nom de package.

Réfléchissez-y davantage ici. Dans l'exemple ci-dessus, nous utilisons la fonction type() pour vérifier le type d'un type ou d'une variable. Le type d'une classe Hello est vérifié et le résultat imprimé est : <class 'type'> En fait, la fonction type() peut non seulement renvoyer le type d’un objet, mais également créer de nouveaux types. La définition de la classe est créée dynamiquement au moment de l'exécution, et la façon de créer une classe consiste à utiliser la fonction type(). Par exemple, nous pouvons créer la classe Hello dans l'exemple ci-dessus via la fonction type(). Voir le code suivant pour plus de détails :

# -*- coding: UTF-8 -*-
def printHello(self, name='Py'):
    # 定义一个打印 Hello 的函数
    print('Hello,', name)
# 创建一个 Hello 类
Hello = type('Hello', (object,), dict(hello=printHello))
# 实例化 Hello 类
h = Hello()
# 调用 Hello 类的方法
h.hello()
# 查看 Hello class 的类型
print(type(Hello))
# 查看实例 h 的类型
print(type(h))

Le résultat de sortie est le suivant :

Hello, Py
<class 'type'>
<class '__main__.Hello'>

Ici, nous devons d'abord comprendre comment créer un objet de classe via la fonction type(). Description du paramètre :

1. Le nom de la classe, comme Hello dans l'exemple 2. La collection de classes parent héritées ne prend en charge que l'héritage multiple. une classe parent, le tuple doit être écrit dans un seul élément ; dans l'exemple Hériter de la classe d'objet, car il s'agit d'un tuple à un seul élément, il est donc écrit comme (object,)

3. est lié à la fonction ; dans l'exemple, la fonction printHello est liée au nom de la méthode hello

Le modèle spécifique est le suivant :

type (nom de la classe, tuple de la classe parent (peut être vide pour l'héritage), dictionnaire contenant attributs (nom et valeur))

D'accord, après avoir compris l'utilisation spécifique des paramètres, jetons un coup d'œil au résultat. En conséquence, vous pouvez voir que la classe créée via la fonction type() est exactement la même que l'écriture de la classe directement, car lorsque l'interpréteur Python rencontre la définition de classe, il analyse simplement la syntaxe de la définition de classe, puis appelle la fonction type() pour créer une classe hors classe.

Mais généralement, nous utilisons la méthode class ***... pour définir des classes, mais la fonction type() nous permet également de créer des classes. En d’autres termes, un langage dynamique lui-même prend en charge la création dynamique de classes lors de l’exécution, ce qui est très différent d’un langage statique. Pour créer une classe lors de l’exécution d’un langage statique, vous devez construire une chaîne de code source puis appeler le compilateur. , ou utilisez certains outils pour générer un mot. L'implémentation du code de section est essentiellement une compilation dynamique, ce qui peut être très compliqué.

Vous pouvez voir qu'en Python, les classes sont aussi des objets et que vous pouvez créer des classes de manière dynamique. En fait, c'est ce que Python fait en coulisse lorsque vous utilisez la classe de mots-clés, et cela est réalisé grâce aux métaclasses.