Wie liste ich alle Funktionen in einem Python-Modul auf?

Ich habe ein Python-Modul auf meinem System installiert und möchte sehen können, welche Funktionen / Klassen / Methoden darin verfügbar sind.

Ich möchte die doc-Funktion für jeden einzelnen aufrufen. In Ruby kann ich so etwas wie ClassName.methods ausführen, um eine Liste aller in dieser Klasse verfügbaren Methoden abzurufen. Gibt es etwas Ähnliches in Python?

z.B. etwas wie:

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

Das inspectModul. Siehe auch das pydocModul, die help()Funktion im interaktiven Interpreter und das pydocBefehlszeilentool, das die Dokumentation generiert, nach der Sie suchen. Sie können ihnen einfach die Klasse geben, deren Dokumentation Sie sehen möchten. Sie können beispielsweise auch HTML-Ausgaben generieren und auf die Festplatte schreiben.

Mit können dir(module)Sie alle verfügbaren Methoden / Attribute anzeigen. Schauen Sie sich auch PyDocs an.

Sobald Sie importdas Modul bearbeitet haben, können Sie einfach Folgendes tun:

 help(modulename)

... um die Dokumente interaktiv auf alle Funktionen gleichzeitig abzurufen. Oder Sie können verwenden:

 dir(modulename)

... um einfach die Namen aller im Modul definierten Funktionen und Variablen aufzulisten.

Ein Beispiel mit inspect:

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 gibt eine Liste von (Objektname, Objekttyp) Tupeln zurück.

Sie können die Funktion durch eine der anderen isXXX-Funktionen im Inspektionsmodul ersetzen.

import types
import yourmodule

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

Der Vollständigkeit halber möchte ich darauf hinweisen, dass Sie manchmal Code analysieren möchten, anstatt ihn zu importieren. Ein importwird ausgeführt Top-Level - Ausdrücke, und das könnte ein Problem sein.

Ich lasse Benutzer beispielsweise Einstiegspunktfunktionen für Pakete auswählen, die mit zipapp erstellt werden . Verwenden von importundinspect riskieren, dass fehlerhafter Code ausgeführt wird, was zu Abstürzen, Ausdrucken von Hilfemeldungen, Auftauchen von GUI-Dialogen usw. führt.

Stattdessen verwende ich das ast- Modul, um alle Funktionen der obersten Ebene aufzulisten:

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)

Wenn list.pyich diesen Code eingebe und mich selbst als Eingabe verwende, erhalte ich:

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

Natürlich kann das Navigieren in einem AST manchmal schwierig sein, selbst für eine relativ einfache Sprache wie Python, da der AST ziemlich niedrig ist. Wenn Sie jedoch einen einfachen und klaren Anwendungsfall haben, ist dieser sowohl machbar als auch sicher.

Ein Nachteil ist jedoch, dass Sie keine Funktionen erkennen können, die zur Laufzeit generiert werden, wie z foo = lambda x,y: x*y.

Für Code, den Sie nicht analysieren möchten, empfehle ich den AST-basierten Ansatz von @csl oben.

Für alles andere ist das Inspektionsmodul korrekt:

import inspect

import <module_to_inspect> as module

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

Dies gibt eine Liste von 2 Tupeln im Formular [(<name:str>, <value:function>), ...].

Die obige einfache Antwort wird in verschiedenen Antworten und Kommentaren angedeutet, aber nicht explizit erwähnt.

Dies wird den Trick machen:

dir(module) 

Wenn Sie es jedoch ärgerlich finden, die zurückgegebene Liste zu lesen, verwenden Sie einfach die folgende Schleife, um einen Namen pro Zeile zu erhalten.

for i in dir(module): print i

dir(module) ist die Standardmethode bei der Verwendung eines Skripts oder des Standardinterpreters, wie in den meisten Antworten erwähnt.

Mit einer interaktiven Python-Shell wie IPython können Sie jedoch mithilfe der Tab-Vervollständigung einen Überblick über alle im Modul definierten Objekte erhalten. Dies ist viel praktischer, als ein Skript zu verwenden und printzu sehen, was im Modul definiert ist.

• module.<tab> zeigt Ihnen alle im Modul definierten Objekte (Funktionen, Klassen usw.)
• module.ClassX.<tab> zeigt Ihnen die Methoden und Attribute einer Klasse
• module.function_xy?oder module.ClassX.method_xy?zeigt Ihnen die Dokumentzeichenfolge dieser Funktion / Methode
• module.function_x??oder module.SomeClass.method_xy??zeigt Ihnen den Quellcode der Funktion / Methode.

Für globale Funktionen dir()ist der zu verwendende Befehl (wie in den meisten dieser Antworten erwähnt), der jedoch sowohl öffentliche als auch nicht öffentliche Funktionen zusammen auflistet.

Zum Beispiel laufen:

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

Gibt Funktionen / Klassen zurück wie:

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

Einige davon sind im Allgemeinen nicht für die allgemeine Programmierung Gebrauch gedacht (aber durch das Modul selbst, außer im Fall von DunderAliases wie __doc__, __file__ect). Aus diesem Grund ist es möglicherweise nicht sinnvoll, sie mit den öffentlichen aufzulisten (so weiß Python, was bei der Verwendung zu bekommen ist from module import *).

__all__könnte verwendet werden, um dieses Problem zu lösen. Es gibt eine Liste aller öffentlichen Funktionen und Klassen in einem Modul zurück (diejenigen, die nicht mit Unterstrichen beginnen - _). Siehe Kann jemand __all__ in Python erklären? für die Verwendung von __all__.

Hier ist ein Beispiel:

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

Alle Funktionen und Klassen mit Unterstrichen wurden entfernt, sodass nur diejenigen übrig bleiben, die als öffentlich definiert sind und daher über verwendet werden können import *.

Beachten Sie, dass dies __all__nicht immer definiert ist. Wenn es nicht enthalten ist, dann einAttributeError ausgelöst.

Ein Fall hierfür ist das ast-Modul:

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

Keine dieser Antworten funktioniert, wenn Sie diese Python-Datei nicht ohne Importfehler importieren können. Dies war bei mir der Fall, als ich eine Datei inspizierte, die aus einer großen Codebasis mit vielen Abhängigkeiten stammt. Im Folgenden wird die Datei als Text verarbeitet und nach allen Methodennamen gesucht, die mit "def" beginnen, und sie und ihre Zeilennummern gedruckt.

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

Mit Ausnahme von dir (Modul) oder help (Modul), die in den vorherigen Antworten erwähnt wurden, können Sie auch
Folgendes versuchen: - Öffnen Sie ipython
- importieren Sie den Modulnamen
- geben Sie den Modulnamen ein und drücken Sie die Tabulatortaste. Es öffnet sich ein kleines Fenster mit einer Auflistung aller Funktionen im Python-Modul.
Es sieht sehr ordentlich aus.

Hier ist ein Ausschnitt, der alle Funktionen des Hashlib-Moduls auflistet

(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

Dadurch werden alle in your_module definierten Funktionen in einer Liste angehängt.

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

Mit der folgenden Methode können Sie alle Funktionen in Ihrem Modul aus der Shell auflisten:

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)

Ausgabe :

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