पायथन मॉड्यूल में सभी कार्यों को कैसे सूचीबद्ध किया जाए?

Question

मेरे पास मेरे सिस्टम पर एक अजगर मॉड्यूल स्थापित है और मैं यह देखने में सक्षम होना चाहता हूं कि इसमें कौन से कार्य / कक्षाएं / विधियां उपलब्ध हैं।

मैं प्रत्येक पर डॉक्टर फ़ंक्शन को कॉल करना चाहता हूं। रूबी में मैं उस कक्षा पर उपलब्ध सभी विधियों की सूची प्राप्त करने के लिए ClassName.methods जैसा कुछ कर सकता हूं। क्या अजगर में भी कुछ ऐसा ही है?

जैसे। कुछ इस तरह:

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

Comments

कृपया चयनित उत्तर की समीक्षा करने पर विचार करें! अन्य उत्तरों में सुझाए गए समाधानों का उपयोग करना बेहतर / आसान है।

— ज़हरा

Answer 1

inspectमॉड्यूल। यह भी देखें pydocमॉड्यूल, help()इंटरैक्टिव दुभाषिया और में समारोह pydocकमांड लाइन उपकरण है जो प्रलेखन आप के बाद कर रहे हैं उत्पन्न करता है। आप उन्हें केवल वह वर्ग दे सकते हैं, जिसका आप दस्तावेज़ीकरण देखना चाहते हैं। उदाहरण के लिए, वे HTML आउटपुट भी उत्पन्न कर सकते हैं और उसे डिस्क पर लिख सकते हैं।

Comments

मैंने अपने उत्तरast में कुछ स्थितियों में मॉड्यूल का उपयोग करने के लिए मामला बनाया है ।

— सीएसएल

टीएल; डीआर ऑफ द जवाब: नीचे दिए गए dirकार्यों और चर का उपयोग करने के लिए; inspectकेवल कार्यों को फ़िल्टर करने के लिए उपयोग ; और astआयात करने के बिना पार्स करने के लिए उपयोग करें।

— जोनाथन एच

यह शेलजोन द्वारा संक्षेप में बताए गए तरीकों में से प्रत्येक का परीक्षण करने के लायक है क्योंकि परिणामस्वरूप आउटपुट एक समाधान से अगले तक काफी भिन्न होता है।

— clozach

@ हैक आर यहाँ सूची में कोड mymodule में सभी कार्यों है: [inspect.getmembers में च (mymodule, inspect.isfunction) के लिए च [0]]

— SurpriseDog

Answer 2

आप dir(module)सभी उपलब्ध विधियों / विशेषताओं को देखने के लिए उपयोग कर सकते हैं । PyDocs भी देखें।

Comments

यह कड़ाई से सच नहीं है। dir()समारोह "प्रयास सबसे अधिक प्रासंगिक है, बजाय पूरा, जानकारी का उत्पादन करने के लिए"। स्रोत: docs.python.org/library/functions.html#dir ।

— ज़रीन

@jAckOdE उद्धृत? फिर आपको स्ट्रिंग मॉड्यूल के उपलब्ध तरीके और विशेषताएं मिलेंगी।

— ऑरेंजट्यूक्स

@OrangeTux: उफ़, यह एक प्रश्न माना जाता है। हाँ, आपने इसका उत्तर दिया।

— jAckOdE

ओपी स्पष्ट रूप से कार्यों के लिए पूछता है, चर नहीं। Cf उत्तर का उपयोग करते हुए inspect।

— जोनाथन एच

Answer 3

एक बार importमॉड्यूल एड करने के बाद, आप बस कर सकते हैं:

 help(modulename)

... एक ही बार में, सभी कार्यों पर डॉक्स प्राप्त करने के लिए। या आप उपयोग कर सकते हैं:

 dir(modulename)

... बस मॉड्यूल में परिभाषित सभी कार्यों और चर के नाम सूचीबद्ध करने के लिए।

Comments

@ ashjohn ... इस आलोचना का क्या मतलब है? मेरा समाधान भी कार्यों को सूचीबद्ध करता है, और inspect मॉड्यूल चर भी सूचीबद्ध कर सकता है, भले ही यहां स्पष्ट रूप से अनुरोध नहीं किया गया हो। इस समाधान के लिए केवल अंतर्निहित वस्तुओं की आवश्यकता होती है, जो कुछ मामलों में बहुत उपयोगी हो सकते हैं जहां पाइथन विवश / लॉक-डाउन / टूटे हुए वातावरण में स्थापित होता है।

— Dan Lenski

धन्यवाद, यह लगभग काम कर गया, लेकिन मैंने सोचा कि dirपरिणाम प्रिंट करेंगे, हालांकि ऐसा लगता है कि आपको ऐसा करने की आवश्यकता है print(dir(modulename))।

— एलियट

Answer 4

निरीक्षण के साथ एक उदाहरण:

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 (ऑब्जेक्ट_name, object_type) टुपल्स की एक सूची देता है।

आप निरीक्षण मॉड्यूल में किसी भी अन्य .XXX फ़ंक्शन के साथ इस्फ़ंक्शन को बदल सकते हैं।

Comments

getmembersएक विधेय ले सकते हैं, इसलिए आपका उदाहरण भी लिखा जा सकता है: functions_list = [o for o in getmembers(my_module, isfunction)]

— क्रिस्टोफर करी

@ChristopherCurrie, आप बेकार सूची की आशंका से भी बच सकते हैं functions_list = getmembers(my_module, predicate)क्योंकि यह पहले से ही एक सूची देता है;)

— नील

यह पता लगाने के लिए कि फ़ंक्शन उस मॉड्यूल में परिभाषित किया गया है (आयातित के बजाय) जोड़ें: "अगर isfunction (o [1]) और o [1] .__ मॉड्यूल__ == my_module .__ name__ " - ध्यान दें कि यह जरूरी नहीं होगा। आयातित फ़ंक्शन इस मॉड्यूल के समान नाम वाले मॉड्यूल से आता है।

— माइकल स्कॉट कटहबर्ट

Answer 5

import types
import yourmodule

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

Comments

इस मार्ग के लिए, गेटमैटर (yourmodule, a, none) का प्रयोग करें बजाय yourmodule .__ डिक्ट्ड __ के। (a)

— थॉमस वाउचर

your_module .__ dict__ मेरी पसंद है क्योंकि आपको वास्तव में एक ताना युक्त फ़ंक्शन मिलता है नाम: <फ़ंक्शन> और अब आपके पास गतिशील रूप से उस फ़ंक्शन को कॉल करने की क्षमता है। अच्छा समय!

— जश २

कुछ चीनी के साथ पाइथन 3 अनुकूल: आयात प्रकार डिफ प्रिंट_मॉड्यूले_फंक्शंस (मॉड्यूल): प्रिंट ('\ n'.join ([str (मॉड्यूल .__ तानाशाह ___) dir (मॉड्यूल) में) आइंस्टीन (मॉड्यूल) के लिए। __dict __। get (ए), type.unctionType)]))

— y.selivonchyk

यह उन सभी कार्यों को भी सूचीबद्ध करेगा जो मॉड्यूल आयात करते हैं। हो सकता है कि आप क्या चाहते हैं या नहीं।

— स्कैबो

Answer 6

पूर्णता के लिए, मैं यह बताना चाहता हूं कि कभी-कभी आप इसे आयात करने के बजाय कोड पार्स करना चाह सकते हैं । एक शीर्ष-स्तरीय अभिव्यक्तियों importको निष्पादित करेगा , और यह एक समस्या हो सकती है।

उदाहरण के लिए, मैं उपयोगकर्ताओं को जिप्प के साथ बनाए जा रहे पैकेजों के लिए एंट्री पॉइंट फ़ंक्शंस चुनने दे रहा हूँ । भटकने वाले कोड का उपयोग importऔर inspectजोखिम, क्रैश के लिए अग्रणी, संदेशों को मुद्रित करने में मदद करना, जीयूआई संवाद पॉप अप करना और इसी तरह।

इसके बजाय मैं शीर्ष-स्तर के सभी कार्यों को सूचीबद्ध करने के लिए ast मॉड्यूल का उपयोग करता हूं :

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)

इस कोड list.pyको इनपुट के रूप में और स्वयं का उपयोग करते हुए, मुझे प्राप्त होता है:

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

बेशक, एक AST को नेविगेट करना कभी-कभी, यहां तक ​​कि पायथन जैसी अपेक्षाकृत सरल भाषा के लिए भी मुश्किल हो सकता है, क्योंकि एएसटी काफी निम्न-स्तर है। लेकिन अगर आपके पास एक सरल और स्पष्ट उपयोग का मामला है, तो यह उल्लेखनीय और सुरक्षित दोनों है।

हालाँकि, एक नकारात्मक पक्ष यह है कि आप उन कार्यों का पता नहीं लगा सकते हैं जो रनटाइम पर उत्पन्न होते हैं, जैसे foo = lambda x,y: x*y।

Comments

यह मुझे पंसद है; मैं वर्तमान में यह पता लगाने की कोशिश कर रहा हूं कि क्या किसी ने पहले से ही एक उपकरण लिख दिया है जो कि पाइडोक जैसा कुछ करता है लेकिन मॉड्यूल को आयात किए बिना। अब तक यह सबसे अच्छा उदाहरण है जो मुझे मिला है :)

— जेम्स मिल्स

इस जवाब से सहमत हैं। मुझे इस फ़ंक्शन के लिए काम करने की आवश्यकता है, भले ही लक्ष्य फ़ाइल आयात हो या इसके लिए लिखे गए अजगर के किस संस्करण की आवश्यकता हो। यह आयात करने वाले मुद्दों में नहीं चलता है जो आयात और आयात करते हैं।

— एरिक इवांस

मॉड्यूल चर ( __version__आदि) के बारे में कैसे । वहाँ एक तरीका है कि पाने के लिए है?

— frakman1

Answer 7

कोड के लिए जिसे आप पार्स नहीं करना चाहते हैं, मैं ऊपर @ एएससीएल के एएसटी-आधारित दृष्टिकोण की सिफारिश करता हूं।

बाकी सब के लिए, निरीक्षण मॉड्यूल सही है:

import inspect

import <module_to_inspect> as module

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

यह फॉर्म में 2-ट्यूपल की सूची देता है [(<name:str>, <value:function>), ...]।

ऊपर दिया गया सरल उत्तर विभिन्न प्रतिक्रियाओं और टिप्पणियों में संकेत दिया गया है, लेकिन स्पष्ट रूप से नहीं बुलाया गया है।

Comments

इसे वर्तनी के लिए धन्यवाद; मुझे लगता है कि यह सही उत्तर है, यदि आप निरीक्षण करने के लिए मॉड्यूल पर आयात चला सकते हैं।

— जोनाथन एच

Answer 8

यह चाल चलेगा:

dir(module) 

हालाँकि, यदि आप लौटी हुई सूची को पढ़ने के लिए परेशान हैं, तो प्रति पंक्ति एक नाम पाने के लिए बस निम्नलिखित लूप का उपयोग करें।

for i in dir(module): print i

Comments

ओपी स्पष्ट रूप से कार्यों के लिए पूछता है, चर नहीं। Cf उत्तर का उपयोग करते हुए inspect। इसके अलावा, यह @ DanLenski के जवाब से कैसे अलग है?

— जोनाथन एच

Answer 9

dir(module) एक स्क्रिप्ट या मानक दुभाषिया का उपयोग करते समय मानक तरीका है, जैसा कि अधिकांश उत्तरों में उल्लेख किया गया है।

हालाँकि IPython जैसे एक इंटरएक्टिव अजगर खोल के साथ आप मॉड्यूल में परिभाषित सभी वस्तुओं का अवलोकन प्राप्त करने के लिए टैब-पूरा करने का उपयोग कर सकते हैं। यह एक स्क्रिप्ट का उपयोग printकरने और मॉड्यूल में क्या परिभाषित है, यह देखने की तुलना में बहुत अधिक सुविधाजनक है ।

• module.<tab> आपको मॉड्यूल (फ़ंक्शंस, क्लासेस वगैरह) में परिभाषित सभी ऑब्जेक्ट दिखाएगा
• module.ClassX.<tab> आपको एक वर्ग के तरीके और गुण दिखाएंगे
• module.function_xy?या module.ClassX.method_xy?आपको उस फ़ंक्शन / विधि का डॉकस्ट्रिंग दिखाएगा
• module.function_x??या module.SomeClass.method_xy??आपको फ़ंक्शन / विधि का स्रोत कोड दिखाएगा।

Answer 10

वैश्विक कार्यों के लिए dir() लिए उपयोग करने की आज्ञा है (जैसा कि इन उत्तरों में से अधिकांश में वर्णित है), हालांकि यह सार्वजनिक कार्यों और गैर-सार्वजनिक कार्यों दोनों को एक साथ सूचीबद्ध करता है।

उदाहरण के लिए चल रहा है:

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

रिटर्न फ़ंक्शंस / कक्षाएं जैसे:

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

जिनमें से कुछ आम तौर पर सामान्य प्रोग्रामिंग उपयोग के लिए नहीं हैं (लेकिन मॉड्यूल द्वारा ही, DunderAliases जैसे __doc__, __file__ect के मामले में) को छोड़कर । इस कारण से उन्हें सार्वजनिक लोगों के साथ सूचीबद्ध करना उपयोगी नहीं हो सकता है (यह इस प्रकार है कि पायथन को पता है कि उपयोग करते समय क्या प्राप्त करना है from module import *)।

__all__इस समस्या को हल करने के लिए इस्तेमाल किया जा सकता है, यह एक मॉड्यूल में सभी सार्वजनिक कार्यों और वर्गों की सूची देता है (जो अंडरस्कोर के साथ शुरू नहीं होते हैं - _)। देखें Can किसी अजगर में __all__ समझाने?के उपयोग के लिए __all__।

यहाँ एक उदाहरण है:

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

अंडरस्कोर वाले सभी कार्यों और वर्गों को हटा दिया गया है, केवल उन लोगों को छोड़कर जिन्हें सार्वजनिक रूप से परिभाषित किया गया है और इसलिए इनका उपयोग किया जा सकता है import * ।

ध्यान दें कि __all__ हमेशा परिभाषित नहीं किया जाता है। यदि यह शामिल नहीं है तो aAttributeError उठाया है।

इसका एक मामला खगोल मॉड्यूल के साथ है:

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

Answer 11

यदि आप आयात त्रुटियों के बिना पायथन फ़ाइल को आयात करने में असमर्थ हैं, तो इनमें से कोई भी उत्तर काम नहीं करेगा। मेरे लिए यह मामला था, जब मैं एक फाइल का निरीक्षण कर रहा था, जो बहुत अधिक निर्भरता वाले बड़े कोड बेस से आती है। निम्नलिखित फ़ाइल को पाठ के रूप में संसाधित करेगा और सभी विधि नामों की खोज करेगा जो "डीफ़" से शुरू होते हैं और उन्हें और उनकी रेखा संख्या प्रिंट करते हैं।

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

Comments

इस मामले में astमॉड्यूल का उपयोग करना बेहतर है । एक उदाहरण के लिए मेरा जवाब देखें ।

— सीएसएल

मुझे लगता है कि यह एक वैध तरीका है। जब यह होता है तो एक मंदी क्यों?

— m3nda

Answer 12

पिछले उत्तरों में बताए गए dir (मॉड्यूल) या हेल्प (मॉड्यूल) को छोड़कर, आप भी कोशिश कर सकते हैं:
- ipython
- आयात मॉड्यूल_name
- टाइप करें mod_name, टैब दबाएँ। यह अजगर मॉड्यूल में सभी कार्यों को सूचीबद्ध करने के साथ एक छोटी सी खिड़की खोलेगा।
यह बहुत साफ-सुथरा दिखता है।

यहाँ स्निपेट हैशलीब मॉड्यूल के सभी कार्यों को सूचीबद्ध करता है

(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

यह उन सभी कार्यों को जोड़ देगा जो एक सूची में आपके_मॉड्यूल में परिभाषित हैं।

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

Comments

यह क्या है unit8_conversion_methods? क्या यह मॉड्यूल नाम का सिर्फ एक उदाहरण है?

— नोकिंबी

@nocibambi हाँ यह सिर्फ एक मॉड्यूल नाम है।

— मनीष कुमार

धन्यवाद मनीष : मैं के बाद एक लाइन विकल्प का प्रस्ताव[getattr(your_module, func) for func in dir(your_module) if type(getattr(your_module, func)).__name__ == "function"]

— अमाइन

Answer 14

आप शेल से अपने मॉड्यूल में सभी कार्यों को सूचीबद्ध करने के लिए निम्नलिखित विधि का उपयोग कर सकते हैं:

import module

module.*?

Comments

@GabrielFair आप किस संस्करण / मंच पर अजगर चला रहे हैं? मुझे Py3.7 / Win10 पर एक सिंटैक्स त्रुटि मिलती है।

— toonarmycaptain

Answer 15

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

Answer 16

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)

---

आउटपुट:

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