Come elencare tutte le funzioni in un modulo Python?

Question

Ho un modulo python installato sul mio sistema e mi piacerebbe essere in grado di vedere quali funzioni/classi/metodi sono disponibili in esso.

Voglio chiamare il doc funzione di ciascuno di essi.In ruby che posso fare qualcosa di simile ClassName.metodi per ottenere un elenco di tutti i metodi disponibili per quella classe.C'è qualcosa di simile in python?

es.qualcosa di simile a:

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

Answer 1

Il inspect modulo.Vedi anche il pydoc modulo, il help() funzione interprete interattivo e pydoc strumento da riga di comando che genera la documentazione che si sono dopo.Si può solo dare loro la classe che si desidera vedere la documentazione.Essi possono anche generare, per esempio, l'output HTML e scrivere sul disco.

Answer 2

È possibile utilizzare dir(module) per vedere tutti i metodi/attributi.Controllare anche PyDocs.

Answer 3

Una volta imported il modulo, si può semplicemente fare:

 help(modulename)

...Per ottenere la documentazione di tutte le funzioni in una sola volta, in modo interattivo.Oppure è possibile utilizzare:

 dir(modulename)

...Semplicemente elencare i nomi di tutte le funzioni e le variabili definite nel modulo.

Answer 4

Un esempio con ispezionare:

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 restituisce una lista di (object_name, object_type) tuple.

È possibile sostituire isfunction con una qualsiasi delle altre isXXX funzioni nel ispezionare modulo.

Answer 5

import types
import yourmodule

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

Answer 6

Per completezza, vorrei sottolineare che a volte si desidera analizzare il codice invece di importarlo.Un import sarà eseguire top a livello di espressioni, e che potrebbe essere un problema.

Per esempio, mi sto lasciando agli utenti di selezionare il punto di ingresso di funzioni per i pacchetti con zipapp.Utilizzando import e inspect i rischi di esecuzione di traviamento codice, che porta a crash, messaggi di aiuto in fase di stampati, pannelli GUI popping up e così via.

Invece io uso l' ast modulo per elencare tutte le funzioni di primo livello:

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)

Mettendo questo codice list.py e utilizzando la stessa come ingresso per ottenere:

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

Naturalmente, la navigazione di un AST può essere a volte difficile, anche per un semplice linguaggio come Python, perché l'AST è abbastanza di basso livello.Ma se si dispone di un chiaro e semplice caso d'uso, è fattibile e sicuro.

Se, il rovescio della medaglia è che non è possibile rilevare le funzioni che vengono generati a runtime, come foo = lambda x,y: x*y.

Answer 7

Questo farà il trucco:

dir(module) 

Tuttavia, se si trovano fastidioso leggere l'elenco restituito, basta usare il seguente ciclo per ottenere un nome per riga.

for i in dir(module): print i

Answer 8

dir(module) è il modo standard quando si utilizza uno script o standard interprete, come menzionato in molte risposte.

Tuttavia, con un interattivo shell di python come IPython è possibile utilizzare il completamento automatico per ottenere una panoramica di tutti gli oggetti definiti nel modulo.Questo è molto più conveniente rispetto all'utilizzo di uno script e print per vedere ciò che è definito nel modulo.

• module.<tab> mostra tutti gli oggetti definiti nel modulo (funzioni, classi e così via)
• module.ClassX.<tab> mostra i metodi e gli attributi di una classe
• module.function_xy? o module.ClassX.method_xy? vi mostrerà la docstring della funzione / metodo di
• module.function_x?? o module.SomeClass.method_xy?? mostra il codice sorgente della funzione / metodo.

Answer 9

Per il codice che non si desidera analizzare, mi raccomando l'AST approccio, basato @csl di cui sopra.

Per tutto il resto, la ispezionare modulo è corretto:

import inspect

import <module_to_inspect> as module

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

Questo dà un elenco di 2-tuple in forma [(<name:str>, <value:function>), ...].

La semplice risposta di cui sopra è accennato nelle varie risposte e commenti, ma non in modo esplicito.

Answer 10

Per le funzioni globali dir() è il comando da utilizzare (come accennato nella maggior parte di queste risposte), tuttavia questo è un elenco di entrambe le funzioni pubbliche e non pubbliche funzioni.

Per esempio, eseguendo:

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

Restituisce funzioni/classi come:

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

Alcuni dei quali non sono in genere progettati per la programmazione in generale l'uso (ma dal modulo stesso, salvo il caso di DunderAliases come __doc__, __file__ ect).Per questo motivo non può essere utile per ottenere un elenco con il pubblico (questo è come Python sa cosa cercare quando si utilizza from module import *).

__all__ potrebbe essere utilizzato per risolvere questo problema, restituisce un elenco di tutte le pubbliche funzioni e classi in un modulo (quelli che non iniziare con il carattere di sottolineatura - _).Vedere Qualcuno può spiegare __tutti__ in Python? per l'uso di __all__.

Ecco un esempio:

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

Tutte le funzioni e le classi con il carattere di sottolineatura sono stati rimossi, lasciando solo quelli che sono definiti come pubblico e possono quindi essere utilizzati tramite import *.

Nota che __all__ non è sempre definito.Se non è incluso quindi un AttributeError è cresciuto.

Un caso di questo è con l'ast modulo:

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

Answer 11

Nessuna di queste risposte funzionerà se si è in grado di importare tale file Python senza errori di importazione.Questo è stato il caso per me, quando mi stava ispezionando un file che viene da una grande base di codice con un sacco di dipendenze.Il seguente processo il file come file di testo e la ricerca di tutti i nomi dei metodi che iniziano con "def" e di stampa, loro e i loro numeri di riga.

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

Tranne dir(modulo) o la guida(modulo) menzionato nella risposta precedente, si può anche provare:
- Aprire ipython
- importazione nome_modulo
- tipo di nome_modulo, premere il tasto tab.Si aprirà una piccola finestra con l'elenco di tutte le funzioni del modulo di python.
Sembra molto carino.

Qui è snippet elenco di tutte le funzioni del modulo 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

È possibile utilizzare il metodo riportato di seguito per ottenere l'elenco di tutte le funzioni del modulo da shell:

import module

module.*?

Answer 14

Questo aggiungerà tutte le funzioni che sono definite in your_module in un elenco.

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

Answer 15

Non è (o almeno non più) corretto usare il dir(modulo).Il codice dovrebbe essere simile a questo:

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

O si specifica che il modulo che si desidera in questo modo: dir('sys') per produrre risultati dal nome del modulo sys. dir() restituisce errori, mentre dir('') è ciò di cui avete bisogno.*guida in linea(") sarà un ritorno di informazioni se sono disponibili per la maggior parte delle funzioni.ad esempio; help('modules') tornerà modulo di informazioni di aiuto.

Grazie per tutti i voti negativi.Stavo usando Python3.2.2 e in altri 3x versioni, quando ho postato questo.Il punto era quello di utilizzare (' roba ') al posto del precedente ( roba ).Ma sto presupponendo che tutti bloccati su Python2 o utilizzando le più recenti versioni per PC non mobile come lo ero io.

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