Comme la classe est également un objet de type, un objet de classe est-il créé lorsque le code ci-dessus est exécuté?

Oui c'est correct.

En fait class mot class clé de class provoque la création d'une instance du type de type . La même chose se produit pour le mot-clé def . Cela provoque la création d'une instance du type Function .

import types

class A:
    pass


def fn():
    pass

print(isinstance(fn, types.FunctionType))
print(isinstance(A, type))

"A" est maintenant une instance du type "type". "fn" est une instance du type "Function".

Lorsqu'une définition de classe (de ClassA , par exemple) est exécutée pour la première fois:

• Un objet type est créé pour contenir la définition de classe.
• Un nom ClassA est introduit dans l'espace de noms actuel (selon l'emplacement de la définition de classe). Le nom pointe vers ce nouvel objet de type .

Notez que dans ce qui précède, "exécuter une définition de classe" n'est pas la même chose que exécuter l'une des fonctions définies dans la portée de cette classe. Quand nous disons qu'une "définition de classe est en cours d'exécution", cela signifie simplement que l'interpréteur essaie de comprendre en quoi consiste la classe (ses membres, ses attributs, etc.). Pendant ce temps, aucune des fonctions de la classe ne sera exécutée elle-même - pas même __init__()

Manifestation:

(pour démontrer quand exactement l'objet de classe est créé, et ce qui se passe en conséquence)

module_a.py:

Before import, len(my_globals) is: 5
Before import, ClassA doesn't exist in globals of mod_b  <-- print() in mod_b before import
Global print() from mod_a                                <-- print() in mod_a during import
Class-level print from ClassA                            <-- print() in mod_a during import
After import, len(my_globals) is: 6
After import, name 'ClassA' exists                       <-- print() in mod_b after import
type(ClassA) is: <class 'type'>                          <-- print() in mod_b after import
Inside ClassA.__init__()                                 <-- print() triggered by ClassB(), from __init__() of ClassA

module_b.py:

ClassB = ClassA  # The name ClassB is now an alias for the same type object
                 # that the name ClassA points to
ClassB()

print (f "Après l'importation, len (my_globals) est: {len (my_globals)}") si "ClassA" n'est pas dans mes_globals: print ("Après l'importation, ClassA n'existe pas dans les globals") else: print ("After import, le nom 'ClassA' existe ") print (f" type (ClassA) is: {type (ClassA)} ")

my_globals = globals()
print (f"Before import, len(my_globals) is: {len(my_globals)}")
if "ClassA" not in my_globals:
    print ("Before import, ClassA doesn't exist in globals of mod_b")
else:
    print (type(ClassA))

from mod_a import *

my_globals = globals()

Sortie (lors de l'exécution de mod_b.py ):

print ("Global print() from mod_a")

class ClassA:
    print ("Class-level print from ClassA")
    
    def __init__(self):
        print ("Inside ClassA.__init__()")

Remarques sur la sortie ci-dessus:

À partir de la sortie ci-dessus, nous pouvons voir que:

1. Le nom ClassA n'existe pas dans l'espace de noms global de mod_b tant que l'instruction from mod_a import * n'est pas exécutée dans mod_b .
2. Après l'exécution de l'instruction d' import , le nom ClassA existe dans l'espace de noms global de mod_b , et pointe vers un objet de type type .
3. Après l'instruction d'affectation ClassB = ClassA , les noms ClassA et ClassB font tous deux référence au même objet.
4. A partir de là, il n'y a rien de "spécial" ou "original" dans le nom ClassA - nous pourrions utiliser le nom ClassB pour faire l'instanciation, au lieu d'utiliser le nom ClassA .
5. En faisant un del ClassA , nous pourrions même rendre le nom ClassA indéfini dans l'espace de noms global de mod_b , et continuer à utiliser le nom d'alias ClassB (mais je n'ai pas inclus ce dernier bit dans la démonstration ci-dessus)

Référence documentaire:

Quelques extraits pertinents dumodèle d'exécution Python :

1. Un programme Python est construit à partir de blocs de code. Un bloc est un morceau de texte de programme Python qui est exécuté en tant qu'unité. Les blocs suivants sont des blocs: un module, un corps de fonction et une définition de classe .
2. Les noms font référence à des objets. Les noms sont introduits par des opérations de liaison de noms.
3. Les constructions suivantes lient les noms: paramètres formels aux fonctions, instructions d'importation, définitions de classe et de fonction (celles-ci lient le nom de classe ou de fonction dans le bloc de définition)
4. Si un nom est lié au niveau du module, il s'agit d'une variable globale.

Oui, la class est une instruction exécutable qui définit un objet.

>>> class Cls:
...     print("This is executed as part of the `class` statement")
...
This is executed as part of `class` statement
>>> isinstance(Cls, object)
True

Référence du langage Python: définitions de classe

Une définition de classe définit un objet de classe [...]
Une définition de classe est une instruction exécutable.

Notez que techniquement, l'instruction de class n'est pas requise pour créer un objet - la métaclasse peut renvoyer un objet existant. Les métaclasses intégrées, de type plus visible, créent de nouveaux objets pour chaque class .