Dynamiquement à l'importation d'une méthode dans un fichier, à partir d'une chaîne

J'ai une chaîne de caractères, dire: abc.def.ghi.jkl.myfile.mymethod. Comment puis-je importer dynamiquement mymethod?

Ici est de savoir comment je suis allé à ce sujet:

def get_method_from_file(full_path):
    if len(full_path) == 1:
        return map(__import__,[full_path[0]])[0]
    return getattr(get_method_from_file(full_path[:-1]),full_path[-1])


if __name__=='__main__':
    print get_method_from_file('abc.def.ghi.jkl.myfile.mymethod'.split('.'))

Je me demandais si la importer des modules est nécessaire à tous.

Edit: je suis en utilisant la version de Python 2.6.5.

InformationsquelleAutor Lakshman Prasad | 2012-01-09

89

De Python 2.7 vous pouvez utiliser le importlib.import_module() fonction. Vous pouvez importer un module et d'accéder à un objet défini avec le code suivant:
```
from importlib import import_module

p, m = name.rsplit('.', 1)

mod = import_module(p)
met = getattr(mod, m)

met()
```
- Intéressant de noter que le Python docs vous recommandons d'utiliser importlib.import_module() sur __import__(): docs.python.org/2/library/functions.html#__import__ -- 2,7+.
- import_module + rsplit = Le seul Vrai Chemin.
InformationsquelleAutor frm
28

Vous n'avez pas besoin d'importer des modules individuels. Il suffit d'importer le module que vous souhaitez importer un nom et de fournir les fromlist argument:
```
def import_from(module, name):
    module = __import__(module, fromlist=[name])
    return getattr(module, name)
```
Pour votre exemple abc.def.ghi.jkl.myfile.mymethod, appeler cette fonction en tant que
```
import_from("abc.def.ghi.jkl.myfile", "mymethod")
```
(À noter qu'au niveau du module les fonctions sont appelées fonctions en Python, pas de méthodes.)

Pour une telle tâche simple, il n'y a aucun avantage en utilisant le importlib module.
- import_from() m'a orienté dans la bonne direction. myClass = getattr(__import__("module.to.import", fromlist=["myClassName"]), "myClassName"). Merci pour l'aide!
- Le __import__ approche fonctionne. Mais essayez d'exécuter help(__import__). Il dit: "Parce que cette fonction est destinée à être utilisée par l'interpréteur Python, et non pour un usage général, il est préférable d'utiliser importlib.import_module() de programmation pour importer un module".
- Lorsque j'ai répondu à cette question, Python 2.5 et 2.6 étaient encore largement utilisés. Aujourd'hui, il est certainement préférable d'utiliser importlib à la place.
- Cool, merci. Pourrait être une bonne idée de mettre à jour la réponse à tenir compte de cela.
InformationsquelleAutor Sven Marnach
20

Pour Python < 2.7 le groupe builtin méthode __ import__ peut être utilisé:
```
__import__('abc.def.ghi.jkl.myfile.mymethod', fromlist=[''])
```
Pour Python >= 2.7 ou 3.1 la méthode pratique importlib.import_module a été ajouté. Il suffit d'importer votre module comme ceci:
```
importlib.import_module('abc.def.ghi.jkl.myfile.mymethod')
```
Mise à jour: version mise à Jour en fonction des commentaires (je dois avouer que je n'ai pas lu la chaîne à être importés jusqu'à la fin et j'ai raté le fait qu'une méthode d'un module doit être importée et pas un module lui-même):

Python < 2.7 :
```
mymethod = getattr(__import__("abc.def.ghi.jkl.myfile", fromlist=["mymethod"]))
```
Python >= 2.7:
```
mymethod = getattr(importlib.import_module("abc.def.ghi.jkl.myfile"), "mymethod")
```
- Aucune de ces solutions ne fonctionne pas car le premier paramètre doit être un nom du module dans les deux __import__() et importlib.import_module().
- importlib.import_module('abc.def.ghi.jkl.myfile.mymethod') ne fonctionnera pas parce que vous avez à préciser "ce module d'importation en valeur absolue ou relative" et non pas "qualifié" nom de la méthode.
- Cela ne fonctionne pas, évidemment, que le premier paramètre de import doit être un module, pas une chaîne de caractères.
InformationsquelleAutor gecco
7

Il est difficile de savoir ce que vous essayez de faire de votre espace de noms local. Je suppose que vous voulez juste my_method comme un local, en tapant output = my_method()?
```
# This is equivalent to "from a.b.myfile import my_method"
the_module = importlib.import_module("a.b.myfile")
same_module = __import__("a.b.myfile")
# import_module() and __input__() only return modules
my_method = getattr(the_module, "my_method")

# or, more concisely,
my_method = getattr(__import__("a.b.myfile"), "my_method")
output = my_method()
```
Alors que vous n'ajoutez my_method à l'espace de noms local, vous ne charge de la chaîne de modules. Vous pouvez regarder à des changements en regardant les touches de sys.modules avant et après l'importation. J'espère que c'est plus clair et plus précis que vos autres réponses.

Pour la perfection, c'est de cette façon que vous ajoutez à l'ensemble de la chaîne.
```
# This is equivalent to "import a.b.myfile"
a = __import__("a.b.myfile")
also_a = importlib.import_module("a.b.myfile")
output = a.b.myfile.my_method()

# This is equivalent to "from a.b import myfile"
myfile = __import__("a.b.myfile", fromlist="a.b")
also_myfile = importlib.import_module("a.b.myfile", "a.b")
output = myfile.my_method()
```
Et, enfin, si vous utilisez __import__() et qui ont modifié vous recherchez le chemin d'accès après le début du programme, vous devrez peut-être utiliser __import__(normal args, globals=globals(), locals=locals()). Le pourquoi est un complexe de discussion.
- Votre premier exemple de the_module et same_module est erroné et peut produire des résultats différents. Downvoting.
InformationsquelleAutor Charles Merriam

from importlib import import_module


name = "file.py".strip('.py')
# if Path like : "path/python/file.py" 
# use name.replaces("/",".")

imp = import_module(name)

# get Class From File.py
model = getattr(imp, "naemClassImportFromFile")

NClass = model() # Class From file

InformationsquelleAutor Alaa Akiel

Ce site web a une belle solution: load_class. Je l'utilise comme ceci:

foo = load_class(package.subpackage.FooClass)()
type(foo) # returns FooClass

Comme demandé, voici le code à partir du lien web:

import importlib

def load_class(full_class_string):
    """
    dynamically load a class from a string
    """

    class_data = full_class_string.split(".")
    module_path = ".".join(class_data[:-1])
    class_str = class_data[-1]

    module = importlib.import_module(module_path)
    # Finally, we retrieve the Class
    return getattr(module, class_str)

Veuillez inclure le résumé/code à partir du lien donné. Lien-seulement les réponses ne sont pas grandes, parce qu'elles sont sujettes à la pourriture des liens.

InformationsquelleAutor kingaj

0

La façon dont j'ai tendance à présent (ainsi qu'un certain nombre d'autres bibliothèques, tels que les pylônes et les coller, si ma mémoire est bonne) est de séparer le nom du module à partir de la fonction/le nom de l'attribut à l'aide d'un ':' entre eux. Voir l'exemple suivant:

'abc.def.ghi.jkl.myfile:mymethod'

Cela rend le import_from(path) fonction ci-dessous un peu plus facile à utiliser.
```
def import_from(path):
    """
    Import an attribute, function or class from a module.
    :attr path: A path descriptor in the form of 'pkg.module.submodule:attribute'
    :type path: str
    """
    path_parts = path.split(':')
    if len(path_parts) < 2:
        raise ImportError("path must be in the form of pkg.module.submodule:attribute")
    module = __import__(path_parts[0], fromlist=path_parts[1])
    return getattr(module, path_parts[1])


if __name__=='__main__':
    func = import_from('a.b.c.d.myfile:mymethod')
    func()
```
- Pourquoi devrait anybdoy faire cela? Cela nécessite l'appelant à se joindre nom du module et le nom de l'attribut par une virgule, et la fonction a besoin de diviser à nouveau dans le côlon. Pourquoi ne pas simplement utiliser deux paramètres en premier lieu?
- Souvent, dans une situation où cela est si vous fil des rappels à partir d'un cadre à votre application à l'aide de fichiers de configuration (.yaml, .ini, etc.). Ensuite, vous pouvez spécifier la fonction, le cadre doit d'appel, etc., avec une seule chaîne de caractères dans votre fichier de configuration.
- Eh bien, oui, vous pouvez choisir ce qu'un fichier de configuration de la syntaxe. Mais comment est-ce lié à l'OP de la question? (Et même si j'avais choisi ce que ma config fichier de syntaxe, je préfère l'avoir analysé par mon fichier de configuration de l'analyseur, pas par hasard fonctions de l'API.)
InformationsquelleAutor Kris Hardy

Comment à ce sujet :

def import_module(name):

    mod = __import__(name)
    for s in name.split('.')[1:]:
        mod = getattr(mod, s)
    return mod

InformationsquelleAutor Aymen Alsaadi

-2

Utilisation importlib (2.7+ uniquement).
- J'utilise 2.6.5. Puis-je faire un from __future__ chose?
- Non, __future__ est pour les fonctionnalités de langage, pas de nouvelles stdlib modules.
- Utiliser le buit-dans __import__ comme dans les exemples ci-dessus. Il fonctionne de 2.5 et, sans mots-clés, avant que.
InformationsquelleAutor Daniel Roseman

Vous devez vous connecter pour publier un commentaire.