web-dev-qa-db-fra.com

Est-il possible de lister toutes les fonctions d'un module?

J'ai défini un fichier .py dans ce format:

foo.py

def foo1(): pass
def foo2(): pass
def foo3(): pass

Je l'importe depuis un autre fichier:

main.py

from foo import * 
# or
import foo

Est-il possible de lister tous les noms de fonctions, par ex. ["foo1", "foo2", "foo3"]?

Merci pour votre aide, j'ai fait un cours pour ce que je veux, veuillez commenter si vous avez une suggestion

class GetFuncViaStr(object):
    def __init__(self):
        d = {}
        import foo
        for y in [getattr(foo, x) for x in dir(foo)]:
            if callable(y):
               d[y.__name__] = y
    def __getattr__(self, val) :
        if not val in self.d :
           raise NotImplementedError
        else:
           return d[val]
pythonpython-module
33
user478514

La façon la plus propre de faire ces choses est d'utiliser le module d'inspection. Il a une fonction getmembers qui prend un prédicat comme deuxième argument. Vous pouvez utiliser isfunction comme prédicat.

 import inspect

 all_functions = inspect.getmembers(module, inspect.isfunction)

Maintenant, all_functions sera une liste de tuples où le premier élément est le nom de la fonction et le second élément est la fonction elle-même.

72
aaronasterling

vous pouvez utiliser dir pour explorer un espace de noms.

import foo
print dir(foo)

Exemple: charger votre foo dans Shell

>>> import foo
>>> dir(foo)
['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'foo1', 'foo2', 'foo3']
>>> 
>>> getattr(foo, 'foo1')
<function foo1 at 0x100430410>
>>> k = getattr(foo, 'foo1')
>>> k.__name__
'foo1'
>>> callable(k)
True
>>>

Vous pouvez utiliser getattr pour obtenir l'attribut associé dans foo et savoir s'il peut être appelé.

Vérifiez la documentation: http://docs.python.org/tutorial/modules.html#the-dir-function

et si vous le faites - "from foo import *", alors les noms sont inclus dans l'espace de noms où vous appelez cela.

>>> from foo import *
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'atexit', 'foo1', 'foo2', 'foo3']
>>>

Le brief suivant sur l'introspection dans python pourrait vous aider:

9
pyfunc

Essayez d'utiliser le module d'inspection comme ci-dessous pour exmaple si le module -> temp.py

In [26]: import inspect

In [27]: import temp

In [28]: l1 = [x.__name__ for x in temp.__dict__.values() if inspect.isfunction(x)]

In [29]: print l1
['foo', 'coo']
4
shahjapan

Comme aaronasterling a dit , vous pouvez utiliser les fonctions getmembers du module inspect pour ce faire.

import inspect

name_func_tuples = inspect.getmembers(module, inspect.isfunction)
functions = dict(name_func_tuples)

Cependant, cela inclura des fonctions qui ont été définies ailleurs , mais importées dans l'espace de noms de ce module.

Si vous souhaitez obtenir uniquement les fonctions qui ont été définies dans ce module, utilisez cet extrait:

name_func_tuples = inspect.getmembers(module, inspect.isfunction)
name_func_tuples = [t for t in name_func_tuples if inspect.getmodule(t[1]) == module]
functions = dict(name_func_tuples)
4
Flimm

si vous souhaitez répertorier les fonctions du module actuel (c'est-à-dire non importé), vous pouvez également faire quelque chose comme ceci:

import sys
def func1(): pass
def func2(): pass

if __name__ == '__main__':
    print dir(sys.modules[__name__])
2
verboze

Pour une importation sauvage

from foo import * 
print dir()

vous pouvez utiliser dir() sans paramètre pour afficher les objets dans l'espace de noms du module actuel. Cela inclura très probablement plus que le contenu de foo.

En cas d'importation absolue (que vous préférez d'ailleurs) vous pouvez passer le module à dir():

import foo
print dir(foo)

Vérifiez également la documentation de dir . Comme vous ne vouliez que des fonctions, vous voudrez peut-être penser à utiliser inspect.isfunction . J'espère que vous n'utiliserez pas cette liste à des fins autres que le débogage.

1
AndiDog