real - matplotlib python

¿Cómo listar 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. ¿Hay 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 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 pydoc . 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.

Answer 2

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

Answer 3

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

Answer 4

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 listado 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

Answer 5

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á junto con 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 6

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 a partir 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

Answer 7

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 funciones de punto de entrada para 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 de muy bajo nivel. 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 .

Answer 8

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 <module_to_inspect> as module

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

Esto da una lista de 2-tuplas en la forma [(<name:str>, <value:function>), ...] .

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

Answer 9

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 programació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 "<stdin>", line 1, in <module>
AttributeError: module ''ast'' has no attribute ''__all__''
>>>

Answer 10

Puede usar dir(module) para ver todos los métodos / atributos disponibles. También puedes ver PyDocs.

Answer 11

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

import module

module.*?

Answer 12

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 13

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.

Answer 14

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

Answer 15

import types
import yourmodule

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