Comment lister toutes les fonctions dans un module Python?

Question

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

Je souhaite appeler la fonction doc sur chacun d'eux. Dans 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

Answer 1

Le module inspect . Voir également le module pydoc , la fonction help() dans le menu interactif. interpréteur et l’outil 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.

Answer 2

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

Answer 3

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

 help(modulename)

... Pour obtenir la documentation sur toutes les fonctions en même temps, 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.

Answer 4

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 sa fonction par l'une des autres fonctions isXXX du module d'inspection.

Answer 5

import types
import yourmodule

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

Answer 6

Par souci d’exhaustivité, je voudrais souligner que vous pouvez parfois vouloir analyser le code au lieu de l’importer. Un import exécutera 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 créés avec zipapp . L'utilisation de inspect et list.py risque d'exécuter du code égaré, d'entraîner des blocages, des messages d'aide en cours d'impression, des dialogues d'interface graphique, etc.

.

A la place, j'utilise le module ast pour répertorier tous les fonctions de haut niveau:

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 dans foo = lambda x,y: x*y et en s’utilisant comme entrée, je reçois:

$ 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 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 à l'exécution, comme <=>.

Answer 7

Cela 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

Answer 8

dir(module) est la méthode standard pour utiliser un script ou un interprète 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 des tabulations 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 de 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.

Answer 9

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 suggérée dans diverses réponses et commentaires, mais n'est pas explicitement appelée.

Answer 10

Pour les fonctions globales dir() est la commande à utiliser (comme indiqué dans la plupart des réponses), cependant, 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 telles que:

'__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 ce qu’il faut 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 ne commencent pas par des underscores - _). Voir Quelqu'un peut-il expliquer __all__ en Python? pour l'utilisation de import *.

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 AttributeError.

Notez que <=> n'est pas toujours défini. S'il n'est pas inclus, un <=> est généré.

C’est le cas du module ast:

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

Answer 11

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 va traiter le fichier en tant que texte et rechercher tous les noms de méthodes commençant par & Quot; def & Quot; et imprimez-les 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])

Answer 12

Sauf dir (module) ou help (module) mentionnés 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.
C'est très chouette.

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

Answer 13

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

import module

module.*?

Answer 14

Ceci ajoutera 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)).__name__ == "function":
        result.append(getattr(your_module, i))

Answer 15

Il n’est pas (ou du moins plus) approprié d’utiliser dir (module). Le code devrait se lire comme ceci:

dir('module') or dir('modules') 

Ou vous spécifiez le module de votre choix comme ceci: dir('sys') pour produire des résultats à partir du nom de module sys. dir() renvoie les erreurs alors que dir('') est ce dont vous avez besoin. * help ('') renvoie les informations d'aide si elles sont disponibles pour la plupart des fonctions. par exemple; help('modules') renverra les informations d'aide du module.

Merci pour tous les votes négatifs. J'utilisais Python3.2.2 et d'autres versions 3x lorsque j'ai posté ceci. Le but était d'utiliser («matériel») au lieu du précédent (matériel). Mais je suppose que vous êtes tous bloqués sur Python2 ou que vous utilisez des versions plus récentes pour PC non mobile comme moi.

http://effbot.org/librarybook/sys.htm