Comment lister toutes les fonctions d'un module Python?

J'ai un module python 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 sur cette classe. Y a-t-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

Le inspectmodule. Voir également le pydocmodule, la help()fonction dans l'interpréteur interactif et l' pydocoutil de ligne de commande 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.

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

Une fois que vous avez importédité le module, vous pouvez simplement faire:

 help(modulename)

... Pour obtenir les documents 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.

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 renvoie une liste de tuples (nom_objet, type_objet).

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

import types
import yourmodule

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

Par souci d'exhaustivité, je voudrais souligner que parfois vous pouvez vouloir analyser le code au lieu de l'importer. Un importva exécuter des expressions de haut niveau, et qui pourrait être un problème.

Par exemple, je laisse les utilisateurs sélectionner des fonctions de point d'entrée pour les packages créés avec zipapp . Utiliser importet inspectrisquer d'exécuter du code erroné, conduisant à des plantages, à l'impression de messages d'aide, à l'apparition de boîtes de dialogue GUI, etc.

Au lieu de cela, 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 __name__ == "__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 list.pyet en utilisant lui-même comme entrée, j'obtiens:

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

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

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

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 d'inspection est correct:

import inspect

import <module_to_inspect> as module

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

Cela donne une liste de 2 tuples dans le formulaire [(<name:str>, <value:function>), ...].

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

Ça fera l'affaire:

dir(module) 

Cependant, si vous trouvez ennuyeux de lire la liste retournée, utilisez simplement la boucle suivante pour obtenir un nom par ligne.

for i in dir(module): print i

dir(module) est le moyen standard lors de l'utilisation d'un script ou de l'interpréteur standard, comme mentionné dans la plupart des réponses.

Cependant, avec un shell python interactif comme IPython, vous pouvez utiliser la complétion de 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 printde 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> vous montrera 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.

Pour les fonctions globales dir() c'est la commande à utiliser (comme mentionné dans la plupart de ces réponses), mais elle répertorie à la fois les fonctions publiques et les fonctions non publiques.

Par exemple en cours d'exécution:

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

Renvoie des fonctions / classes comme:

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

Certains d'entre eux ne sont généralement pas destinés à 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 répertorier avec les public (c'est ainsi que Python sait quoi obtenir lors de l'utilisation from module import *).

__all__pourrait être utilisé pour résoudre ce problème, il renvoie une liste de toutes les fonctions et classes publiques dans un module (celles qui ne commencent pas par des traits de soulignement - _). 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 qui sont définies comme publiques et peuvent donc être utilisées via import * .

Notez que ce __all__n'est pas toujours défini. S'il n'est pas inclus, un AttributeErrorest levé.

Un cas de ceci 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__'
>>>

Aucune de ces réponses ne fonctionnera si vous ne parvenez pas à importer ledit fichier Python sans erreurs d'importation. Ce fut le cas pour moi lorsque j'inspectais un fichier provenant d'une grande base de code avec beaucoup de dépendances. Les éléments suivants traiteront le fichier sous forme de texte et rechercheront tous les noms de méthode commençant par «def» et les imprimeront ainsi que leurs numéros 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])

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

Voici un extrait répertoriant 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

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

result=[]
for i in dir(your_module):
    if type(getattr(your_module, i)).__name__ == "function":
        result.append(getattr(your_module, i))

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

import module

module.*?

import sys
from inspect import getmembers, isfunction
fcn_list = [o[0] for o in getmembers(sys.modules[__name__], isfunction)]

r = globals()
sep = '\n'+100*'*'+'\n' # To make it clean to read.
for k in list(r.keys()):
    try:
        if str(type(r[k])).count('function'):
            print(sep+k + ' : \n' + str(r[k].__doc__))
    except Exception as e:
        print(e)

Production :

******************************************************************************************
GetNumberOfWordsInTextFile : 

    Calcule et retourne le nombre de mots d'un fichier texte
    :param path_: le chemin du fichier à analyser
    :return: le nombre de mots du fichier

******************************************************************************************

    write_in : 

        Ecrit les donnees (2nd arg) dans un fichier txt (path en 1st arg) en mode a,
        :param path_: le path du fichier texte
        :param data_: la liste des données à écrire ou un bloc texte directement
        :return: None


 ******************************************************************************************
    write_in_as_w : 

            Ecrit les donnees (2nd arg) dans un fichier txt (path en 1st arg) en mode w,
            :param path_: le path du fichier texte
            :param data_: la liste des données à écrire ou un bloc texte directement
            :return: None