¿Cómo listar todas las funciones en un módulo de Python?

Tengo un módulo de Python instalado en mi sistema y me gustaría poder ver qué funciones / clases / métodos están disponibles en él.

Quiero llamar a la función doc en cada uno. En ruby ​​puedo hacer algo como ClassName.methods para obtener una lista de todos los métodos disponibles en esa clase. ¿Hay algo similar en python?

p.ej. algo como:

from somemodule import foo print foo.methods # or whatever is the correct method to call 

El módulo de inspección. También vea el módulo pydoc , la función help() en el intérprete interactivo y la herramienta de línea de comandos pydoc que genera la documentación que está buscando. Puede simplemente darles la clase de la que desea ver la documentación. También pueden generar, por ejemplo, la salida HTML y escribirla en el disco.

Puede usar dir(module) para ver todos los métodos / atributos disponibles. También echa un vistazo a PyDocs.

Una vez que haya import el módulo, puede simplemente hacer:

  help(modulename) 

… Para obtener los documentos sobre todas las funciones a la vez, de manera interactiva. O puedes usar:

  dir(modulename) 

… Para simplemente listar los nombres de todas las funciones y variables definidas en el módulo.

Un ejemplo con inspeccionar:

 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 devuelve una lista de tuplas (object_name, object_type).

Puede reemplazar esta función con cualquiera de las otras funciones isXXX en el módulo de inspección.

 import types import yourmodule print([getattr(yourmodule, a) for a in dir(yourmodule) if isinstance(getattr(yourmodule, a), types.FunctionType)]) 

Para completar, me gustaría señalar que a veces es posible que desee analizar el código en lugar de importarlo. Una import ejecutará expresiones de nivel superior, y eso podría ser un problema.

Por ejemplo, estoy permitiendo que los usuarios seleccionen las funciones de punto de entrada para los paquetes que se hacen con zipapp . El uso de la import y la inspect conlleva riesgos al ejecutar un código extraviado, lo que provoca fallos, mensajes de ayuda que se imprimen, aparecen diálogos de GUI, etc.

En su lugar, uso el módulo ast para enumerar todas las funciones de nivel superior:

 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) 

Al poner este código en list.py y usarlo como entrada, obtengo:

 $ python list.py list.py list.py top_level_functions parse_ast 

Por supuesto, navegar por un AST puede ser complicado a veces, incluso para un lenguaje relativamente simple como Python, porque el AST es bastante bajo. Pero si tiene un caso de uso simple y claro, es factible y seguro.

Sin embargo, un inconveniente es que no puede detectar funciones que se generan en tiempo de ejecución, como foo = lambda x,y: x*y .

Esto hará el truco:

 dir(module) 

Sin embargo, si le resulta molesto leer la lista devuelta, solo use el siguiente bucle para obtener un nombre por línea.

 for i in dir(module): print i 

dir(module) es la forma estándar cuando se usa un script o el intérprete estándar, como se menciona en la mayoría de las respuestas.

Sin embargo, con un shell de Python interactivo como IPython , puede usar la función de tabulación para obtener una visión general de todos los objetos definidos en el módulo. Esto es mucho más conveniente, que usar un script e print para ver qué se define en el módulo.

  • module. le mostrará todos los objetos definidos en el módulo (funciones, clases, etc.)
  • module.ClassX. le mostrará los métodos y atributos de una clase
  • module.function_xy? o module.ClassX.method_xy? le mostrará la cadena de documentación de esa función / método
  • module.function_x?? o module.SomeClass.method_xy?? le mostrará el código fuente de la función / método.

Para el código que no desea analizar, recomiendo el enfoque basado en AST de @csl anterior.

Para todo lo demás, el módulo de inspección es correcto:

 import inspect import  as module functions = inspect.getmembers(module, inspect.isfunction) 

Esto da una lista de 2-tuplas en la forma [(, ), ...] .

La respuesta simple anterior se menciona en varias respuestas y comentarios, pero no se menciona explícitamente.

Para funciones globales dir() es el comando a usar (como se menciona en la mayoría de estas respuestas), sin embargo, esto enumera tanto las funciones públicas como las no públicas.

Por ejemplo ejecutando:

 >>> import re >>> dir(re) 

Devuelve funciones / clases como:

 '__all__', '_MAXCACHE', '_alphanum_bytes', '_alphanum_str', '_pattern_type', '_pickle', '_subx' 

Algunos de los cuales generalmente no están destinados para uso de progtwigción general (sino por el propio módulo, excepto en el caso de DunderAliases como __doc__ , __file__ ect). Por esta razón, puede que no sea útil enumerarlos con los públicos (así es como Python sabe qué obtener al usar from module import * ).

__all__ podría usarse para resolver este problema, devuelve una lista de todas las funciones y clases públicas en un módulo (las que no comienzan con guiones bajos – _ ). Ver ¿Puede alguien explicar __all__ en Python? para el uso de __all__ .

Aquí hay un ejemplo:

 >>> 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'] >>> 

Todas las funciones y clases con guiones bajos se han eliminado, dejando solo aquellas que están definidas como públicas y, por lo tanto, se pueden usar a través de la import * .

Tenga en cuenta que __all__ no siempre está definido. Si no está incluido, se genera un AttributeError .

Un caso de esto es con el módulo ast:

 >>> import ast >>> ast.__all__ Traceback (most recent call last): File "", line 1, in  AttributeError: module 'ast' has no attribute '__all__' >>> 

Ninguna de estas respuestas funcionará si no puede importar dicho archivo de Python sin errores de importación. Este fue el caso para mí cuando estaba inspeccionando un archivo que proviene de una base de código grande con muchas dependencias. Lo siguiente procesará el archivo como texto y buscará todos los nombres de métodos que comiencen con “def” e los imprimirá y sus números de línea.

 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]) 

Excepto dir (módulo) o ayuda (módulo) mencionado en las respuestas anteriores, también puede probar:
– Abrir ipython
– import nombre_módulo
– escribe nombre_módulo, presiona tab. Se abrirá una pequeña ventana con una lista de todas las funciones en el módulo de python.
Se ve muy limpio.

Aquí hay un fragmento de todas las funciones del módulo 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 

Puede usar el siguiente método para obtener una lista de todas las funciones de su módulo desde el shell:

import module

 module.*? 

Esto agregará todas las funciones que están definidas en su módulo en una lista.

 result=[] for i in dir(unit8_conversion_methods): if type(getattr(your_module, i)).__name__ == "function": result.append(getattr(your_module, i)) 

No es (o al menos ya no) apropiado usar dir (módulo). El código debería leerse así:

 dir('module') or dir('modules') 

O bien, especifique el módulo que desea así: dir('sys') para producir resultados del nombre del módulo sys. dir() devuelve errores, mientras que dir('') es lo que necesita. * help (”) devolverá información de ayuda si está disponible para la mayoría de las funciones. p.ej; help('modules') devolverá la información de ayuda del módulo.

Gracias por todos los votos a la baja. Estaba usando Python3.2.2 y otras versiones 3x cuando publiqué esto. El punto era usar (‘cosas’) en lugar de las anteriores (cosas). Pero supongo que todo está atascado en Python2 o usando versiones más nuevas para PC que no sean móviles como lo era yo.

http://effbot.org/librarybook/sys.htm