Jak wyświetlić listę wszystkich funkcji w module Python?

Mam moduł Pythona zainstalowany w moim systemie i chciałbym móc zobaczyć, jakie funkcje / klasy / metody są w nim dostępne.

Chcę wywołać funkcję doc na każdym z nich. W Ruby mogę zrobić coś takiego jak ClassName.methods, aby uzyskać listę wszystkich metod dostępnych w tej klasie. Czy w Pythonie jest coś podobnego?

na przykład. coś jak:

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

inspectModuł. Zobacz także pydocmoduł, help()funkcję interaktywnego interpretera i pydocnarzędzie wiersza poleceń, które generuje poszukiwaną dokumentację. Możesz po prostu dać im klasę, której dokumentację chcesz zobaczyć. Mogą również generować na przykład dane wyjściowe HTML i zapisywać je na dysku.

Możesz użyć, dir(module)aby zobaczyć wszystkie dostępne metody / atrybuty. Sprawdź także PyDocs.

Po importedycji modułu możesz po prostu:

 help(modulename)

... Aby uzyskać dokumenty dotyczące wszystkich funkcji jednocześnie, interaktywnie. Lub możesz użyć:

 dir(modulename)

... Aby po prostu wymienić nazwy wszystkich funkcji i zmiennych zdefiniowanych w module.

Przykład z inspekcją:

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 zwraca listę krotek (nazwa_obiektu, typ_obiektu).

Możesz zastąpić isfunkcję dowolną inną funkcją isXXX w module inspekcji.

import types
import yourmodule

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

Dla kompletności chciałbym zauważyć, że czasami możesz chcieć przeanalizować kod zamiast go importować. importBędzie wykonać wyrażenia najwyższego poziomu, a to może być problem.

Na przykład pozwalam użytkownikom wybrać funkcje punktu wejścia dla pakietów tworzonych za pomocą zipappa . Używanie importi inspectryzyko uruchomienia błędnego kodu, co prowadzi do awarii, pomaga drukować komunikaty, wyświetla się okna dialogowe GUI i tak dalej.

Zamiast tego używam modułu ast , aby wyświetlić listę wszystkich funkcji najwyższego poziomu:

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)

Umieszczając ten kod list.pyi wykorzystując go jako dane wejściowe, otrzymuję:

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

Oczywiście nawigacja w AST może być czasem trudna, nawet w przypadku stosunkowo prostego języka, takiego jak Python, ponieważ poziom AST jest dość niski. Ale jeśli masz prosty i przejrzysty przypadek użycia, jest to wykonalne i bezpieczne.

Jednak wadą jest to, że nie można wykryć funkcji generowanych w czasie wykonywania, takich jak foo = lambda x,y: x*y.

W przypadku kodu, którego nie chcesz analizować, zalecam podejście oparte na AST @csl powyżej.

W pozostałych przypadkach moduł sprawdzania jest poprawny:

import inspect

import <module_to_inspect> as module

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

Daje to listę 2-krotek w formularzu [(<name:str>, <value:function>), ...].

Prosta odpowiedź powyżej jest podana w różnych odpowiedziach i komentarzach, ale nie jest wyraźnie wzywana.

To załatwi sprawę:

dir(module) 

Jeśli jednak irytujesz czytanie przeczytanej listy, po prostu użyj następującej pętli, aby uzyskać jedną nazwę w wierszu.

for i in dir(module): print i

dir(module) jest standardowym sposobem korzystania ze skryptu lub standardowego interpretera, jak wspomniano w większości odpowiedzi.

Jednak dzięki interaktywnej powłoce pythonowej, takiej jak IPython , można użyć tabulacji, aby uzyskać przegląd wszystkich obiektów zdefiniowanych w module. Jest to o wiele wygodniejsze niż używanie skryptu i printsprawdzanie, co jest zdefiniowane w module.

• module.<tab> pokaże wszystkie obiekty zdefiniowane w module (funkcje, klasy i tak dalej)
• module.ClassX.<tab> pokaże metody i atrybuty klasy
• module.function_xy? lub module.ClassX.method_xy? pokaże ci dokumentację tej funkcji / metody
• module.function_x??lub module.SomeClass.method_xy??pokaże kod źródłowy funkcji / metody.

W przypadku funkcji globalnych dir()należy użyć polecenia (jak wspomniano w większości tych odpowiedzi), jednak zawiera ono zarówno funkcje publiczne, jak i funkcje niepubliczne.

Na przykład bieganie:

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

Zwraca funkcje / klasy, takie jak:

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

Niektóre z nich zasadniczo nie są przeznaczone do ogólnego użytku w programowaniu (ale przez sam moduł, z wyjątkiem DunderAliases, takich jak __doc__, __file__ect). Z tego powodu może być nieprzydatne, aby wymienić je na publiczne (w ten sposób Python wie, co uzyskać, używając from module import *).

__all__może być użyty do rozwiązania tego problemu, zwraca listę wszystkich funkcji publicznych i klas w module (tych, które nie zaczynają się od podkreślenia - _). Zobacz Czy ktoś może wyjaśnić __all__ w Pythonie? do użytku __all__.

Oto przykład:

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

Wszystkie funkcje i klasy ze znakami podkreślenia zostały usunięte, pozostawiając tylko te, które są zdefiniowane jako publiczne i dlatego mogą być używane przez import *.

Pamiętaj, że __all__nie zawsze jest zdefiniowane. Jeśli nie jest uwzględniony, to AttributeErrorjest podnoszony.

Przykładem może być moduł ast:

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

Żadna z tych odpowiedzi nie zadziała, jeśli nie będzie można zaimportować wspomnianego pliku Python bez błędów importu. Tak było w przypadku, gdy sprawdzałem plik pochodzący z dużej bazy kodu z wieloma zależnościami. Poniżej przetworzy plik jako tekst i wyszuka wszystkie nazwy metod zaczynające się od „def” i wydrukuje je wraz z numerami wierszy.

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

Poza katalogiem (moduł) lub pomocą (moduł) wspomnianym w poprzednich odpowiedziach możesz także spróbować:
- Otwórz ipython
- import nazwa_modułu
- wpisz nazwa_modułu, naciśnij klawisz tab. Otworzy małe okno z listą wszystkich funkcji w module python.
Wygląda bardzo schludnie.

Oto fragment listy wszystkich funkcji modułu 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

Spowoduje to dodanie do listy wszystkich funkcji zdefiniowanych w module_urządzenia.

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

Możesz użyć następującej metody, aby uzyskać listę wszystkich funkcji w module z powłoki:

import module

module.*?

import sys
from inspect import getmembers, isfunction
fcn_list = [o[0] for o in getmembers(sys.modules[__name__], isfunction)]

r = globals()
sep = '\n'+100*'*'+'\n' # To make it clean to read.
for k in list(r.keys()):
    try:
        if str(type(r[k])).count('function'):
            print(sep+k + ' : \n' + str(r[k].__doc__))
    except Exception as e:
        print(e)

Wynik :

******************************************************************************************
GetNumberOfWordsInTextFile : 

    Calcule et retourne le nombre de mots d'un fichier texte
    :param path_: le chemin du fichier à analyser
    :return: le nombre de mots du fichier

******************************************************************************************

    write_in : 

        Ecrit les donnees (2nd arg) dans un fichier txt (path en 1st arg) en mode a,
        :param path_: le path du fichier texte
        :param data_: la liste des données à écrire ou un bloc texte directement
        :return: None


 ******************************************************************************************
    write_in_as_w : 

            Ecrit les donnees (2nd arg) dans un fichier txt (path en 1st arg) en mode w,
            :param path_: le path du fichier texte
            :param data_: la liste des données à écrire ou un bloc texte directement
            :return: None