I have a Python module installed on my system and I"d like to be able to see what functions/classes/methods are available in it.
I want to call the
help function on each one. In Ruby I can do something like
ClassName.methods to get a list of all the methods available on that class. Is there something similar in Python?
eg. something like:
from somemodule import foo print(foo.methods) # or whatever is the correct method to call
You can use
dir(module) to see all available methods/attributes. Also check out PyDocs.
from inspect import getmembers, isfunction from somemodule import foo print(getmembers(foo, isfunction))
Also see the
pydoc module, the
help() function in the interactive interpreter and the
pydoc command-line tool which generates the documentation you are after. You can just give them the class you wish to see the documentation of. They can also generate, for instance, HTML output and write it to disk.
imported the module, you can just do:
... To get the docs on all the functions at once, interactively. Or you can use:
... To simply list the names of all the functions and variables defined in the module.
For completeness" sake, I"d like to point out that sometimes you may want to parse code instead of importing it. An
import will execute top-level expressions, and that could be a problem.
For example, I"m letting users select entry point functions for packages being made with zipapp. Using
inspect risks running astray code, leading to crashes, help messages being printed out, GUI dialogs popping up and so on.
Instead I use the ast module to list all the top-level functions:
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)
Putting this code in
list.py and using itself as input, I get:
$ python list.py list.py list.py top_level_functions parse_ast
Of course, navigating an AST can be tricky sometimes, even for a relatively simple language like Python, because the AST is quite low-level. But if you have a simple and clear use case, it"s both doable and safe.
Though, a downside is that you can"t detect functions that are generated at runtime, like
foo = lambda x,y: x*y.