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
This question is related to
python
reflection
module
inspect
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)
Output :
******************************************************************************************
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
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
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
.
This will append all the functions that are defined in your_module in a list.
result=[]
for i in dir(your_module):
if type(getattr(your_module, i)).__name__ == "function":
result.append(getattr(your_module, i))
import types
import yourmodule
print([getattr(yourmodule, a) for a in dir(yourmodule)
if isinstance(getattr(yourmodule, a), types.FunctionType)])
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__'
>>>
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
If you want to get the list of all the functions defined in the current file, you can do it that way:
# Get this script's name.
import os
script_name = os.path.basename(__file__).rstrip(".py")
# Import it from its path so that you can use it as a Python object.
import importlib.util
spec = importlib.util.spec_from_file_location(script_name, __file__)
x = importlib.util.module_from_spec(spec)
spec.loader.exec_module(x)
# List the functions defined in it.
from inspect import getmembers, isfunction
list_of_functions = getmembers(x, isfunction)
As an application example, I use that for calling all the functions defined in my unit testing scripts.
This is a combination of codes adapted from the answers of Thomas Wouters and adrian here, and from Sebastian Rittau on a different question.
You can use the following method to get list all the functions in your module from shell:
import module
module.*?
Use inspect.getmembers
to get all the variables/classes/functions etc. in a module, and pass in inspect.isfunction
as the predicate to get just the functions:
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)
tuples sorted alphabetically by name.
You can replace isfunction
with any of the other isXXX
functions in the inspect
module.
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])
You can use dir(module)
to see all available methods/attributes. Also check out PyDocs.
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?
or module.ClassX.method_xy?
will show you the docstring of that function / methodmodule.function_x??
or module.SomeClass.method_xy??
will show you the source code of the function / method. import sys
from inspect import getmembers, isfunction
fcn_list = [o[0] for o in getmembers(sys.modules[__name__], isfunction)]
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.
Once you've import
ed 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.
The Python documentation provides the perfect solution for this which uses the built-in function dir
.
You can just use dir(module_name) and then it will return a list of the functions within that module.
For example, dir(time) will return
['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'time', 'time_ns', 'timezone', 'tzname', 'tzset']
which is the list of functions the 'time' module contains.
Use vars(module)
then filter out anything that isn't a function using inspect.isfunction
:
import inspect
import my_module
my_module_functions = [f for _, f in vars(my_module).values() if inspect.isfunction(f)]
The advantage of vars
over dir
or inspect.getmembers
is that it returns the functions in the order they were defined instead of sorted alphabetically.
Also, this will include functions that are imported by my_module
, if you want to filter those out to get only functions that are defined in my_module
, see my question Get all defined functions in Python module.
Source: Stackoverflow.com