web-dev-qa-db-fra.com

Comment lister toutes les fonctions dans un module Python?

Un module python est installé sur mon système et j'aimerais pouvoir voir quelles fonctions/classes/méthodes y sont disponibles. 

Je veux appeler la fonction doc sur chacun d'eux. En Ruby, je peux faire quelque chose comme ClassName.methods pour obtenir une liste de toutes les méthodes disponibles dans cette classe. Y at-il quelque chose de similaire en python?

par exemple. quelque chose comme:

from somemodule import foo
print foo.methods # or whatever is the correct method to call
pythonreflectioninspect
316
Chris Gow

Le module inspecter. Voir également le module pydoc , la fonction help() dans l'interpréteur interactif et l'outil de ligne de commande pydoc qui génère la documentation que vous recherchez. Vous pouvez simplement leur donner la classe dont vous souhaitez voir la documentation. Ils peuvent également générer, par exemple, une sortie HTML et l'écrire sur le disque.

108
Thomas Wouters

Vous pouvez utiliser dir(module) pour voir toutes les méthodes/attributs disponibles. Consultez également PyDocs.

412
camflan

Une fois que vous avez imported le module, vous pouvez simplement faire:

 help(modulename)

... Pour obtenir la documentation sur toutes les fonctions à la fois, de manière interactive. Ou vous pouvez utiliser:

 dir(modulename)

... Pour lister simplement les noms de toutes les fonctions et variables définies dans le module.

134
Dan Lenski

Un exemple avec inspect:

from inspect import getmembers, isfunction
from my_project import my_module

functions_list = [o for o in getmembers(my_module) if isfunction(o[1])]

getmembers retourne une liste de tuples (nom_objet, type_objet).

Vous pouvez remplacer sa fonction par l'une des autres fonctions isXXX du module d'inspection.

68
adnan
import types
import yourmodule

print([getattr(yourmodule, a) for a in dir(yourmodule)
  if isinstance(getattr(yourmodule, a), types.FunctionType)])
65
Oli

Par souci d'exhaustivité, j'aimerais souligner que vous pouvez parfois vouloir analyser le code au lieu de l'importer. Un import va exécuter des expressions de niveau supérieur, ce qui pourrait poser problème.

Par exemple, je laisse les utilisateurs sélectionner les fonctions de point d’entrée pour les packages réalisés avec zipapp . Utiliser import et inspect risque d'exécuter du code égaré, d'entraîner des plantages, des messages d'aide en cours d'impression, des dialogues d'interface graphique surgissant, etc.

À la place, j'utilise le module ast pour répertorier toutes les fonctions de niveau supérieur:

import ast
import sys

def top_level_functions(body):
    return (f for f in body if isinstance(f, ast.FunctionDef))

def parse_ast(filename):
    with open(filename, "rt") as file:
        return ast.parse(file.read(), filename=filename)

if __== "__main__":
    for filename in sys.argv[1:]:
        print(filename)
        tree = parse_ast(filename)
        for func in top_level_functions(tree.body):
            print("  %s" % func.name)

En mettant ce code dans list.py et en utilisant lui-même comme entrée, je reçois:

$ python list.py list.py
list.py
  top_level_functions
  parse_ast

Bien sûr, la navigation dans AST peut parfois être délicate, même pour un langage relativement simple comme Python, car le AST est assez bas niveau. Mais si vous avez un cas d'utilisation simple et clair, c'est à la fois faisable et sûr.

Cependant, l'inconvénient est que vous ne pouvez pas détecter les fonctions générées au moment de l'exécution, telles que foo = lambda x,y: x*y.

32
csl

Ça fera l'affaire:

dir(module)

Cependant, si vous trouvez agaçant de lire la liste renvoyée, utilisez simplement la boucle suivante pour obtenir un nom par ligne.

for i in dir(module): print i
23
Algorias

dir(module) est la méthode standard pour utiliser un script ou un interpréteur standard, comme indiqué dans la plupart des réponses.

Cependant, avec un shell python interactif tel que IPython , vous pouvez utiliser la complétion par tabulation pour obtenir une vue d'ensemble de tous les objets définis dans le module. C'est beaucoup plus pratique que d'utiliser un script et print pour voir ce qui est défini dans le module.

  • module.<tab> vous montrera tous les objets définis dans le module (fonctions, classes, etc.)
  • module.ClassX.<tab> va vous montrer les méthodes et les attributs d'une classe
  • module.function_xy? ou module.ClassX.method_xy? vous montrera la docstring de cette fonction/méthode
  • module.function_x?? ou module.SomeClass.method_xy?? vous montrera le code source de la fonction/méthode. 
20
bmu

Pour le code que vous ne souhaitez pas analyser, je recommande l'approche basée sur AST de @csl ci-dessus.

Pour tout le reste, le module inspecter est correct:

import inspect

import <module_to_inspect> as module

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

Ceci donne une liste de 2 tuples sous la forme [(<name:str>, <value:function>), ...].

La réponse simple ci-dessus est évoquée dans diverses réponses et commentaires, mais n'est pas explicitement appelée.

16
Cireo

Pour les fonctions globales, dir() est la commande à utiliser (comme indiqué dans la plupart des réponses), toutefois, elle répertorie les fonctions publiques et les fonctions non publiques. 

Par exemple en cours d'exécution:

>>> import re
>>> dir(re)

Renvoie les fonctions/classes comme:

'__all__', '_MAXCACHE', '_alphanum_bytes', '_alphanum_str', '_pattern_type', '_pickle', '_subx'

Certaines d'entre elles ne sont généralement pas destinées à une utilisation générale de la programmation (mais par le module lui-même, sauf dans le cas de DunderAliases comme __doc__, __file__ ect). Pour cette raison, il peut ne pas être utile de les lister avec les noms publics (c’est ainsi que Python sait quoi obtenir en utilisant from module import *).

__all__ pourrait être utilisé pour résoudre ce problème, il retourne une liste de toutes les fonctions et classes publiques d’un module (celles qui ne font pas commencent par des underscores - _). Voir Quelqu'un peut-il expliquer __all__ en Python? pour l'utilisation de __all__.

Voici un exemple:

>>> import re
>>> re.__all__
['match', 'fullmatch', 'search', 'sub', 'subn', 'split', 'findall', 'finditer', 'compile', 'purge', 'template', 'escape', 'error', 'A', 'I', 'L', 'M', 'S', 'X', 'U', 'ASCII', 'IGNORECASE', 'LOCALE', 'MULTILINE', 'DOTALL', 'VERBOSE', 'UNICODE']
>>>

Toutes les fonctions et classes avec des traits de soulignement ont été supprimées, ne laissant que celles définies comme publiques et pouvant donc être utilisées via import *.

Notez que __all__ n'est pas toujours défini. S'il n'est pas inclus, alors une AttributeError est générée. 

Un cas de cela est avec le module ast:

>>> import ast
>>> ast.__all__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: module 'ast' has no attribute '__all__'
>>>
11
Simon

Aucune de ces réponses ne fonctionnera si vous ne parvenez pas à importer ledit fichier Python sans erreur d'importation. Ce fut le cas pour moi lors de l'inspection d'un fichier provenant d'une base de code volumineuse comportant de nombreuses dépendances. Ce qui suit traitera le fichier en tant que texte et recherchera tous les noms de méthodes commençant par "def" et les imprimera avec leur numéro de ligne.

import re
pattern = re.compile("def (.*)\(")
for i, line in enumerate(open('Example.py')):
  for match in re.finditer(pattern, line):
    print '%s: %s' % (i+1, match.groups()[0])
2
ckb

Sauf dir (module) ou help (module) mentionné dans les réponses précédentes, vous pouvez également essayer:
- Ouvrez ipython 
- import module_name 
- tapez nom_module, appuyez sur la touche de tabulation. Cela ouvrira une petite fenêtre avec la liste de toutes les fonctions du module python. 
Ça a l'air très chouette. 

Voici un extrait listant toutes les fonctions du module hashlib

(C:\Program Files\Anaconda2) C:\Users\lenovo>ipython
Python 2.7.12 |Anaconda 4.2.0 (64-bit)| (default, Jun 29 2016, 11:07:13) [MSC v.1500 64 bit (AMD64)]
Type "copyright", "credits" or "license" for more information.

IPython 5.1.0 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: import hashlib

In [2]: hashlib.
             hashlib.algorithms            hashlib.new                   hashlib.sha256
             hashlib.algorithms_available  hashlib.pbkdf2_hmac           hashlib.sha384
             hashlib.algorithms_guaranteed hashlib.sha1                  hashlib.sha512
             hashlib.md5                   hashlib.sha224
2
Saurya Man Patel

Vous pouvez utiliser la méthode suivante pour obtenir la liste de toutes les fonctions de votre module à partir de Shell:

import module

module.*?
0
Vishal Lamba

Cela va ajouter toutes les fonctions définies dans votre_module dans une liste.

result=[]
for i in dir(unit8_conversion_methods):
    if type(getattr(your_module, i)).__== "function":
        result.append(getattr(your_module, i))
0
Manish Kumar