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

417

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
Chris Gow
quelle
3
Bitte überprüfen Sie die ausgewählte Antwort! Es gibt bessere / einfacher zu verwendende Lösungen, die in anderen Antworten vorgeschlagen werden.
Zahra

Antworten:

139

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.

Thomas Wouters
quelle
3
Ich habe astin meiner Antwort dafür plädiert, das Modul in bestimmten Situationen zu verwenden .
CSL
28
TL; DR der folgenden Antworten: Verwenden Sie dirdiese Option, um Funktionen und Variablen zurückzugeben. verwenden inspectnur Filterfunktionen; und verwenden, um astzu analysieren, ohne zu importieren.
Jonathan H
Es lohnt sich, jeden der von Sheljohn zusammengefassten Ansätze zu testen, da sich die resultierende Ausgabe von einer Lösung zur nächsten drastisch unterscheidet.
Clozach
1
@ Hack-R Hier ist der Code, um alle Funktionen in mymodule aufzulisten: [f [0] für f in inspect.getmembers (mymodule, inspect.isfunction)]
SurpriseDog
498

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

Camflan
quelle
15
Dies ist nicht unbedingt richtig. Die dir()Funktion "versucht, die relevantesten und nicht die vollständigsten Informationen zu erzeugen". Quelle: docs.python.org/library/functions.html#dir .
Zearin
15
@jAckOdE Zitiert? Dann erhalten Sie verfügbare Methoden und Attribute des String-Moduls.
OrangeTux
@OrangeTux: Ups, das sollte eine Frage sein. Ja, du hast es beantwortet.
jAckOdE
1
Das OP fragt eindeutig nach Funktionen, nicht nach Variablen. Siehe Antworten mit inspect.
Jonathan H
167

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.

Dan Lenski
quelle
1
@ Sheljohn… was ist der Sinn dieser Kritik? Meine Lösung auch listet Funktionen, und das inspect Modul kann auch Listenvariablen, obwohl hier nicht explizit angefordert. Diese Lösung erfordert nur integrierte Objekte. Dies kann in einigen Fällen sehr nützlich sein, in denen Python in einer eingeschränkten / gesperrten / defekten Umgebung installiert ist.
Dan Lenski
Danke, das hat fast funktioniert, aber ich dachte, das dirwürde die Ergebnisse drucken, aber es sieht so aus, als müssten Sie es tun print(dir(modulename)).
Eliot
96

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.

adnan
quelle
27
getmemberskann ein Prädikat nehmen, so dass Ihr Beispiel auch geschrieben werden könnte: functions_list = [o for o in getmembers(my_module, isfunction)]
Christopher Currie
27
@ChristopherCurrie, Sie könnten auch das nutzlose Listenverständnis mit vermeiden, functions_list = getmembers(my_module, predicate)weil es bereits eine Liste zurückgibt;)
Nil
5
Um herauszufinden, ob die Funktion in diesem Modul definiert ist (anstatt importiert zu werden), fügen Sie Folgendes hinzu: "if isfunction (o [1]) und o [1] .__ module__ == my_module .__ name__ " - beachten Sie, dass dies nicht unbedingt funktioniert, wenn Die importierte Funktion stammt von einem Modul mit demselben Namen wie dieses Modul.
Michael Scott Cuthbert
72
import types
import yourmodule

print([getattr(yourmodule, a) for a in dir(yourmodule)
  if isinstance(getattr(yourmodule, a), types.FunctionType)])
Oli
quelle
8
Verwenden Sie für diese Route getattr (Ihr Modul, a, Keine) anstelle Ihres Moduls .__ dict __. Get (a)
Thomas Wouters
4
Ihr_Modul .__ dict__ ist meine Wahl, da Sie tatsächlich ein Diktat erhalten, das functionName: <function> enthält, und Sie jetzt die Möglichkeit haben, diese Funktion dynamisch aufzurufen. gute Zeiten!
Jsh
1
Python 3 freundlich mit etwas Zucker: Importtypen def print_module_functions (Modul): print ('\ n'.join ([str (Modul .__ dict __. Get (a) .__ name__) für ein in dir (Modul) wenn isinstance (Modul). __dict __. get (a), types.FunctionType)]))
y.selivonchyk
Dadurch werden auch alle Funktionen aufgelistet, die dieses Modul importiert. Das kann sein oder auch nicht, was Sie wollen.
Scubbo vor
47

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.

csl
quelle
2
Ich mag das; Ich versuche gerade herauszufinden, ob jemand bereits ein Tool geschrieben hat, das so etwas wie pydoc macht, ohne das Modul zu importieren. Bisher ist dies das beste Beispiel, das ich dafür gefunden habe :)
James Mills
Ich stimme dieser Antwort zu. Diese Funktion muss funktionieren, unabhängig davon, was die Zieldatei importieren darf oder für welche Python-Version sie geschrieben wurde. Dies führt nicht zu den Importproblemen, die imp und importlib verursachen.
Eric Evans
Wie wäre es mit Modulvariablen ( __version__etc). Gibt es einen Weg, das zu bekommen?
frakman1
29

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.

Cireo
quelle
Vielen Dank, dass Sie es formuliert haben. Ich denke, dies ist die richtige Antwort, wenn Sie den Import für das zu inspizierende Modul ausführen können.
Jonathan H
25

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
Algorias
quelle
2
Das OP fragt eindeutig nach Funktionen, nicht nach Variablen. Siehe Antworten mit inspect. Außerdem, wie unterscheidet sich das von @ DanLenskis Antwort?
Jonathan H
20

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.
bmu
quelle
19

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__'
>>>
Simon
quelle
4

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])
ckb
quelle
3
In diesem Fall ist es viel besser, das astModul zu verwenden. Siehe meine Antwort für ein Beispiel.
CSL
Ich denke, das ist eine gültige Methode. Warum eine Ablehnung, wenn es so ist?
m3nda
2

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
Saurya Man Patel
quelle
1

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))
Manish Kumar
quelle
Was ist das unit8_conversion_methods? Ist dies nur ein Beispiel für den Modulnamen?
Nocibambi
@nocibambi ja es ist nur ein Modulname.
Manish Kumar
2
danke Manish. Ich schlage die folgende einzeilige Alternative vor:[getattr(your_module, func) for func in dir(your_module) if type(getattr(your_module, func)).__name__ == "function"]
Amin
0

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

import module

module.*?
Vishal Lamba
quelle
1
@GabrielFair Auf welcher Version / Plattform läuft Python? Ich erhalte einen Syntaxfehler unter Py3.7 / Win10.
ToonarmyCaptain
0
import sys
from inspect import getmembers, isfunction
fcn_list = [o[0] for o in getmembers(sys.modules[__name__], isfunction)]
eid
quelle
0
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
Julien Faujanet
quelle