问题
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 doc 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
回答1:
The inspect module. 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.
回答2:
You can use dir(module) to see all available methods/attributes. Also check out PyDocs.
回答3:
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.
回答4:
An example with 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 returns a list of (object_name, object_type) tuples.
You can replace isfunction with any of the other isXXX functions in the inspect module.
回答5:
import types
import yourmodule
print([getattr(yourmodule, a) for a in dir(yourmodule)
if isinstance(getattr(yourmodule, a), types.FunctionType)])
回答6:
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.
回答7:
This will do the trick:
dir(module)
However, if you find it annoying to read the returned list, just use the following loop to get one name per line.
for i in dir(module): print i
回答8:
For code that you do not wish to parse, I recommend the AST-based approach of @csl above.
For everything else, the inspect module is correct:
import inspect
import <module_to_inspect> as module
functions = inspect.getmembers(module, inspect.isfunction)
This gives a list of 2-tuples in the form [(<name:str>, <value:function>), ...].
The simple answer above is hinted at in various responses and comments, but not called out explicitly.
回答9:
dir(module) is the standard way when using a script or the standard interpreter, as mentioned in most answers.
However with an interactive python shell like IPython you can use tab-completion to get an overview of all objects defined in the module.
This is much more convenient, than using a script and print to see what is defined in the module.
module.<tab>will show you all objects defined in the module (functions, classes and so on)module.ClassX.<tab>will show you the methods and attributes of a classmodule.function_xy?ormodule.ClassX.method_xy?will show you the docstring of that function / methodmodule.function_x??ormodule.SomeClass.method_xy??will show you the source code of the function / method.
回答10:
For global functions dir() is the command to use (as mentioned in most of these answers), however this lists both public functions and non-public functions together.
For example running:
>>> import re
>>> dir(re)
Returns functions/classes like:
'__all__', '_MAXCACHE', '_alphanum_bytes', '_alphanum_str', '_pattern_type', '_pickle', '_subx'
Some of which are not generally meant for general programming use (but by the module itself, except in the case of DunderAliases like __doc__, __file__ ect). For this reason it may not be useful to list them with the public ones (this is how Python knows what to get when using from module import *).
__all__ could be used to solve this problem, it returns a list of all the public functions and classes in a module (those that do not start with underscores - _). See
Can someone explain __all__ in Python? for the use of __all__.
Here is an example:
>>> 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']
>>>
All the functions and classes with underscores have been removed, leaving only those that are defined as public and can therefore be used via import *.
Note that __all__ is not always defined. If it is not included then an AttributeError is raised.
A case of this is with the ast module:
>>> import ast
>>> ast.__all__
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: module 'ast' has no attribute '__all__'
>>>
回答11:
None of these answers will work if you are unable to import said Python file without import errors. This was the case for me when I was inspecting a file which comes from a large code base with a lot of dependencies. The following will process the file as text and search for all method names that start with "def" and print them and their line numbers.
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])
回答12:
Except dir(module) or help(module) mentioned in previous answers, you can also try:
- Open ipython
- import module_name
- type module_name, press tab. It'll open a small window with listing all functions in the python module.
It looks very neat.
Here is snippet listing all functions of hashlib module
(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
回答13:
You can use the following method to get list all the functions in your module from shell:
import module
module.*?
回答14:
This will append all the functions that are defined in your_module in a list.
result=[]
for i in dir(unit8_conversion_methods):
if type(getattr(your_module, i)).__name__ == "function":
result.append(getattr(your_module, i))
来源：https://stackoverflow.com/questions/139180/how-to-list-all-functions-in-a-python-module