Como listar todas as funções em um módulo Python?




python getmembers (12)

Eu tenho um módulo python instalado no meu sistema e gostaria de poder ver quais funções / classes / métodos estão disponíveis nele.

Eu quero chamar a função doc em cada um. Em ruby ​​eu posso fazer algo como ClassName.methods para obter uma lista de todos os métodos disponíveis nessa classe. Existe algo semelhante em python?

por exemplo. algo como:

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

Isso anexará todas as funções definidas em seu_module em uma lista.

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

O módulo inspecionar. Veja também o módulo pydoc , a função help() no interpretador interativo e a ferramenta de linha de comando pydoc que gera a documentação que você está procurando. Você pode apenas dar-lhes a classe que você deseja ver a documentação. Eles também podem gerar, por exemplo, saída HTML e gravá-la em disco.


Você pode usar o seguinte método para obter uma lista de todas as funções do seu módulo a partir do shell:

import module

module.*?

Um exemplo com inspecionar:

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

Você pode substituir a função com qualquer uma das outras funções isXXX no módulo inspecionar.


import types
import yourmodule

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

Para ser completo, gostaria de salientar que às vezes você pode querer analisar o código em vez de importá-lo. Uma import executará expressões de nível superior e isso pode ser um problema.

Por exemplo, estou permitindo que os usuários selecionem funções de ponto de entrada para pacotes que estão sendo feitos com o zipapp . O uso de import e inspect riscos corre o código perdido, levando a falhas, a ajuda de mensagens sendo impressas, diálogos de GUI aparecendo e assim por diante.

Em vez disso, uso o módulo ast para listar todas as funções de nível 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)

Colocando este código em list.py e usando a si mesmo como entrada, recebo:

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

É claro que navegar por um AST pode ser complicado às vezes, mesmo para uma linguagem relativamente simples como o Python, porque o AST é bastante baixo. Mas se você tiver um caso de uso simples e claro, é possível e seguro.

Porém, uma desvantagem é que você não pode detectar funções que são geradas em tempo de execução, como foo = lambda x,y: x*y .


Depois de import o módulo, você pode apenas fazer:

 help(modulename)

... Para obter os documentos sobre todas as funções de uma só vez, interativamente. Ou você pode usar:

 dir(modulename)

... Para simplesmente listar os nomes de todas as funções e variáveis ​​definidas no módulo.


Nenhuma dessas respostas funcionará se você não conseguir importar o dito arquivo Python sem erros de importação. Este foi o caso para mim quando eu estava inspecionando um arquivo que vem de uma grande base de código com muitas dependências. O seguinte processará o arquivo como texto e procurará todos os nomes de método que começam com "def" e os imprime e seus números de linha.

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

Isto irá fazer o truque:

dir(module) 

No entanto, se você achar que é irritante ler a lista retornada, apenas use o loop a seguir para obter um nome por linha.

for i in dir(module): print i

Não é (ou pelo menos não mais) adequado usar o dir (módulo). O código deve ler assim:

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

Ou você especifica o módulo que deseja assim: dir('sys') para produzir resultados a partir do nome do módulo sys. dir() retorna erros enquanto dir('') é o que você precisa. * help ('') retornará informação de ajuda se disponível para a maioria das funções. por exemplo; help('modules') retornará informações de ajuda do módulo.

Obrigado por todos os votos para baixo. Eu estava usando o Python3.2.2 e outras versões 3x quando postei isso. O ponto era usar ('coisas') ao invés do anterior (material). Mas eu estou supondo que você esteja preso no Python2 ou usando versões mais novas para PC que não sejam móveis como eu era.

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


Para funções globais, dir() é o comando a ser usado (como mencionado na maioria dessas respostas), no entanto, ele lista funções públicas e funções não públicas juntas.

Por exemplo, executando:

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

Retorna funções / classes como:

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

Alguns dos quais não são geralmente destinados ao uso de programação geral (mas pelo próprio módulo, exceto no caso de DunderAliases como __doc__ , __file__ ect). Por esse motivo, pode não ser útil listá-los com os públicos (é assim que o Python sabe o que obter ao usar a from module import * ).

__all__ poderia ser usado para resolver este problema, ele retorna uma lista de todas as funções públicas e classes em um módulo (aquelas que não começam com sublinhados - _ ). Alguém pode explicar __all__ em Python? para o uso de __all__ .

Aqui está um exemplo:

>>> 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 as funções e classes com sublinhados foram removidas, deixando apenas aquelas que são definidas como públicas e, portanto, podem ser usadas via import * .

Note que __all__ nem sempre é definido. Se não for incluído, um AttributeError será gerado.

Um caso disso é com o 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__'
>>>

Exceto dir (módulo) ou ajuda (módulo) mencionado nas respostas anteriores, você também pode tentar:
- ipython aberto
- import module_name
- digite module_name, pressione a guia. Ele abrirá uma pequena janela listando todas as funções no módulo python.
Parece muito legal.

Aqui está um trecho listando todas as funções do 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




inspect