Comment lister toutes les fonctions d'un module Python?

418

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
Chris Gow
la source
3
veuillez examiner la réponse sélectionnée! il existe des solutions meilleures / plus faciles à utiliser suggérées dans d'autres réponses.
Zahra

Réponses:

139

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.

Thomas Wouters
la source
3
J'ai fait valoir l'utilisation du astmodule dans certaines situations dans ma réponse .
csl
28
TL; DR des réponses ci-dessous: utiliser dirpour renvoyer des fonctions et des variables; utiliser inspectpour filtrer les fonctions uniquement; et utiliser astpour analyser sans importer.
Jonathan H
Cela vaut la peine de tester chacune des approches résumées par Sheljohn, car le résultat obtenu est radicalement différent d'une solution à l'autre.
clozach
1
@ Hack-R Voici le code pour lister toutes les fonctions dans mymodule: [f [0] pour f dans inspect.getmembers (mymodule, inspect.isfunction)]
SurpriseDog
498

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

camflan
la source
15
Ce n'est pas strictement vrai. La dir()fonction «tente de produire les informations les plus pertinentes, plutôt que complètes». Source: docs.python.org/library/functions.html#dir .
Zearin
15
@jAckOdE cité? Ensuite, vous obtiendrez les méthodes et les attributs disponibles du module de chaîne.
OrangeTux
@OrangeTux: oups, c'est censé être une question. oui, vous y avez répondu.
jAckOdE
1
L'OP demande clairement des fonctions, pas des variables. Cf répond en utilisant inspect.
Jonathan H
168

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.

Dan Lenski
la source
1
@ sheljohn… quel est l'intérêt de cette critique? Ma solution répertorie également les fonctions, et le inspect module peut également répertorier les variables, même si cela n'est pas explicitement demandé ici. Cette solution ne nécessite que des objets intégrés, ce qui peut être très utile dans certains cas où Python est installé dans un environnement contraint / verrouillé / cassé.
Dan Lenski
Merci, cela a presque fonctionné, mais je pensais que dircela imprimerait les résultats, mais il semble que vous deviez le faire print(dir(modulename)).
Eliot
96

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.

adnan
la source
27
getmemberspeut prendre un prédicat, donc votre exemple pourrait également être écrit: functions_list = [o for o in getmembers(my_module, isfunction)]
Christopher Currie
27
@ChristopherCurrie, vous pouvez également éviter la compréhension inutile de la liste functions_list = getmembers(my_module, predicate)car elle renvoie déjà une liste;)
Nil
5
Pour savoir si la fonction est définie dans ce module (plutôt qu'importée), ajoutez: "if isfunction (o [1]) et o [1] .__ module__ == my_module .__ name__ " - notez que cela ne fonctionnera pas nécessairement si la fonction importée provient d'un module du même nom que ce module.
Michael Scott Cuthbert
72
import types
import yourmodule

print([getattr(yourmodule, a) for a in dir(yourmodule)
  if isinstance(getattr(yourmodule, a), types.FunctionType)])
Oli
la source
8
Pour cet itinéraire, utilisez getattr (yourmodule, a, None) au lieu de yourmodule .__ dict __. Get (a)
Thomas Wouters
4
votre_module .__ dict__ est mon choix car vous obtenez en fait un dict contenant functionName: <function> et vous avez maintenant la possibilité d'appeler cette fonction dynamiquement. bon temps!
2011
1
Python 3 convivial avec du sucre: types d'importation def print_module_functions (module): print ('\ n'.join ([str (module .__ dict __. Get (a) .__ name__) for a in dir (module) if isinstance (module. __dict __. get (a), types.FunctionType)]))
y.selivonchyk
1
Cela répertoriera également toutes les fonctions que ce module importe. Cela peut ou non être ce que vous voulez.
scubbo
48

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.

csl
la source
3
J'aime ça; J'essaie actuellement de savoir si quelqu'un a déjà écrit un outil qui fait quelque chose comme pydoc mais sans importer le module. Jusqu'à présent, c'est le meilleur exemple que j'ai trouvé de cela :)
James Mills
D'accord avec cette réponse. J'ai besoin que cette fonction fonctionne indépendamment de ce que le fichier cible peut importer ou pour quelle version de python il est écrit. Cela ne se heurte pas aux problèmes d'importation que font imp et importlib.
Eric Evans
Que diriez-vous des variables de module ( __version__etc.). Y a-t-il un moyen de l'obtenir?
frakman1
29

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.

Cireo
la source
Merci de l'avoir expliqué; Je pense que c'est la bonne réponse, si vous pouvez exécuter l'importation sur le module à inspecter.
Jonathan H
25

Ç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
Algorias
la source
2
L'OP demande clairement des fonctions, pas des variables. Cf répond en utilisant inspect. En outre, en quoi est-ce différent de la réponse de @ DanLenski?
Jonathan H
20

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.
bmu
la source
19

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__'
>>>
Simon
la source
4

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])
ckb
la source
3
Dans ce cas, il est préférable d'utiliser le astmodule. Voir ma réponse pour un exemple.
csl
Je pense que c'est une méthode valable. Pourquoi un downvote quand il le fait?
m3nda
2

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
Saurya Man Patel
la source
1

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))
Manish Kumar
la source
Qu'est-ce que c'est unit8_conversion_methods? Est-ce juste un exemple du nom du module?
nocibambi
@nocibambi oui c'est juste un nom de module.
Manish Kumar
2
merci Manish. Je propose l'alternative suivante:[getattr(your_module, func) for func in dir(your_module) if type(getattr(your_module, func)).__name__ == "function"]
amine le
0

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

import module

module.*?
Vishal Lamba
la source
1
@GabrielFair sur quelle version / plateforme utilisez-vous python? J'obtiens une erreur de syntaxe sur Py3.7 / Win10.
toonarmycaptain
0
import sys
from inspect import getmembers, isfunction
fcn_list = [o[0] for o in getmembers(sys.modules[__name__], isfunction)]
eid
la source
0
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
Julien Faujanet
la source