Instancier une classe dont le nom est contenu dans une String

Bonjour,


Je veux instancier une classe dont je ne connais pas le nom à l'avance. Il sera dans une String lors de l'execution du programme.

Idéalement, je voudrais avoir un fichier de config qui contient des noms de classes, par exemple

Code:

---

1 2 3

[maSection] actions = monPackage.Classe1 action2 = Classe2

---

Et dans mon code, je voudrais pouvoir instancier ma classe selon ce paramètre. Exemple :

Code:

---

1 2	action = ConfigReader.get(maSection, actions) monInstance = [fonction/action/astuce](action)(paramInstance)

---

Je sais qu'il est possible d'instancier un module dynamiquement avec __import__, par exemple

Code:

---

monModule = __import__(actions)

---

Mais je n'ai pas réussi à instancier la classe sans faire de test sur son nom.

Une idée ?

Stéphane

http://python.developpez.com/faq/?pa...es#GenStrDecla

Merci mais malheureusement cela ne fournit pas la réponse à mon problème !
Je ne veux pas déclarer un nouvel attribut ou une nouvelle fonction, mais instancier une nouvelle classe ...

Quelque chose comme :

Code:

---

1 2	maClasse = "ActionsPackage.ClasseAction1" monInstance = __import__(maClasse).__init__()

---

Malheureusement ce code ne marche pas car __import__ ne permet d'importer que des modules et non des classes.

Merci quand même.

Admettons que j'ai une arborescence du style suivant:

Code:

---

1 2 3 4 5

Dossier : mypackage File : __init__.py File : module.py File : test.py

---

avec __init__.py vide et module.py contenant :

Code:

---

1 2 3 4

class Test(): def my_print(self, str): print str

---

Le fichier test.py est le suivant :

Code:

---

1 2 3 4 5 6 7 8 9

my_package = 'mypackage' my_module = 'module' my_class = 'Test'   package = __import__ (my_package, fromlist=[my_module]) cls = package.__dict__[my_module].__dict__[my_class]()   cls.my_print ("coucou")

---

Est ce que ça réponds à la question ?

Bonjour,

Code:

---

1 2 3

[maSection] action1 = Classe1 action2 = Classe2

---

Code:

---

1 2 3 4 5

import monModule action = ConfigReader.get('maSection', 'action1') monInstance = getattr(monModule,action) monInstance()

---

Salut,

Je préfère la solution de pierjean qui me parait la plus propre.

Citation:

---

Envoyé par yacinechaouche

Salut,

Je préfère la solution de pierjean qui me parait la plus propre.

---

Le but de la réponse n'étais pas de faire la solution la plus propre mais de montrer jusqu'ou on pouvait aller, encore que j'aurais pu passer aussi en string le nom de la méthode à appeler.

Salut,

DelphiManiac, tu utilises des attributs qui sont sensés être cachés de l'utilisateur (__dict__). Des fonctions telles que getattr et hasattr utilisent pour nous ces attributs cachés pour que l'inspection des objets soit tâche facile pour nous. Alors, autant les utiliser :)

Il est vrai que dans ce contexte utilisé getattr est surement plus approprié.

Concernant les identifiants préfixé de 2 '_', ce sont des éléments pseudo privés. Par ailleurs, il est des fois nécessaire de les utiliser comme dans __import__ pour faire un import dynamique.

L'usage de __dict__ est plus souvent réservé à l'introspection vu que l'on est pas censé connaitre les éléments que l'on recherche.

Personnellement et dans le contexte de la question, je préfère utiliser __dict__ qui me parait plus "lisible" que la syntaxe équivalente avec getattr : cls = getattr(getattr(package, my_module), my_class)()

Mais c'est un choix bien personnel ;)

En fait, __dict__ tient du détail d'implementation, il y a quelques différences entre faire a.__dict__[x] et getattr(a,x):

• __dict__ n'existe pas pour les classes qui ont des __slots__
• __dict__ ne retourne pas les méthodes et d'une manière générale ce qui dépend de la classe, par exemple les attributs de classes
• getattr peut appeler __getattr__ et __getattribute__

Par exemple:

Code:

---

1 2 3 4 5 6 7 8

>>> class g: ... toto=1 ... >>> g.toto,g().toto,getattr(g(),'toto') (1, 1, 1) >>> g().__dict__ {}

---

Citation:

---

Envoyé par Fructidor

• __dict__ n'existe pas pour les classes qui ont des __slots__
• __dict__ ne retourne pas les méthodes et d'une manière générale ce qui dépend de la classe, par exemple les attributs de classes
• getattr peut appeler __getattr__ et __getattribute__

---

Pour éviter les confusions :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class spam: __slots__ = ["egg"] egg = 1 def ham(self): print egg def __init__(self): self.jam = 0   print spam.__dict__ print spam().__dict__

---

imprime

Code:

---

1 2 3

'__module__': '__main__', 'ham': <function ham at 0xb7dc548c>, '__slots__': ['egg'], 'egg': 1, '__doc__': None, '__init__': <function __init__ at 0xb7dc541c>} {'jam': 0}

---

Donc :

• __dict__ contient ce qui est dans la classe, si on l'appelle sur la classe
• __dict__ contient les méthodes de la classe, si on l'appelle sur la classe
• On peut accéder au dictionnaire de la classe à partir de son instance en faisant

Code:

---

1 2	print spam().__class__.__dict__

---

Pour ce qui concerne les __slots__, que je ne connais pas très bien, il s'avère que le code que j'ai essayé a bien affiché le dictionnaire de l'instance, même si la classe contient bien un __slots__. Peux-tu nous en dire plus sur ce point ?


Merci.

Réponse dans les tutoiels : http://python.developpez.com/cours/D...mic_import.php

Merci pour ces réponses, c'est tout simplement magnifique :-)

J'ai utilisé un peu des deux réponses, car j'ai mis dans mon fichier de config

Code:

---

1 2	[section] action = Production.Extractors.OracleExtractor

---

où OracleExtractor est la classe à instancier

Mon arborescence est la suivante :

Code:

---

1 2 3 4

Dossier : Production/Extraction File : __init__.py File : Oracle.py File : test.py

---

- Oracle.py contient la classe OracleExtractor()
- __init__.py qui contient

Code:

---

from Oracle import OracleExtractor

---

ce qui me permet d'instancier ma classe de façon jolie comme from Production.Extractors import OracleExtractor




Ca marche en faisant

Code:

---

1 2 3 4 5 6 7 8 9 10

package = "Production.Extractors" module = "Extractors" maclass = "OracleExtractor"   module = __import__(package, fromlist=[module]) maclass = module.getattr(maclass )   extractor = maclass () extractor.launch() ...

---

J'ai écris une petite procédure (y'a sûrement mieux mais au moins ça fait le taf pour moi)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

maclass = getClassFromString("Production.Extractors.OracleExtractor") extractor = maclass () extractor.launch() ...   def getClassFromString(absoluteClass): l = absoluteClass.split('.')   packageName = "" for i in range(len(l)-1): packageName = packageName + l[i] + "."   packageName = packageName[:-1] moduleName = l[i] className = l[i+1]   module = __import__(packageName, fromlist=[moduleName])   return getattr(module, className)

---

Je suis donc assez content, puisque ça marche.
Mais néanmoins j'ai l'impression de passer à côté de quelque chose à propos des __init__.py des différents modules/packages puisque j'aurais plutôt vu :

Code:

---

1 2	module = __import__("Production.Extractors") maclass = getattr(module, "OracleExtractor")

---

Mais :

Code:

---

1 2	print module <module 'Production' from 'D:\eclipse workspace\APPLICATION\bin\Production\__init__.pyc'>

---

En espérant n'avoir pas été trop long ni confut.

En tout cas merci pour vos réponses !!
Stéphane

C'est pour ça que j'ai donné le lien dans mon précédent message, tout y est expliqué.

Bonjour,

je reviens rapidement sur le post de yacinechaouche:

Citation:

---

Envoyé par yacinechaouche

Pour éviter les confusions :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class spam: __slots__ = ["egg"] egg = 1 def ham(self): print egg def __init__(self): self.jam = 0   print spam.__dict__ print spam().__dict__

---

---

pour que __slots__ fonctionne, il faut que la classe dérive d'object ("new-style class"). Je ne l'utilise pas couramment (en fait, jamais). L'idée est d'optimiser les resources en évitant le passage par une map, notamment en cas de création de nombreuses instances. Avec cette modification, on a:

Code:

---

1 2 3 4 5

class spam(object): ... >>> spam() AttributeError: 'spam' object has no attribute 'jam'

---

l'initialisation a raté car la création de l'attribut jam a échoué (il ne fait pas partie de la liste __slots__)

Citation:

---

• __dict__ contient ce qui est dans la classe, si on l'appelle sur la classe
• __dict__ contient les méthodes de la classe, si on l'appelle sur la classe

---

oui, mais uniquement les méthodes et attributs de la classe elle-même, et notamment pas les méthodes héritées:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

>>> class a: ... def toto(self):pass ... >>> class b(a): ... def titi(self):pass ... >>> getattr(b,'toto') <unbound method b.toto> >>> b.__dict__['toto'] KeyError: 'toto'

---

Citation:

---

• On peut accéder au dictionnaire de la classe à partir de son instance en faisant

Code:

---

1 2	print spam().__class__.__dict__

---

---

A nouveau, on va avoir le problème de l'héritage. Donc si on veut seulement les attribut de la classe, sans les super classes, OK. Si on veut tous les attributs auxquels l'instance et la classe vont avoir accès, il faut utiliser dir() qui en sous-main va inspecter tous les __dicts__ et les __slots__.

Code:

---

1 2 3 4 5 6

>>> b.__dict__ {'__module__': '__main__', 'titi': <function titi at 0x00AE9330>, '__doc__': Non e} >>> dir(b) ['__doc__', '__module__', 'titi', 'toto']

---

Mon point de vue, c'est bien sûr qu'on peut utiliser __dict__, et dans de nombreux cas cela aura les résultats que tu présentes, mais qu'il faut garder à l'esprit qu'il ne va remonter que les attributs "propres" de l'instance ou de la classe.
getattr et dir, d'un autre coté, sont des protocoles qui permettent d'accéder aux attributs et méthodes en faisant abstraction de l'implémentation de la classe, du fait qu'elle soit dérivée ou new-style, etc.

Merci pour cette explication très détaillée et instructive ! notamment pour les slots que je n'ai jamais utilisé moi non plus. Je ne vois pas encore l'intérêt d'interdire l'ajout d'attributs supplémentaires à une instance de classe. Ce qui m'avait séduit très tôt chez python c'est que, tout comme chez smalltalk, on peut bidouiller un objet même après sa création, lui ajouter des attributs ou les changer etc. Allez faire ça en Java ou en C++...

Effectivement __dict__ ne contient que ce qui est dans le namespace de l'objet qu'on inspecte, qu'il soit instance, classe, type ou autre. getattr et dir sont donc plus puissants puisqu'ils vont chercher les attributs hérités.