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

Question

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.¿Existe algo similar en Python?

p.ej.algo como:

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

Answer 1

El inspect módulo. Consulte también el pydoc , la función help() en el interactivo intérprete y la herramienta de línea de comandos <=> que genera la documentación que busca. Puede darles la clase de la que desea ver la documentación. También pueden generar, por ejemplo, salida HTML y escribirla en el disco.

Answer 2

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

Answer 3

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

 help(modulename)

... Para obtener los documentos en todas las funciones a la vez, de forma interactiva. O puede usar:

 dir(modulename)

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

Answer 4

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 isfunction con cualquiera de las otras funciones isXXX en el módulo de inspección.

Answer 5

import types
import yourmodule

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

Answer 6

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

Por ejemplo, estoy permitiendo a los usuarios seleccionar funciones de punto de entrada para paquetes creados con zipapp.Usando import y inspect corre el riesgo de ejecutar código extraviado, lo que provoca fallas, la impresión de mensajes de ayuda, la aparición de cuadros de diálogo GUI, etc.

En lugar de eso uso el ast módulo 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)

Poniendo este código list.py y usándose a sí mismo 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 de nivel bastante bajo.Pero si tiene un caso de uso simple y claro, es factible y seguro.

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

Answer 7

Esto hará el truco:

dir(module) 

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

for i in dir(module): print i

Answer 8

dir(module) es la forma estándar cuando se utiliza 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 finalizació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 y print para ver qué se define en el módulo.

• module.<tab> le mostrará todos los objetos definidos en el módulo (funciones, clases, etc.)
• module.ClassX.<tab> le mostrará los métodos y atributos de una clase
• module.function_xy? o module.ClassX.method_xy? le mostrará la cadena de documentos 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.

Answer 9

Para el código que no desea analizar, le 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 <module_to_inspect> as module

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

Esto proporciona una lista de 2 tuplas en el formulario [(<name:str>, <value:function>), ...].

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

Answer 10

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 juntas.

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 el uso de programación general (sino por el módulo en sí, excepto en el caso de DunderAliases como __doc__, __file__ ect). Por esta razón, puede no ser ú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 ¿Alguien puede explicar __all__ en Python? para el uso de import *.

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

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

Tenga en cuenta que <=> no siempre se define. Si no está incluido, se genera un <=>.

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

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

Answer 11

Ninguna de estas respuestas funcionará si no puede importar dicho archivo Python sin errores de importación. Este fue el caso para mí cuando estaba inspeccionando un archivo que proviene de una gran base de código con muchas dependencias. Lo siguiente procesará el archivo como texto y buscará todos los nombres de métodos que comiencen con & Quot; def & Quot; e imprimirlos 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])

Answer 12

Excepto dir (módulo) o ayuda (módulo) mencionado en respuestas anteriores, también puede intentar:
 - Abrir ipython
 - importar nombre_módulo
 - escriba module_name, presione tab. Se abrirá una pequeña ventana con una lista de todas las funciones en el módulo de Python.
Se ve muy bien.

Aquí hay un fragmento que enumera 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

Answer 13

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

import module

module.*?

Answer 14

Esto agregará todas las funciones que se definen en your_module 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))

Answer 15

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

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

O puede especificar el módulo que desea de esta manera: 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 negativos. Estaba usando Python3.2.2 y otras versiones 3x cuando publiqué esto. El punto era usar ('cosas') en lugar de las (cosas) anteriores. Pero supongo que todo está atascado en Python2 o que estoy usando versiones más nuevas para PC que no son móviles como yo.

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