objects - python getmembers




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

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.

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

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

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


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.


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

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 .


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.


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

dir(module) é o modo padrão ao usar um script ou o interpretador padrão, como mencionado na maioria das respostas.

No entanto, com um shell python interativo como o IPython, você pode usar o preenchimento de tabulação para obter uma visão geral de todos os objetos definidos no módulo. Isso é muito mais conveniente do que usar um script e print para ver o que está definido no módulo.

  • module.<tab> mostrará todos os objetos definidos no módulo (funções, classes e assim por diante)
  • module.ClassX.<tab> mostrará os métodos e atributos de uma classe
  • module.function_xy? ou module.ClassX.method_xy? irá mostrar-lhe o docstring dessa função / método
  • module.function_x?? ou module.SomeClass.method_xy?? mostrará o código-fonte da função / método.




inspect