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

Możesz użyć dir(module), aby zobaczyć wszystkie dostępne metody / atrybuty. Zobacz też PyDocs.

Gdy już importedytujesz moduł, możesz po prostu zrobić:

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.

Użycie inspect.getmembers aby uzyskać wszystkie zmienne/klasy / funkcje itp. w module, i przekazać w inspect.isfunction jako predykat do uzyskania tylko funkcji:

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 (object_name, object) posortowanych alfabetycznie według nazwy.

Możesz zastąpić isfunction dowolną z pozostałych isXXX funkcji w inspect Moduł .

import types
import yourmodule

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

Ze względu na kompletność, chciałbym zwrócić uwagę, że czasami możesz chcieć parsować kod zamiast go importować. import wykona wyrażenia najwyższego poziomu, co może być problemem.

Na przykład pozwalam użytkownikom wybrać funkcje punktu wejścia dla pakietów tworzonych za pomocą zipapp. Korzystanie z import i inspect grozi uruchomieniem błędnego kodu, prowadząc do awarii, wydrukowania wiadomości pomocy, pojawiania się okien dialogowych GUI i tak dalej.

Zamiast tego używam moduł ast do listy 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 w list.py i używając samego siebie jako wejścia, otrzymuję:

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

Oczywiście poruszanie się po AST może być czasami trudne, nawet dla stosunkowo prostego języka, takiego jak Python, ponieważ AST jest dość niski poziom. Ale jeśli masz prosty i przejrzysty przypadek użycia, jest to zarówno wykonalne, jak i bezpieczne.

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

Dla kodu, którego nie chcesz analizować, polecam podejście oparte na AST z @csl powyżej.

Dla wszystkiego innego moduł inspect jest poprawny:

import inspect

import <module_to_inspect> as module

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

To daje listę 2-krotek w postaci [(<name:str>, <value:function>), ...].

Powyższa prosta odpowiedź jest podpowiadana w różnych odpowiedziach i komentarzach, ale nie wywoływana wprost.

To wystarczy:

dir(module) 

Jeśli jednak irytujące jest czytanie zwracanej listy, po prostu użyj poniższej pętli, aby uzyskać jedną nazwę dla każdej linii.

for i in dir(module): print i

dir(module) jest standardowym sposobem przy użyciu skryptu lub standardowego interpretera, jak wspomniano w większości odpowiedzi.

Jednak dzięki interaktywnej powłoce Pythona, takiej jak IPython , możesz użyć tab-completion, aby uzyskać przegląd wszystkich obiektów zdefiniowanych w module. Jest to o wiele wygodniejsze niż użycie skryptu i print, aby zobaczyć, co jest zdefiniowane w module.

• module.<tab> wyświetli wszystkie obiekty zdefiniowane w module (funkcje, klasy itd.)
• module.ClassX.<tab> pokaże Ci metody i atrybuty klasy
• module.function_xy? lub module.ClassX.method_xy? pokaże Ci docstring tej funkcji / metody
• module.function_x?? lub module.SomeClass.method_xy?? pokaże Ci kod źródłowy funkcji / metody.

Dla funkcji globalnych {[4] } jest poleceniem do użycia (jak wspomniano w większości tych odpowiedzi), jednak zawiera listę zarówno funkcji publicznych, jak i funkcji niepublicznych razem.

Na przykład:

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

Zwraca funkcje / klasy typu:

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

Niektóre z nich nie są zazwyczaj przeznaczone do ogólnego użytku programistycznego (ale przez sam moduł, z wyjątkiem przypadku DunderAliases, takich jak __doc__, __file__ ect). Z tego powodu nie warto wymieniać ich z publiczne (stąd Python wie, co uzyskać, gdy używa from module import *).

__all__ może być użyty do rozwiązania tego problemu, zwraca listę wszystkich publicznych funkcji i klas w module(te, które Nie zaczynają się od podkreślników- _). Zobacz też Czy ktoś może wyjaśnić _ _ wszystkie _ _ w Pythonie? do stosowania __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 z podkreślnikami zostały usunięte, pozostawiając tylko te, które są zdefiniowane jako publiczne i dlatego może być używany przez import *.

Zauważ, że __all__ nie zawsze jest zdefiniowana. Jeśli nie jest ona uwzględniona, to powstaje AttributeError.

Przypadek jest z modułem 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 będzie działać, jeśli nie możesz zaimportować wspomnianego pliku Pythona bez błędów importu. Tak było w przypadku mnie, gdy sprawdzałem plik, który pochodzi z dużej bazy kodu z wieloma zależnościami. Poniższy plik przetworzy tekst i wyszukuje wszystkie nazwy metod zaczynające się od" def " i wyświetli je wraz z numerami linii.

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

Dokumentacja Pythona zapewnia idealne rozwiązanie, które wykorzystuje wbudowaną funkcję dir.

Możesz po prostu użyć dir (module_name) , a następnie zwróci listę funkcji w tym module.

Na przykład, dir(time) zwróci

['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'time', 'time_ns', 'timezone', 'tzname', 'tzset']

Która jest listą funkcji, które zawiera moduł 'time'.

Oprócz dir (moduł) lub help (moduł) wymienionych w poprzednich odpowiedziach, możesz również spróbować:
- Open ipython
- import module_name
- wpisz module_name, naciśnij tab. Otworzy to małe okno z listą wszystkich funkcji w module Pythona.
Wygląda bardzo schludnie.

Oto fragment z listą 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

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

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

import module

module.*?

To doda wszystkie funkcje zdefiniowane w your_module do listy.

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

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)

Wyjście:

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

Użyj vars(module) następnie odfiltruj wszystko, co nie jest funkcją za pomocą inspect.isfunction:

import inspect
import my_module

my_module_functions = [f for _, f in vars(my_module).values() if inspect.isfunction(f)]

Zaletą vars over dir lub inspect.getmembers polega na tym, że zwraca funkcje w kolejności, w jakiej zostały zdefiniowane, a nie posortowane alfabetycznie.

Będzie to również obejmować funkcje importowane przez my_module, Jeśli chcesz je filtrować, aby uzyskać tylko funkcje zdefiniowane w my_module, Zobacz moje pytanie Get all defined functions in Python moduł .

Jeśli chcesz uzyskać listę wszystkich funkcji zdefiniowanych w bieżący plik, możesz to zrobić w ten sposób:

# Get this script's name.
import os
script_name = os.path.basename(__file__).rstrip(".py")

# Import it from its path so that you can use it as a Python object.
import importlib.util
spec = importlib.util.spec_from_file_location(script_name, __file__)
x = importlib.util.module_from_spec(spec)
spec.loader.exec_module(x)

# List the functions defined in it.
from inspect import getmembers, isfunction
list_of_functions = getmembers(x, isfunction)

Jako przykład aplikacji używam go do wywoływania wszystkich funkcji zdefiniowanych w moich skryptach testów jednostkowych.

Jest to kombinacja kodów zaadaptowanych z odpowiedzi Thomasa Woutersa i Adriana tutaj, oraz z Sebastiana Rittau na inne pytanie.