How to list all functions in a Python module?

StackOverflow

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

Answer rating: 543

You can use dir(module) to see all available methods/attributes. Also check out PyDocs.

Answer rating: 208

Use the inspect module:

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.

Answer rating: 197

Once you"ve imported the module, you can just do:

help(modulename)

... To get the docs on all the functions at once, interactively. Or you can use:

dir(modulename)

... To simply list the names of all the functions and variables defined in the module.

Answer rating: 58

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 import and 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.





Tutorials